HRESULT CHtmlEditCtrl2::PrintPreview()
{
	return ExecHelperNN(IDM_PRINTPREVIEW);
}

HRESULT CHtmlEditCtrl2::PrintPreview(LPCTSTR szPrintTemplate)
{
	return ExecHelperSetVal(IDM_PRINTPREVIEW, szPrintTemplate);
}

HRESULT CHtmlEditCtrl2::Bold()
{
	return ExecHelperNN(IDM_BOLD);
}

HRESULT CHtmlEditCtrl2::StrikeOut()
{
	return ExecHelperNN(IDM_STRIKETHROUGH);
}

HRESULT CHtmlEditCtrl2::Copy()
{
	return ExecHelperNN(IDM_COPY);
}

HRESULT CHtmlEditCtrl2::Cut()
{
	return ExecHelperNN(IDM_CUT);
}

HRESULT CHtmlEditCtrl2::Delete()
{
	return ExecHelperNN(IDM_DELETE);
}

HRESULT CHtmlEditCtrl2::Indent()
{
	return ExecHelperNN(IDM_INDENT);
}

HRESULT CHtmlEditCtrl2::Italic()
{
	return ExecHelperNN(IDM_ITALIC);
}

HRESULT CHtmlEditCtrl2::LineBreakNormal()
{
	return ExecHelperNN(IDM_LINEBREAKNORMAL);
}

HRESULT CHtmlEditCtrl2::JustifyCenter()
{
	return ExecHelperNN(IDM_JUSTIFYCENTER);
}

HRESULT CHtmlEditCtrl2::JustifyLeft()
{
	return ExecHelperNN(IDM_JUSTIFYLEFT);
}

HRESULT CHtmlEditCtrl2::JustifyRight()
{
	return ExecHelperNN(IDM_JUSTIFYRIGHT);
}

HRESULT CHtmlEditCtrl2::Outdent()
{
	return ExecHelperNN(IDM_OUTDENT);
}

HRESULT CHtmlEditCtrl2::Paste()
{
	return ExecHelperNN(IDM_PASTE);
}

HRESULT CHtmlEditCtrl2::RemoveFormat()
{
	return ExecHelperNN(IDM_REMOVEFORMAT);
}

HRESULT CHtmlEditCtrl2::SelectAll()
{
	return ExecHelperNN(IDM_SELECTALL);
}

HRESULT CHtmlEditCtrl2::Underline()
{
	return ExecHelperNN(IDM_UNDERLINE);
}

HRESULT CHtmlEditCtrl2::Unlink()
{
	return ExecHelperNN(IDM_UNLINK);
}

HRESULT CHtmlEditCtrl2::ClearSelection()
{
	return ExecHelperNN(IDM_CLEARSELECTION);
}

HRESULT CHtmlEditCtrl2::Font()
{
	return ExecHelperNN(IDM_FONT);
}

BOOL CHtmlEditCtrl2::QueryDocumentState(BSTR a_bstrItemToQuery)
{
	if(PrepareInterfaces() == FALSE)
	{
		return FALSE;
	}

	VARIANT_BOOL vOut = 0;
	m_pHtmlDoc->queryCommandState(a_bstrItemToQuery, &vOut);
	return (vOut == VARIANT_TRUE);
}

BOOL CHtmlEditCtrl2::IsBold()
{
	return QueryDocumentState(L"Bold");
}

BOOL CHtmlEditCtrl2::IsUnderline()
{
	return QueryDocumentState(L"Underline");
}

BOOL CHtmlEditCtrl2::IsItalic()
{
	return QueryDocumentState(L"Italic");
}

BOOL CHtmlEditCtrl2::IsStrikeOut()
{
	return QueryDocumentState(L"StrikeThrough");
}

BOOL CHtmlEditCtrl2::CanPaste() //IZ TO DO
{
	if(PrepareInterfaces() == FALSE)
	{
		return FALSE;
	}

	VARIANT_BOOL vOut = 0;
	m_pHtmlDoc->queryCommandEnabled(L"Paste", &vOut);
	return (vOut == VARIANT_TRUE);
}

