windows-xp/Source/XPSP1/NT/enduser/troubleshoot/tshoot/htmlfrag.cpp

//
// MODULE: HTMLFrag.cpp
//
// PURPOSE: implementation of the CHTMLFragmentsTS class, which is how CInfer packages
//	up fragments of HTML to be rendered in accord with a template
//
// PROJECT: Generic Troubleshooter DLL for Microsoft AnswerPoint
//
// COMPANY: Saltmine Creative, Inc. (206)-284-7511 [email protected]
//
// AUTHOR: Joe Mabel
// 
// ORIGINAL DATE: 8-27-1998
//
// NOTES: 
//
// Version	Date		By		Comments
//--------------------------------------------------------------------
// V3.0		7-20-98		JM		Original
//
//////////////////////////////////////////////////////////////////////

#pragma warning(disable:4786)

#include "stdafx.h"
#include <algorithm>
#include "HTMLFrag.h"
#include "event.h"
#include "baseexception.h"
#include "CharConv.h"
#include "fileread.h"
#ifdef LOCAL_TROUBLESHOOTER
#include "CHMFileReader.h"
#endif

// V3.2 Additions.
namespace
{
	const CString kstrCond_StringCompare=		_T("StringCompare");
	const CString kstrCond_OperatorGT=		_T(".GT.");
	const CString kstrCond_OperatorGE=		_T(".GE.");
	const CString kstrCond_OperatorEQ=		_T(".EQ.");
	const CString kstrCond_OperatorNE=		_T(".NE.");
	const CString kstrCond_OperatorLE=		_T(".LE.");
	const CString kstrCond_OperatorLT=		_T(".LT.");
	const CString kstrCond_OperatorSubstring=	_T(".SubstringOf.");
}

//////////////////////////////////////////////////////////////////////
// CHTMLValue implementation
//////////////////////////////////////////////////////////////////////

bool CHTMLValue::SetValue(const CString& value)
{
	CString strOldValue = m_strValValue;
	m_strValValue = value;
	m_strValValue.TrimLeft();
	m_strValValue.TrimRight();
	if (IsValid())
		return true;
	m_strValValue = strOldValue;
	return false;
}

bool CHTMLValue::IsNumeric()
{
	for (int i = 0; i < m_strValValue.GetLength(); i++)
		if(!_ismbcdigit(m_strValValue[i]))
			return false;
	return true;
}

bool CHTMLValue::IsString()
{
	// string should be wrapped by quots
	if (m_strValValue.GetLength() >= 2 &&
		m_strValValue[0] == _T('"') &&
		m_strValValue[m_strValValue.GetLength()-1] == _T('"')
	   )
	   return true;
	return false;
}

bool CHTMLValue::IsBoolean()
{
	return 0 == _tcsicmp(_T("true"), m_strValValue) || 
		   0 == _tcsicmp(_T("false"), m_strValValue);
}

bool CHTMLValue::GetNumeric(long& out)
{
	if (IsNumeric())
	{
		out = _ttol(m_strValValue);
		return true;
	}
	return false;
}

bool CHTMLValue::GetString(CString& out)
{
	if (IsString())
	{
		out = m_strValValue.Mid(1, m_strValValue.GetLength()-2);
		return true;
	}
	return false;
}

bool CHTMLValue::GetBoolean(bool& out)
{
	if (IsBoolean())
	{
		out = (0 == _tcsicmp(_T("true"), m_strValValue)) ? true : false;
		return true;
	}
	return false;
}

bool CHTMLValue::operator == (const CHTMLValue& sib)
{
	return 0 == _tcsicmp(m_strValName, sib.m_strValName); // case insensitive
}

//////////////////////////////////////////////////////////////////////
// CHTMLFragments implementation
//////////////////////////////////////////////////////////////////////