HRESULT CHtmlEditCtrl2::PasteHTMLAtCurrentSelection(const CString& a_sHTMLText, BOOL a_bSetCursorAtBeginingOfInsertedText)
{
	if(PrepareInterfaces() == FALSE)
	{
		return E_FAIL;
	}

	IHTMLSelectionObject* pSelection;
	m_hResult = m_pHtmlDoc->get_selection(&pSelection);
	if(SUCCEEDED(m_hResult) && pSelection)
	{
		IDispatch* pTextRangeDisp;
		m_hResult = pSelection->createRange(&pTextRangeDisp);
		if(SUCCEEDED(m_hResult) && pTextRangeDisp)
		{
			IHTMLTxtRange* pRange;
			m_hResult = pTextRangeDisp->QueryInterface(IID_IHTMLTxtRange, (void**)&pRange);
			if(SUCCEEDED(m_hResult) && pRange)
			{
				BSTR bstrText = a_sHTMLText.AllocSysString();
				m_hResult = pRange->pasteHTML(bstrText);
				SysFreeString(bstrText);

				if( SUCCEEDED(m_hResult) && a_bSetCursorAtBeginingOfInsertedText)
				{
					long lActual =0;
					m_hResult = pRange->move(L"character", -a_sHTMLText.GetLength(), &lActual); //this will move selection back
					
					if(SUCCEEDED(m_hResult))
					{
						m_hResult = pRange->select(); //this will show the new cursor point
					}
				}

				pRange->Release();
			}
			pTextRangeDisp->Release();
		}
		pSelection->Release();
	}

	return m_hResult;
}

HRESULT CHtmlEditCtrl2::RefreshDocument()
{
	return ExecHelperNN(IDM_REFRESH, OLECMDF_SUPPORTED);
}

HRESULT CHtmlEditCtrl2::UnBookmark()
{
	return ExecHelperNN(IDM_UNBOOKMARK);
}

HRESULT CHtmlEditCtrl2::ExecHelperNN(UINT nID, long nMinSupportLevel, long nExecOpt)
{
	HRESULT hr = E_FAIL;
	long lStatus = QueryStatus(nID);
	if ((lStatus & nMinSupportLevel) == nMinSupportLevel)
		hr = ExecCommand(nID, nExecOpt);
	return hr;
}

HRESULT CHtmlEditCtrl2::ExecHelperSetVal(UINT nCmdID, LPCTSTR szID, long nMinSupportLevel, long nExecOpt)
{
	long lStatus = QueryStatus(nCmdID);
	if ((lStatus & nMinSupportLevel) == nMinSupportLevel)
	{
		if (szID)
		{
			CComVariant vName(szID);
			return ExecCommand(nCmdID, nExecOpt, &vName);
		}
		else
			return ExecCommand(nCmdID, nExecOpt);
	}
	return E_FAIL;
}

HRESULT CHtmlEditCtrl2::ExecHelperSetVal(UINT nCmdID, bool bValue, long nMinSupportLevel, long nExecOpt)
{
	HRESULT hr = E_FAIL;
	long lStatus = QueryStatus(nCmdID);
	if ((lStatus & nMinSupportLevel) == nMinSupportLevel)
	{
		CComVariant vIn(bValue);
		hr = ExecCommand(nCmdID, nExecOpt, &vIn);
	}
	return hr;
}

HRESULT CHtmlEditCtrl2::ExecHelperSetVal(UINT nCmdID, short nNewVal, long nMinSupportLevel, long nExecOpt)
{
	HRESULT hr = E_FAIL;
	long lStatus = QueryStatus(nCmdID);
	if ((lStatus & nMinSupportLevel) == nMinSupportLevel)
	{
		CComVariant vIn((short)nNewVal);
		hr = ExecCommand(nCmdID, nExecOpt, &vIn);
	}
	return hr;
}

HRESULT CHtmlEditCtrl2::ExecHelperSetVal(UINT nCmdID, int nNewVal, long nMinSupportLevel, long nExecOpt)
{
	HRESULT hr = E_FAIL;
	long lStatus = QueryStatus(nCmdID);
	if ((lStatus & nMinSupportLevel) == nMinSupportLevel)
	{
		CComVariant vIn((int)nNewVal);
		hr = ExecCommand(nCmdID, nExecOpt, &vIn);
	}
	return hr;
}

HRESULT CHtmlEditCtrl2::ExecHelperGetVal(UINT nCmdID, bool &bValue, long nMinSupportLevel, long nExecOpt)
{
	HRESULT hr = E_FAIL;
	bValue = false;
	long lStatus = QueryStatus(nCmdID);
	if ((lStatus & nMinSupportLevel) == nMinSupportLevel)
	{
		CComVariant vOut;
		hr = ExecCommand(nCmdID, nExecOpt, NULL, &vOut);
		if (hr == S_OK)
		{
			switch(vOut.vt)
			{
			case VT_BOOL:
				bValue = vOut.boolVal == VARIANT_TRUE ? true : false;
				break;
			case VT_NULL:
			case VT_EMPTY:
				break;
			case VT_ERROR:
				hr = V_ERROR(&vOut);
				break;
			default:
				hr = E_UNEXPECTED;
				break;
			}
		}
	}
	return hr;
}