bool CHTMLFragments::SetValue(const CString& str)
{
	int index = str.Find(_T('='));
	
	if (index == -1)
		return false;

	CString name = str.Left(index);
	name.TrimLeft();
	name.TrimRight();

	CString value= str.Right(str.GetLength() - index - 1);
	value.TrimLeft();
	value.TrimRight();

	CHTMLValue HTMLValue(name, value);
	
	HTMLValueVector::iterator found = find(m_HTMLValueVector.begin(), m_HTMLValueVector.end(), HTMLValue);
	
	if (found != m_HTMLValueVector.end())
		*found = HTMLValue;
	else
		m_HTMLValueVector.push_back(HTMLValue);

	return true;
}

CHTMLValue* CHTMLFragments::GetValue(const CString& value_name)
{
	HTMLValueVector::iterator found = find(m_HTMLValueVector.begin(), m_HTMLValueVector.end(), CHTMLValue(value_name));
	if (found != m_HTMLValueVector.end())
		return found;
	return NULL;
}

//////////////////////////////////////////////////////////////////////
// CHTMLFragmentsTS implementation
//////////////////////////////////////////////////////////////////////

CHTMLFragmentsTS::CHTMLFragmentsTS( const CString & strScriptPath, bool bIncludesHistoryTable ) :
	m_bIncludesHistoryTable(bIncludesHistoryTable),
	m_bIncludesHiddenHistory(!bIncludesHistoryTable),
	m_bSuccess(false),
	m_strYes(_T("Yes")),
    m_strScriptPath(strScriptPath)
{
}

CHTMLFragmentsTS::~CHTMLFragmentsTS()
{
}

// Obviously, a very ad hoc implementation
int CHTMLFragmentsTS::GetCount(const FragmentIDVector & fidvec) const
{
	if (fidvec.empty())
		return 0;

	if (fidvec.back().Index != -1)
		return 0;

	const CString & strVariable = fidvec[0].VarName;	// ref of convenience

	if (fidvec.size() == 1)
	{
		if (strVariable == VAR_PROBLEM_ASK)
			return 1;
		if (strVariable == VAR_RECOMMENDATIONS)
			return m_vstrVisitedNodes.size();
		if (strVariable == VAR_QUESTIONS)
			return 1;
		if (strVariable == VAR_SUCCESS)
			return m_bSuccess ? 1 : 0;
		if (strVariable == VAR_STARTFORM)
			return 1;

		return 0;
	}

	if (fidvec.size() == 2 
	&& strVariable == VAR_RECOMMENDATIONS
	&& fidvec[0].Index >= 0
	&& fidvec[0].Index < m_vvstrStatesOfVisitedNodes.size()
	&& fidvec[1].VarName == VAR_STATES)
	{
		return m_vvstrStatesOfVisitedNodes[fidvec[0].Index].size();
	}

	return 0;
}

// this function was removed from const to achieve further flexibility:
//  we might need to take some active steps in it, as for informational
//  statement we might modify current node text. Oleg. 01.05.99
CString CHTMLFragmentsTS::GetText( const FragmentIDVector & fidvec, const FragCommand fragCmd )
{
	if (fidvec.empty())
		return m_strNil;

	const CString & strVariable0 = fidvec[0].VarName;	// ref of convenience
	int i0 = fidvec[0].Index;

	if (fidvec.size() == 1)
	{
		if (strVariable0 == VAR_PROBLEM_ASK)
			return m_strProblem;

		if (strVariable0 == VAR_RECOMMENDATIONS
		&& i0 >= 0
		&& i0 < m_vstrVisitedNodes.size() )
		{
			return m_vstrVisitedNodes[i0];
		}

		if (strVariable0 == VAR_QUESTIONS)
			return m_strCurrentNode;

		if (strVariable0 == VAR_SUCCESS)
			return m_bSuccess ? m_strYes : m_strNil;

		if (strVariable0 == VAR_STARTFORM)
			return m_strStartForm;

		if (fragCmd == eResource)
		{
			// Load a server side include file.
			CString strScriptContent;
			CString strFullPath = m_strScriptPath + strVariable0;

			CFileReader fileReader(	CPhysicalFileReader::makeReader( strFullPath ) );

			if (fileReader.Read())
			{
				fileReader.GetContent(strScriptContent);
				return strScriptContent;
			}
		}

		// Check for new conditionals added in V3.2.
		CString strTemp= strVariable0.Left( kstrCond_NumericCompare.GetLength() );
		if (strTemp == kstrCond_NumericCompare)
		{
			// Evaluate the numeric expression.
			if (NumericConditionEvaluatesToTrue( strVariable0.Mid( kstrCond_NumericCompare.GetLength() )))
				return( m_strYes );
			return( m_strNil );
		}
		strTemp= strVariable0.Left( kstrCond_StringCompare.GetLength() );
		if (strTemp == kstrCond_StringCompare)
		{
			// Evaluate the string expression.
			if (StringConditionEvaluatesToTrue( strVariable0.Mid( kstrCond_StringCompare.GetLength() )))
				return( m_strYes );
			return( m_strNil );
		}

		return m_strNil;
	}


	const CString & strVariable1 = fidvec[1].VarName;	// ref of convenience
	int i1 = fidvec[1].Index;

	if (fidvec.size() == 2 
	&& strVariable0 == VAR_RECOMMENDATIONS
	&& i0 >= 0
	&& i0 < m_vvstrStatesOfVisitedNodes.size()
	&& strVariable1 == VAR_STATES
	&& i1 >= 0
	&& i1 < m_vvstrStatesOfVisitedNodes[i0].size() )
		return (m_vvstrStatesOfVisitedNodes[i0][i1]);

	// V3.2
	// The specification for the v3.2 cookies called for permitting underscores
	// in cookie names.  The HTI reader already used underscores to delimit
	// variables.  The code below detects a comparision operation that has been
	// broken up due to the presence of underscores and reassembles it.
	// RAB-19991019.
	{
		// Check for new conditionals added in V3.2.
		int nOpType= 0;
		CString strTemp= strVariable0.Left( kstrCond_NumericCompare.GetLength() );
		if (strTemp == kstrCond_NumericCompare)
			nOpType= 1;
		else
		{
			strTemp= strVariable0.Left( kstrCond_StringCompare.GetLength() );
			if (strTemp == kstrCond_StringCompare)
				nOpType= 2;
		}

		if (nOpType)
		{
			// Reassemble the comparison operation.  
			CString strCompareOp= fidvec[0].VarName;
			for (int nItem= 1; nItem < fidvec.size(); nItem++)
			{
				strCompareOp+= _T("_");	// Reinsert the delimiter that was removed during the parse.
				strCompareOp+= fidvec[ nItem ].VarName;
			}

			if (nOpType == 1)
			{
				// Evaluate the numeric expression.
				if (NumericConditionEvaluatesToTrue( strCompareOp.Mid( kstrCond_NumericCompare.GetLength() )))
					return( m_strYes );
			}
			else
			{
				// Evaluate the string expression.
				if (StringConditionEvaluatesToTrue( strCompareOp.Mid( kstrCond_StringCompare.GetLength() )))
					return( m_strYes );
			}

			return( m_strNil );
		}
	}

	return m_strNil;
}

bool CHTMLFragmentsTS::IsValidSeqOfVars(const FragmentIDVector & arrParents, const FragmentIDVector & arrChildren) const
{
	// we allow only one level of nesting
	//  that means in "forany" of $Recommendations we can have "forany" array of $States
	if (arrParents.size() == 1 && arrChildren.size() == 1)
		if (arrParents[0].VarName == VAR_RECOMMENDATIONS  && arrChildren[0].VarName == VAR_STATES)
			return true;
	return false;
}

void CHTMLFragmentsTS::SetStartForm(const CString & str)
{
	m_strStartForm = str;
}
	