HRESULT CHtmlEditCtrl2::ExecHelperGetVal(UINT nCmdID, short &nValue, long nMinSupportLevel, long nExecOpt)
{
	int nTempVal;
	HRESULT hr = ExecHelperGetVal(nCmdID, nTempVal, nMinSupportLevel, nExecOpt);
	if (hr == S_OK)
		nValue = (short)nTempVal;
	return hr;
}


HRESULT CHtmlEditCtrl2::ExecHelperGetVal(UINT nCmdID, int &nValue, long nMinSupportLevel, long nExecOpt)
{
	HRESULT hr = E_FAIL;
	long lStatus = QueryStatus(nCmdID);
	nValue = 0;
	if ((lStatus & nMinSupportLevel) == nMinSupportLevel)
	{
		CComVariant vOut;
		hr = ExecCommand(nCmdID, nExecOpt, NULL, &vOut);
		if (hr == S_OK)
		{
			switch (vOut.vt)
			{
			case VT_I4:
				nValue = vOut.lVal;
				break;
			case VT_I2:
				nValue = vOut.iVal;
				break;
			case VT_EMPTY:
			case VT_NULL:
				break;
			case VT_ERROR:
				hr = V_ERROR(&vOut);
				break;
			default:
				hr = E_UNEXPECTED;
				break;
			}
		}
	}
	return hr;
}

HRESULT CHtmlEditCtrl2::ExecHelperGetVal(UINT nCmdID, CString& strValue, long nMinSupportLevel, long nExecOpt)
{
	HRESULT hr = E_FAIL;
	CComVariant vaRet;
	strValue.Empty();
	long lStatus = QueryStatus(nCmdID);
	if ((lStatus & nMinSupportLevel) == nMinSupportLevel)
	{
		hr = ExecCommand(nCmdID, nExecOpt, NULL, &vaRet);
		if (hr == S_OK)
		{
			switch(vaRet.vt)
			{
			case VT_BSTR:
				{
					strValue = vaRet.bstrVal;
				}
				break;
			case VT_NULL:
			case VT_EMPTY:
				break;
			case VT_ERROR:
				hr = V_ERROR(&vaRet);
				break;
			default:
				hr = E_UNEXPECTED;
				break;
			}
		}
	}
	return hr;
}


/////////////////////////////////////////


//IZ: added to simulate Append method of CString from MFC70
void CHtmlEditCtrl2::CStreamOnCString::AppendToCString(CString& a_sString, const char* a_pstrToAdd, UINT a_uiLength)
{
	char* pTmp = new char[a_uiLength+1];
	if(pTmp)
	{
		RtlZeroMemory(pTmp, a_uiLength+1);
		strncpy(pTmp, a_pstrToAdd, a_uiLength);
		a_sString += pTmp;
		delete [] pTmp;
	}
}

// Construction
CHtmlEditCtrl2::CStreamOnCString::CStreamOnCString()
{
	m_current_index = 0;
}

CHtmlEditCtrl2::CStreamOnCString::CStreamOnCString(LPCTSTR szData): m_strStream(szData)
{
	m_current_index = 0;
}

// Copies the data currently held in this
// object into a CString
BOOL CHtmlEditCtrl2::CStreamOnCString::CopyData(CString& target)
{
	target = m_strStream;
	return TRUE;
}

// Sets the value of 
BOOL CHtmlEditCtrl2::CStreamOnCString::SetData(LPCTSTR szData)
{
	try //IZ replaced: _ATLTRY
	{
		m_strStream = szData;
	}
	catch(...) //IZ replaced: _ATLCATCHALL()
	{
		return FALSE;
	}
	return TRUE;
}

// Implementation
HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::QueryInterface(REFIID iid, void **ppUnk)
{
	if (::InlineIsEqualGUID(iid, IID_IUnknown) ||
		::InlineIsEqualGUID(iid, IID_IStream) ||
		::InlineIsEqualGUID(iid, IID_ISequentialStream))
	{
		*ppUnk = (void*)this;
		AddRef();
		return S_OK;
	}
	return E_NOINTERFACE;
}

ULONG STDMETHODCALLTYPE CHtmlEditCtrl2::CStreamOnCString::AddRef( void) 
{
	return (ULONG)1;
}