void CHTMLFragmentsTS::SetProblemText(const CString & str)
{
	if (m_bIncludesHistoryTable)
		m_strProblem = str;
}
	
void CHTMLFragmentsTS::SetCurrentNodeText(const CString & str)
{
	m_strCurrentNodeSimple = str;
	RebuildCurrentNodeText();
}

void CHTMLFragmentsTS::SetHiddenHistoryText(const CString & str)
{
	if (m_bIncludesHiddenHistory)
	{
		m_strHiddenHistory = str;
		RebuildCurrentNodeText();
	}
}

// need only be called for bSuccess == true (false is default) but written more generally.
void CHTMLFragmentsTS::SetSuccessBool(bool bSuccess)
{
	m_bSuccess = bSuccess;
}
	
CString CHTMLFragmentsTS::GetCurrentNodeText()
{
	return m_strCurrentNodeSimple;
}

// must be called in order nodes were visited.  Do not call for problem node.
// return index of added node
int CHTMLFragmentsTS::PushBackVisitedNodeText(const CString & str)
{
	if (m_bIncludesHistoryTable)
	{
		try
		{
			m_vstrVisitedNodes.push_back(str);
		}
		catch (exception& x)
		{
			CString str;
			// Note STL exception in event log.
			CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
			CEvent::ReportWFEvent(	SrcLoc.GetSrcFileLineStr(), 
									SrcLoc.GetSrcFileLineStr(), 
									CCharConversion::ConvertACharToString(x.what(), str), 
									_T(""), 
									EV_GTS_STL_EXCEPTION ); 
		}
		return m_vstrVisitedNodes.size() - 1;
	}
	return -1;
}

// For each given iVisitedNode, must be called in order of state number, 
//	with ST_UNKNOWN last
// return index of added state
int CHTMLFragmentsTS::PushBackStateText(UINT iVisitedNode, const CString & str)
{
	if (m_bIncludesHistoryTable)
	{
		try
		{
			// Check if we need to add one or more elements to the vector of nodes.
			if (m_vvstrStatesOfVisitedNodes.size() <= iVisitedNode)
			{
				// Check if we need to add more than one element to the vector of nodes.
				if (m_vvstrStatesOfVisitedNodes.size() < iVisitedNode)
				{
					// We need to add more than one element to the vector of nodes.
					// This condition should not be occurring, so log it.
					CString tmpStrCurCnt, tmpStrReqCnt;

					tmpStrCurCnt.Format( _T("%d"), m_vvstrStatesOfVisitedNodes.size() );
					tmpStrReqCnt.Format( _T("%d"), iVisitedNode );
					CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
					CEvent::ReportWFEvent(	SrcLoc.GetSrcFileLineStr(), 
											SrcLoc.GetSrcFileLineStr(), 
											tmpStrCurCnt, tmpStrReqCnt, 
											EV_GTS_NODE_COUNT_DISCREPANCY );  


					// Add to the vector of nodes until we have placed a total of
					// iVisitedNode elements into the vector.  We are inserting empty
					// states as the first element of the vector of states for a node.
					vector<CString> vecDummy;
					vecDummy.push_back( _T("") );
					do
					{
						m_vvstrStatesOfVisitedNodes.push_back( vecDummy );
					}
					while (m_vvstrStatesOfVisitedNodes.size() < iVisitedNode);
				}

				// Add this state string as the first element of the vector of states for a node.
				vector<CString> tmpVector;
				tmpVector.push_back( str );
				m_vvstrStatesOfVisitedNodes.push_back( tmpVector );
			}
			else
			{
				// Add this state string to the vector of states for a node.
				m_vvstrStatesOfVisitedNodes[iVisitedNode].push_back(str);
			}
		}
		catch (exception& x)
		{
			CString str;
			// Note STL exception in event log.
			CBuildSrcFileLinenoStr SrcLoc( __FILE__, __LINE__ );
			CEvent::ReportWFEvent(	SrcLoc.GetSrcFileLineStr(), 
									SrcLoc.GetSrcFileLineStr(), 
									CCharConversion::ConvertACharToString(x.what(), str), 
									_T(""),
									EV_GTS_STL_EXCEPTION ); 
		}
		return m_vvstrStatesOfVisitedNodes[iVisitedNode].size() - 1;
	}
	return -1;
}

// call this function to find out if there is any need for a history table.
// If not, calling class can save the effort of constructing one:
//	SetProblemText(), AppendVisitedNodeText(), AppendStateText()
//	becomes no-ops, so no need to construct strings and call them
bool CHTMLFragmentsTS::IncludesHistoryTable() const
{
	return m_bIncludesHistoryTable;
}

// call this function to find out if there is any need for "hidden history"
// If not, calling class can save the effort of constructing one:
//	SetHiddenHistoryText() becomes a no-op, so no need to construct a string and call it
bool CHTMLFragmentsTS::IncludesHiddenHistory() const
{
	return m_bIncludesHiddenHistory;
}

void CHTMLFragmentsTS::RebuildCurrentNodeText()
{
	m_strCurrentNode = m_strHiddenHistory;
	m_strCurrentNode += m_strCurrentNodeSimple; 
}


// Function which parses and evaluates a numeric condition.
bool CHTMLFragmentsTS::NumericConditionEvaluatesToTrue( const CString & str )
{
	bool bRetVal= false;
	CString strScratch= RemoveOuterParenthesis( str );

	if (strScratch.GetLength())
	{
		long lLeftOperand, lRightOperand;

		// Check for all supported operators.
		if (RetNumericOperands( strScratch, kstrCond_OperatorGT, lLeftOperand, lRightOperand ))
		{
			// .GT. case.
			bRetVal= (lLeftOperand > lRightOperand) ? true : false;
		}
		else if (RetNumericOperands( strScratch, kstrCond_OperatorGE, lLeftOperand, lRightOperand ))
		{
			// .GE. case.
			bRetVal= (lLeftOperand >= lRightOperand) ? true : false;
		}
		else if (RetNumericOperands( strScratch, kstrCond_OperatorEQ, lLeftOperand, lRightOperand ))
		{
			// .EQ. case.
			bRetVal= (lLeftOperand == lRightOperand) ? true : false;
		}
		else if (RetNumericOperands( strScratch, kstrCond_OperatorNE, lLeftOperand, lRightOperand ))
		{
			// .NE. case.
			bRetVal= (lLeftOperand != lRightOperand) ? true : false;
		}
		else if (RetNumericOperands( strScratch, kstrCond_OperatorLE, lLeftOperand, lRightOperand ))
		{
			// .LE. case.
			bRetVal= (lLeftOperand <= lRightOperand) ? true : false;
		}
		else if (RetNumericOperands( strScratch, kstrCond_OperatorLT, lLeftOperand, lRightOperand ))
		{
			// .LT. case.
			bRetVal= (lLeftOperand < lRightOperand) ? true : false;
		}
	}

	return( bRetVal );
}