ULONG STDMETHODCALLTYPE CHtmlEditCtrl2::CStreamOnCString::Release( void) 
{
	return (ULONG)1;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::Read(void *pv, ULONG cb, ULONG *pcbRead)
{
	if (pcbRead)
		*pcbRead = 0;
	if (m_strAnsi.GetLength() == 0)
		m_strAnsi = m_strStream;
	
	if (!pv)
		return E_POINTER;
	
	unsigned int length = m_strAnsi.GetLength();
	char *pStream = m_strAnsi.GetBuffer(0); //IZ added 0 parameter to GetBuffer call
	if (!pStream)
		return E_UNEXPECTED;
	
	char *pStart = pStream + m_current_index;
	char *pEnd = pStream + length;
	if (pStart >= pEnd)
		return S_FALSE; // no more data to read
	
	int bytes_left = (int)(pEnd-pStart);
	int bytes_to_copy = (int)min(bytes_left, (int)cb);
	if (bytes_to_copy <= 0)
	{
		// reset members so this stream can be used again
		m_current_index = 0;
		m_strAnsi.Empty();
		return S_FALSE;
	}
	
	memcpy(pv, pStream + m_current_index, bytes_to_copy);
	if (pcbRead)
		*pcbRead = (ULONG)bytes_to_copy;
	m_current_index += bytes_to_copy;
	m_strAnsi.ReleaseBuffer(0);
	return S_OK;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::Write(const void *pv, ULONG cb, ULONG *pcbWritten)
{
	if (pcbWritten)
		*pcbWritten = 0;
#ifdef _UNICODE
				int flags = IS_TEXT_UNICODE_UNICODE_MASK;
				if (0 != IsTextUnicode((LPVOID)pv, cb, &flags))
				{
					if (flags & IS_TEXT_UNICODE_ASCII16 ||
						flags & IS_TEXT_UNICODE_STATISTICS)
					{
						// compiling UNICODE and got a UNICODE buffer
						UINT nCharsToSkip = flags & IS_TEXT_UNICODE_SIGNATURE ? 1 : 0;
						m_strStream.Append((wchar_t*)( ((wchar_t*)pv)+nCharsToSkip), (cb/sizeof(wchar_t))-nCharsToSkip);
						if (pcbWritten)
							*pcbWritten = cb;
					}
				}
				else
				{
					// compiling UNICODE and got an ansi buffer
					// convert ansi buffer to UNICODE buffer
					unsigned int buffer_size = cb;
					wchar_t *pBuffer = new wchar_t[buffer_size];
					if (pBuffer)
					{
						if (buffer_size >= (unsigned int)MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pv, cb, pBuffer, buffer_size))
						{
							m_strStream.Append(pBuffer, buffer_size);
						}
					}
					delete [] pBuffer;
				}
#else
				int flags = IS_TEXT_UNICODE_UNICODE_MASK;
				if (0 != IsTextUnicode((LPVOID)pv, cb, &flags))
				{
					if (flags & IS_TEXT_UNICODE_ASCII16 ||
						flags & IS_TEXT_UNICODE_STATISTICS)
					{
						// compiling ANSI and got a UNICODE buffer
						UINT nCharsToSkip = flags & IS_TEXT_UNICODE_SIGNATURE ? 1 : 0;
						unsigned int nChars = WideCharToMultiByte(CP_ACP, 0, (wchar_t*)pv, cb,
							NULL, 0, NULL, NULL);
						
						char *pBuff = new char[nChars];
						if (pBuff)
						{
							WideCharToMultiByte(CP_ACP, 0, (wchar_t*)pv, cb, pBuff, nChars, NULL, NULL);
							//IZ replaced: m_strStream.Append(pBuff+nCharsToSkip, nChars-nCharsToSkip);
							AppendToCString(m_strStream, pBuff+nCharsToSkip, nChars-nCharsToSkip);
							
							if (pcbWritten)
								*pcbWritten = cb;
						}
						delete [] pBuff;
					}
				}
				else
				{
					// compiling ANSI and got an ANSI buffer
					//IZ replaced: m_strStream.Append((char*)pv, cb);
					AppendToCString(m_strStream, (char*)pv, cb);
					if (pcbWritten)
						*pcbWritten = cb;
				}
#endif
				return S_OK;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::Seek(LARGE_INTEGER , DWORD , ULARGE_INTEGER *)
{
	return E_NOTIMPL;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::SetSize(ULARGE_INTEGER )
{
	return E_NOTIMPL;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::CopyTo(IStream *, ULARGE_INTEGER , ULARGE_INTEGER *,
														   ULARGE_INTEGER *)
{
	return E_NOTIMPL;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::Commit(DWORD )
{
	return E_NOTIMPL;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::Revert( void)
{
	return E_NOTIMPL;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::LockRegion(ULARGE_INTEGER , ULARGE_INTEGER , DWORD )
{
	return E_NOTIMPL;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::UnlockRegion(ULARGE_INTEGER , ULARGE_INTEGER ,DWORD )
{
	return E_NOTIMPL;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::Stat(STATSTG *, DWORD )
{
	return E_NOTIMPL;
}

HRESULT __stdcall CHtmlEditCtrl2::CStreamOnCString::Clone(IStream **)
{
	return E_NOTIMPL;
}