// Function which parses and evaluates a string condition.
bool CHTMLFragmentsTS::StringConditionEvaluatesToTrue( const CString & str )
{
	bool bRetVal= false;
	CString strScratch= RemoveOuterParenthesis( str );

	if (strScratch.GetLength())
	{
		CString strLeftOperand, strRightOperand;

		// Check for all supported operators.
		if (RetStringOperands( strScratch, kstrCond_OperatorEQ, strLeftOperand, strRightOperand ))
		{
			if ((strLeftOperand.GetLength() == strRightOperand.GetLength()) &&
				(_tcsicmp( strLeftOperand, strRightOperand ) == 0))
				bRetVal= true;
		}
		else if (RetStringOperands( strScratch, kstrCond_OperatorNE, strLeftOperand, strRightOperand ))
		{
			if ((strLeftOperand.GetLength() != strRightOperand.GetLength()) ||
				(_tcsicmp( strLeftOperand, strRightOperand ) != 0))
				bRetVal= true;
		}
		else if (RetStringOperands( strScratch, kstrCond_OperatorSubstring, strLeftOperand, strRightOperand ))
		{
			int nLeftLen= strLeftOperand.GetLength();
			int nRightLen= strRightOperand.GetLength();
			if ((nLeftLen) && (nRightLen) && (nLeftLen <= nRightLen))
			{
				strLeftOperand.MakeLower();
				strRightOperand.MakeLower();
				if (_tcsstr( strRightOperand, strLeftOperand ) != NULL)
					bRetVal= true;
			}
		}
	}

	return( bRetVal );
}


// Function to peel off the outer parenthesis of a condition.
CString CHTMLFragmentsTS::RemoveOuterParenthesis( const CString & str )
{
	CString strRet;
	int	nOrigLength= str.GetLength();

	if (nOrigLength > 2)
	{
		TCHAR cFirstChar= str.GetAt( 0 );
		TCHAR cLastChar= str.GetAt( nOrigLength - 1 );

		if ((cFirstChar == _T('(')) && (cLastChar == _T(')')))
			strRet= str.Mid( 1, nOrigLength - 2 );
	}
	return( strRet );
}


// Breaks out the numeric operands from a string.
bool CHTMLFragmentsTS::RetNumericOperands(	const CString & str, const CString & strOperator,
											long &lLeftOperand, long &lRightOperand )
{
	bool	bRetVal= false;
	int		nOffset= str.Find( strOperator );

	if (nOffset != -1)
	{
		CString strScratch= str.Left( nOffset - 1 );

		strScratch.TrimRight();
		strScratch.TrimLeft();
		if (strScratch.GetLength())
		{
			lLeftOperand= atol( strScratch );

			strScratch= str.Mid( nOffset + strOperator.GetLength() );
			strScratch.TrimRight();
			strScratch.TrimLeft();
			if (strScratch.GetLength())
			{
				lRightOperand= atol( strScratch );
				bRetVal= true;
			}
		}
	}

	return( bRetVal );
}


// Breaks out the string operands from a string.
bool CHTMLFragmentsTS::RetStringOperands(	const CString & str, const CString & strOperator,
											CString & strLeftOperand, CString & strRightOperand )
{
	bool	bRetVal= false;
	int		nOffset= str.Find( strOperator );

	if (nOffset != -1)
	{
		strLeftOperand= str.Left( nOffset - 1 );
		if (CleanStringOperand( strLeftOperand ))
		{
			strRightOperand= str.Mid( nOffset + strOperator.GetLength() );
			strRightOperand.TrimRight();
			strRightOperand.TrimLeft();
			if (CleanStringOperand( strRightOperand ))
				bRetVal= true;
		}
	}

	return( bRetVal );
}

// Trims an operand string and replaces embedded characters.
int CHTMLFragmentsTS::CleanStringOperand( CString& strOperand )
{
	int nRetLength= 0;
	if (!strOperand.IsEmpty())
	{
		strOperand.TrimRight();
		strOperand.TrimLeft();
		nRetLength= strOperand.GetLength();
		if (nRetLength > 2)
		{
			if ((strOperand[ 0 ] == _T('\"')) && (strOperand[ nRetLength - 1 ] == _T('\"')))
			{
				// V3.2 Remove the surrounding double quotes.
				nRetLength-= 2;
				strOperand= strOperand.Mid( 1, nRetLength );
			}

			// V3.2  Replace embedded quotes or backslashes within the string.
			for (int nOp= 0; nOp < 2; nOp++)
			{
				// Set the search and replacement strings.
				CString strSearch, strReplace;
				if (nOp)
				{
					// Replace backslashes.
					strSearch= _T("\\\\");
					strReplace= _T("\\");
				}
				else
				{
					// Replace double quotes.
					strSearch= _T("\\\"");
					strReplace= _T("\"");
				}

				// Search and replace.
				int nStart= 0, nEnd;
				while (CString::FIND_FAILED != (nStart= strOperand.Find( strSearch, nStart )))
				{
					nEnd= nStart + strSearch.GetLength();
					strOperand= strOperand.Left( nStart ) + strReplace + strOperand.Mid( nEnd );
					nStart+= strReplace.GetLength();	// Move search past the character that was just replaced.
				}
			}
		}
	}

	return( nRetLength );
}

// JSM V3.2
// called by HTIReader in parsing stage to convert network property name, given
// in  <$GTS property "propname">, to network property (value).
//
CString CHTMLFragmentsTS::GetNetProp(const CString & strNetPropName)
{
	map<CString,CString>::iterator it = m_mapstrNetProps.find(strNetPropName);

	if (it == m_mapstrNetProps.end())
		return _T("\0"); // not found
	else 
		return (*it).second;
}

// JSM V3.2
//  add a name to the internal list (map) of Net props which are needed
//   by this Fragments object
//
//    CAPGTSHTIReader finds the names of the network properties and passes
//       them in via AddNetPropName, but it doesn't know how to get the values.
//    CInfer will later get the network property names from Fragments object, call the BNTS
//       to find out the network property values, and supply the values to Fragments
//
// 
void CHTMLFragmentsTS::AddNetPropName(const CString & strNetPropName)
{
	// don't insert a NULL key!!!
	if (!strNetPropName.IsEmpty())
		m_mapstrNetProps[strNetPropName];
}

// JSM V3.2
// SetNetProp()
//
//  For a Network Property Name in our internal map, set the
//  corresponding network property (ie, fill in the map value
//   for that key.) Called by CInfer, which is the object that knows how
//   to talk to the BNTS.
//
// returns TRUE if success
//         FALSE if we've given a NetPropName which is not in the internal map
// 
BOOL CHTMLFragmentsTS::SetNetProp(CString strNetPropName, CString strNetProp)
{
	map<CString,CString>::iterator it;

	if ((it= m_mapstrNetProps.find(strNetPropName)) == m_mapstrNetProps.end())
		return false;

	m_mapstrNetProps[strNetPropName] = strNetProp;
	return true;
}

// JSM V3.2
// IterateNetProp()
//  Called to iterate through the network properties in our internal
//  map during the setting process (see above.)
//
//     Sets strNameIterator to the name of the next net prop in the map. 
//
//     calling w/ an empty (NULL) key starts the iteration.
//     calling w/ a name that's not in the map returns false.
//     calling w/ any other name returns true, unless at end of iteration
//
//   strNameIterator is not valid if this function returns false. 
// 
BOOL CHTMLFragmentsTS::IterateNetProp(CString & strNameIterator)
{
	map<CString,CString>::iterator it;

	if (strNameIterator.IsEmpty())
	{
		// request to start iteration, if possible
		if (m_mapstrNetProps.empty())
			return false; // we're at end already
		it = m_mapstrNetProps.begin();
	}
	else if ((it= m_mapstrNetProps.find(strNameIterator)) != m_mapstrNetProps.end())
	{
		// iterate:
		if (++it == m_mapstrNetProps.end())
			return false;   // arrived at end
	}
	else
	{
		// invalid key 
		return false;
	}

	strNameIterator = (*it).first;
	return true;

}

// V3.2 enhancement for the Start Over button.
void CHTMLFragmentsTS::SetStartOverLink( const CString & str )
{
	m_strStartOverLink = str;
}

// V3.2 enhancement for the Start Over button.
CString CHTMLFragmentsTS::GetStartOverLink()
{
	return m_strStartOverLink;
}