archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/inetcore/outlookexpress/mailnews/mail/mehost.cpp

4787 lines
139 KiB
Raw Blame History

#include "pch.hxx"
#include <docobj.h>
#include "dllmain.h"
#include "strconst.h"
#include "msoert.h"
#include "mimeole.h"
#include "mehost.h"
#include "oleutil.h"
#include "ibodyopt.h"
#include "resource.h"
#include "mshtmcid.h"
#include "thormsgs.h"
#include "msoeprop.h"
#include "goptions.h"
#include "bodyutil.h"
#include "mimeutil.h"
#include "ourguid.h"
#include "shlwapi.h"
#include "shlwapip.h"
#include "ipab.h"
#include "statnery.h"
#include "options.h"
#include "sigs.h"
#include "fonts.h"
#include "url.h"
#include "secutil.h"
#include "sechtml.h"
#include "mimeolep.h"
#include "menuutil.h"
#include "htmlhelp.h"
#include "msgprop.h"
#include "demand.h"
#include <mshtmdid.h>
#include "menures.h"
#include "multiusr.h"
#include "fontnsc.h"
const int idTimerMarkAsRead = 100;
const TCHAR c_szSigPrefix[] = "\r\n-- \r\n";
#define MAKEINDEX(b, l) (((DWORD)l & 0x00ffffff) | ((DWORD)b << 24))
#define GETINDEX(m) (((m & 0xff000000) >> 24) & 0x000000ff)
ASSERTDATA
static const WCHAR c_wszMailTo[] = L"mailto:",
c_wszHttp[] = L"http://",
c_wszFile[] = L"file://";
const DWORD rgrgbColors16[16] = {
RGB( 0, 0, 0), // "BLACK"},
RGB(128, 0, 0), // "MAROON"},
RGB( 0, 128, 0), // "GREEN"},
RGB(128, 128, 0), // "OLIVE"},
RGB( 0, 0, 128), // "NAVY"},
RGB(128, 0, 128), // "PURPLE"},
RGB( 0, 128, 128), // "TEAL"},
RGB(128, 128, 128), // "GREY"},
RGB(192, 192, 192), // "SILVER"},
RGB(255, 0, 0), // "RED"},
RGB( 0, 255, 0), // "LIME"},
RGB(255, 255, 0), // "YELLOW"},
RGB( 0, 0, 255), // "BLUE"},
RGB(255, 0, 255), // "FUSCHIA"},
RGB( 0, 255, 255), // "AQUA"},
RGB(255, 255, 255) // "WHITE"}
};
INT_PTR CALLBACK BkImageDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
int id;
LPWSTR pwszURL;
HWND hwndCombo = GetDlgItem(hwnd, idTxtBkImage);
LRESULT lr=0;
HRESULT hr;
pwszURL = (LPWSTR)GetWindowLongPtr(hwnd, DWLP_USER);
switch(msg)
{
case WM_INITDIALOG:
Assert(lParam!= NULL);
SetWindowLongPtr(hwnd, DWLP_USER, (LPARAM)lParam);
SetIntlFont(hwndCombo);
SendDlgItemMessage(hwnd, idTxtBkImage, EM_LIMITTEXT, MAX_PATH-1, NULL);
SetFocus(hwndCombo);
pwszURL = (LPWSTR)lParam;
HrFillStationeryCombo(hwndCombo, TRUE, pwszURL);
StripStationeryDir(pwszURL);
SetWindowTextWrapW(hwndCombo, pwszURL);
SendMessage(GetWindow(hwndCombo, GW_CHILD), EM_SETSEL, 0, -1);
CenterDialog(hwnd);
return FALSE;
case WM_COMMAND:
switch(id=GET_WM_COMMAND_ID(wParam, lParam))
{
case idBrowsePicture:
HrBrowsePicture(hwnd, GetDlgItem(hwnd, idTxtBkImage));
break;
case IDOK:
Assert(pwszURL);
SendMessageWrapW(hwndCombo, CB_GETLBTEXT, (WPARAM)(SendMessage(hwndCombo, CB_GETCURSEL, 0, 0)), (LPARAM)(pwszURL));
// fall thro'
case IDCANCEL:
EndDialog(hwnd, id);
break;
}
}
return FALSE;
}
//+---------------------------------------------------------------
//
// Member: CMimeEditDocHost
//
// Synopsis:
//
//---------------------------------------------------------------
CMimeEditDocHost::CMimeEditDocHost(DWORD dwBorderFlags)
{
m_hwnd = 0;
m_hwndDocObj = 0;
m_cRef = 1;
m_dwStyle = 0;
m_dwHTMLNotifyCookie = 0;
m_dwBorderFlags = dwBorderFlags;
m_dwDocStyle = MESTYLE_NOHEADER;
m_fUIActive = FALSE;
m_fIsSigned = FALSE;
m_fFixedFont = FALSE;
m_fMarkedRead = FALSE;
m_fSignTrusted = TRUE;
m_fIsEncrypted = FALSE;
m_fSecDispInfo = FALSE;
m_fSecureReceipt = FALSE;
m_fEncryptionOK = TRUE;
m_fBlockingOnSMime = FALSE;
m_fShowingErrorPage = FALSE;
m_fRegisteredForDocEvents = FALSE;
m_pDoc = NULL;
m_pMsg = NULL;
m_pStatus = NULL;
m_pDocView = NULL;
m_lpOleObj = NULL;
m_pPrstMime = NULL;
m_pCmdTarget = NULL;
m_hmenuColor = NULL;
m_hmenuStyle = NULL;
m_pEventSink = NULL;
m_pUnkService = NULL;
m_pBodyOptions = NULL;
m_pSecureMessage = NULL;
m_pInPlaceActiveObj = NULL;
m_pSecurityErrorScreen = NULL;
}
//+---------------------------------------------------------------
//
// Member:
//
// Synopsis:
//
//---------------------------------------------------------------
CMimeEditDocHost::~CMimeEditDocHost()
{
// These should all get feed up when we get a WM_DESTROY and close the docobj
Assert(m_lpOleObj==NULL);
Assert(m_pDocView==NULL);
Assert(m_pInPlaceActiveObj==NULL);
Assert(m_pCmdTarget==NULL);
Assert(m_pPrstMime==NULL);
Assert(m_pMsg==NULL);
Assert(m_pSecurityErrorScreen==NULL);
Assert(m_pSecureMessage==NULL);
if(m_hmenuColor)
DestroyMenu(m_hmenuColor);
if(m_hmenuStyle)
DestroyMenu(m_hmenuStyle);
}
//+---------------------------------------------------------------
//
// Member: AddRef
//
// Synopsis:
//
//---------------------------------------------------------------
ULONG CMimeEditDocHost::AddRef()
{
TraceCall("CMimeEditDocHost::AddRef");
//TraceInfo(_MSG("CMimeEditDocHost::AddRef: cRef==%d", m_cRef+1));
return ++m_cRef;
}
//+---------------------------------------------------------------
//
// Member: Release
//
// Synopsis:
//
//---------------------------------------------------------------
ULONG CMimeEditDocHost::Release()
{
TraceCall("CMimeEditDocHost::Release");
//TraceInfo(_MSG("CMimeEditDocHost::Release: cRef==%d", m_cRef-1));
if (--m_cRef==0)
{
delete this;
return 0;
}
return m_cRef;
}
//+---------------------------------------------------------------
//
// Member: QueryInterface
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::QueryInterface(REFIID riid, LPVOID *lplpObj)
{
TraceCall("CMimeEditDocHost::QueryInterface");
if(!lplpObj)
return E_INVALIDARG;
*lplpObj = NULL; // set to NULL, in case we fail.
if (IsEqualIID(riid, IID_IUnknown))
*lplpObj = (LPVOID)this;
else if (IsEqualIID(riid, IID_IOleInPlaceUIWindow))
*lplpObj = (LPVOID)(IOleInPlaceUIWindow *)this;
else if (IsEqualIID(riid, IID_IOleInPlaceSite))
*lplpObj = (LPVOID)(LPOLEINPLACESITE)this;
else if (IsEqualIID(riid, IID_IOleClientSite))
*lplpObj = (LPVOID)(LPOLECLIENTSITE)this;
else if (IsEqualIID(riid, IID_IOleControlSite))
*lplpObj = (LPVOID)(IOleControlSite *)this;
else if (IsEqualIID(riid, IID_IAdviseSink))
*lplpObj = (LPVOID)(LPADVISESINK)this;
else if (IsEqualIID(riid, IID_IOleDocumentSite))
*lplpObj = (LPVOID)(LPOLEDOCUMENTSITE)this;
else if (IsEqualIID(riid, IID_IOleCommandTarget))
*lplpObj = (LPVOID)(LPOLECOMMANDTARGET)this;
else if (IsEqualIID(riid, IID_IDocHostUIHandler))
*lplpObj = (LPVOID)(IDocHostUIHandler*)this;
else if (IsEqualIID(riid, IID_IBodyObj2))
*lplpObj = (LPVOID)(IBodyObj2*)this;
else if (IsEqualIID(riid, IID_IPersistMime))
*lplpObj = (LPVOID)(IPersistMime*)this;
else if (IsEqualIID(riid, IID_IDispatch))
*lplpObj = (LPVOID)(IDispatch*)this;
else
return E_NOINTERFACE;
AddRef();
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: ExtWndProc
//
// Synopsis:
//
//---------------------------------------------------------------
LRESULT CALLBACK CMimeEditDocHost::ExtWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
CMimeEditDocHost *pDocHost;
if (WM_CREATE == msg)
{
pDocHost = (CMimeEditDocHost *)((LPCREATESTRUCT)lParam)->lpCreateParams;
if(!pDocHost)
return -1;
if(FAILED(pDocHost->OnCreate(hwnd)))
return -1;
}
pDocHost = (CMimeEditDocHost *)GetWndThisPtr(hwnd);
if(pDocHost)
return pDocHost->WndProc(hwnd, msg, wParam, lParam);
else
return DefWindowProcWrapW(hwnd, msg, wParam, lParam);
}
//+---------------------------------------------------------------
//
// Member: WndProc
//
// Synopsis:
//
//---------------------------------------------------------------
LRESULT CMimeEditDocHost::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
case WM_PAINT:
if (!m_lpOleObj)
{
HDC hdc;
PAINTSTRUCT ps;
RECT rc;
HBRUSH hBrush;
GetClientRect(m_hwnd, &rc);
hdc = BeginPaint(hwnd, &ps);
hBrush = SelectBrush(hdc, GetSysColorBrush(COLOR_WINDOW));
PatBlt(hdc, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, PATCOPY);
SelectBrush(hdc, hBrush);
EndPaint(hwnd, &ps);
return 0;
}
case WM_COMMAND:
if(WMCommand( GET_WM_COMMAND_HWND(wParam, lParam),
GET_WM_COMMAND_ID(wParam, lParam),
GET_WM_COMMAND_CMD(wParam, lParam)))
return 0;
break;
case WM_SETFOCUS:
return OnFocus(TRUE);
case WM_KILLFOCUS:
return OnFocus(FALSE);
case WM_NOTIFY:
return WMNotify((int) wParam, (NMHDR *)lParam);
case WM_SIZE:
WMSize(LOWORD(lParam), HIWORD(lParam));
return 0;
case WM_CLOSE:
return 0; // prevent alt-f4's
case WM_NCDESTROY:
WMNCDestroy();
break;
case WM_TIMER:
if (wParam == idTimerMarkAsRead)
{
OnWMTimer();
return 0;
}
break;
case WM_WININICHANGE:
case WM_DISPLAYCHANGE:
case WM_SYSCOLORCHANGE:
case WM_QUERYNEWPALETTE:
case WM_PALETTECHANGED:
if (m_hwndDocObj)
return SendMessage(m_hwndDocObj, msg, wParam, lParam);
break;
}
return DefWindowProcWrapW(hwnd, msg, wParam, lParam);
}
BOOL CMimeEditDocHost::WMCreate(HWND hwnd)
{
m_hwnd = hwnd;
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM)this);
AddRef();
return SUCCEEDED(HrSubWMCreate())?TRUE:FALSE;
}
void CMimeEditDocHost::WMNCDestroy()
{
SetWindowLongPtr(m_hwnd, GWLP_USERDATA, NULL);
m_hwnd = NULL;
Release();
}
//+---------------------------------------------------------------
//
// Member: OnNCDestroy
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnNCDestroy()
{
TraceCall("CMimeEditDocHost::OnNCDestroy");
SetWindowLongPtr(m_hwnd, GWLP_USERDATA, NULL);
m_hwnd = NULL;
Release();
return S_OK;
}
//+---------------------------------------------------------------
//
// Member: OnDestroy
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnDestroy()
{
TraceCall("CMimeEditDocHost::OnDestroy");
return CloseDocObj();
}
//+---------------------------------------------------------------
//
// Member: OnCreate
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnCreate(HWND hwnd)
{
TraceCall("CMimeEditDocHost::OnCreate");
m_hwnd = hwnd;
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM)this);
AddRef();
return S_OK;
}
//+---------------------------------------------------------------
//
// Member: CreateDocObj
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::CreateDocObj(LPCLSID pCLSID)
{
HRESULT hr=NOERROR;
TraceCall("CMimeEditDocHost::CreateDocObj");
if(!pCLSID)
return E_INVALIDARG;
Assert(!m_lpOleObj);
Assert(!m_pDocView);
Assert(!m_pCmdTarget);
hr = CoCreateInstance(*pCLSID, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
IID_IOleObject, (LPVOID *)&m_lpOleObj);
if (FAILED(hr))
goto error;
hr = m_lpOleObj->SetClientSite((LPOLECLIENTSITE)this);
if (FAILED(hr))
goto error;
hr = m_lpOleObj->QueryInterface(IID_IOleCommandTarget, (LPVOID *)&m_pCmdTarget);
if (FAILED(hr))
goto error;
hr = m_lpOleObj->QueryInterface(IID_IPersistMime, (LPVOID *)&m_pPrstMime);
if (FAILED(hr))
goto error;
hr = HrInitNew(m_lpOleObj);
error:
return hr;
}
//+---------------------------------------------------------------
//
// Member: Show
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::Show()
{
RECT rc;
HRESULT hr;
TraceCall("CMimeEditDocHost::Show");
GetClientRect(m_hwnd, &rc);
hr=m_lpOleObj->DoVerb(OLEIVERB_SHOW, NULL, (LPOLECLIENTSITE)this, 0, m_hwnd, &rc);
if(FAILED(hr))
goto error;
error:
return hr;
}
//+---------------------------------------------------------------
//
// Member: CloseDocObj
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::CloseDocObj()
{
LPOLEINPLACEOBJECT pInPlaceObj=0;
RegisterForHTMLDocEvents(FALSE);
SafeRelease(m_pCmdTarget);
SafeRelease(m_pPrstMime);
SafeRelease(m_pInPlaceActiveObj);
SafeRelease(m_pDoc);
SafeRelease(m_pMsg);
SafeRelease(m_pSecureMessage);
SafeRelease(m_pSecurityErrorScreen);
SafeRelease(m_pEventSink);
SafeRelease(m_pStatus);
if(m_pDocView)
{
m_pDocView->UIActivate(FALSE);
m_pDocView->CloseView(0);
m_pDocView->SetInPlaceSite(NULL);
m_pDocView->Release();
m_pDocView=NULL;
}
if (m_lpOleObj)
{
// deactivate the docobj
if (!FAILED(m_lpOleObj->QueryInterface(IID_IOleInPlaceObject, (LPVOID*)&pInPlaceObj)))
{
pInPlaceObj->InPlaceDeactivate();
pInPlaceObj->Release();
}
// close the ole object, but blow off changes as we have either extracted
// them ourselves or don't care.
m_lpOleObj->Close(OLECLOSE_NOSAVE);
#ifdef DEBUG
ULONG uRef;
uRef=
#endif
m_lpOleObj->Release();
m_lpOleObj=NULL;
AssertSz(uRef==0, "We leaked a docobject!");
}
m_fUIActive=FALSE;
return NOERROR;
}
// Close DocObj
HRESULT CMimeEditDocHost::HrResetDocument()
{
CloseDocObj();
CreateDocObj((LPCLSID)&CLSID_MimeEdit);
CreateDocView();
return(S_OK);
}
// *** IOleWindow ***
//+---------------------------------------------------------------
//
// Member: GetWindow
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::GetWindow(HWND *phwnd)
{
TraceCall("CMimeEditDocHost::GetWindow");
*phwnd=m_hwnd;
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: ContextSensitiveHelp
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::ContextSensitiveHelp(BOOL fEnterMode)
{
TraceCall("CMimeEditDocHost::ContextSensitiveHelp");
return E_NOTIMPL;
}
// *** IOleInPlaceUIWindow methods ***
//+---------------------------------------------------------------
//
// Member: GetBorder
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::GetBorder(LPRECT lprectBorder)
{
TraceCall("CMimeEditDocHost::GetBorder");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: RequestBorderSpace
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::RequestBorderSpace(LPCBORDERWIDTHS pborderwidths)
{
TraceCall("CMimeEditDocHost::RequestBorderSpace");
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: SetBorderSpace
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::SetBorderSpace(LPCBORDERWIDTHS lpborderwidths)
{
TraceCall("CMimeEditDocHost::IOleInPlaceUIWindow::SetBorderSpace");
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: SetActiveObject
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::SetActiveObject(IOleInPlaceActiveObject * pActiveObject, LPCOLESTR lpszObjName)
{
TraceCall("CMimeEditDocHost::IOleInPlaceUIWindow::SetActiveObject");
ReplaceInterface(m_pInPlaceActiveObj, pActiveObject);
return S_OK;
}
// *** IOleInPlaceFrame methods ***
//+---------------------------------------------------------------
//
// Member: CMimeEditDocHost::InsertMenus
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::InsertMenus(HMENU, LPOLEMENUGROUPWIDTHS)
{
TraceCall("CMimeEditDocHost::InsertMenus");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: CMimeEditDocHost::SetMenu
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::SetMenu(HMENU, HOLEMENU, HWND)
{
TraceCall("CMimeEditDocHost::SetMenu");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: CMimeEditDocHost::RemoveMenus
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::RemoveMenus(HMENU)
{
TraceCall("CMimeEditDocHost::RemoveMenus");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: CMimeEditDocHost::SetStatusText
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::SetStatusText(LPCOLESTR pszW)
{
TCHAR rgch[CCHMAX_STRINGRES];
TraceCall("CMimeEditDocHost::SetStatusText");
if(!m_pStatus)
return E_NOTIMPL;
*rgch=0;
if(pszW && WideCharToMultiByte(CP_ACP, 0, pszW, -1, rgch, ARRAYSIZE(rgch), NULL, NULL))
m_pStatus->ShowSimpleText(rgch);
if(*rgch==0)
m_pStatus->HideSimpleText();
DOUTL(64, "IOleInPlaceFrame::SetStatusText:'%s'", rgch);
return NOERROR;
}
HRESULT CMimeEditDocHost::TranslateAccelerator(LPMSG, WORD)
{
return E_NOTIMPL;
}
// **** IOleInPlaceSite methods ****
//+---------------------------------------------------------------
//
// Member: CanInPlaceActivate
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::CanInPlaceActivate()
{
TraceCall("CMimeEditDocHost::IOleInPlaceSite::CanInPlaceActivate");
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: OnInPlaceActivate
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnInPlaceActivate()
{
LPOLEINPLACEACTIVEOBJECT pInPlaceActive;
TraceCall("CMimeEditDocHost::OnInPlaceActivate");
Assert(m_lpOleObj);
if (m_lpOleObj->QueryInterface(IID_IOleInPlaceActiveObject, (LPVOID *)&pInPlaceActive)==S_OK)
{
SideAssert((pInPlaceActive->GetWindow(&m_hwndDocObj)==NOERROR)&& IsWindow(m_hwndDocObj));
pInPlaceActive->Release();
}
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: OnUIActivate
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnUIActivate()
{
TraceCall("CMimeEditDocHost::OnUIActivate");
m_fUIActive=TRUE;
// Notify our parent that we're the one with the focus now.
if (m_pEventSink)
m_pEventSink->EventOccurred(MEHC_UIACTIVATE, NULL);
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: GetWindowContext
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::GetWindowContext( IOleInPlaceFrame **ppFrame,
IOleInPlaceUIWindow **ppDoc,
LPRECT lprcPosRect,
LPRECT lprcClipRect,
LPOLEINPLACEFRAMEINFO lpFrameInfo)
{
TraceCall("CMimeEditDocHost::IOleInPlaceSite::GetWindowContext");
*ppFrame = (LPOLEINPLACEFRAME)this;
AddRef();
*ppDoc = NULL;
GetClientRect(m_hwnd, lprcPosRect);
*lprcClipRect = *lprcPosRect;
lpFrameInfo->fMDIApp = FALSE;
lpFrameInfo->hwndFrame = m_hwnd;
lpFrameInfo->haccel = NULL;
lpFrameInfo->cAccelEntries = 0;
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: Scroll
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::Scroll(SIZE scrollExtent)
{
// the docobject consumes the entireview, so scroll requests
// are meaningless. Return NOERROR to indicate that they're scolled
// into view.
TraceCall("CMimeEditDocHost::IOleInPlaceSite::Scroll");
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: OnUIDeactivate
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnUIDeactivate(BOOL fUndoable)
{
TraceCall("CMimeEditDocHost::OnUIDeactivate");
m_fUIActive=FALSE;
return S_OK;
}
//+---------------------------------------------------------------
//
// Member: OnInPlaceDeactivate
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnInPlaceDeactivate()
{
TraceCall("CMimeEditDocHost::OnInPlaceDeactivate");
return S_OK;
}
//+---------------------------------------------------------------
//
// Member: DiscardUndoState
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::DiscardUndoState()
{
TraceCall("CMimeEditDocHost::IOleInPlaceSite::DiscardUndoState");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: DeactivateAndUndo
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::DeactivateAndUndo()
{
TraceCall("CMimeEditDocHost::IOleInPlaceSite::DeactivateAndUndo");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: OnPosRectChange
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnPosRectChange(LPCRECT lprcPosRect)
{
TraceCall("CMimeEditDocHost::IOleInPlaceSite::OnPosRectChange");
return E_NOTIMPL;
}
// IOleClientSite methods.
//+---------------------------------------------------------------
//
// Member: SaveObject
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::SaveObject()
{
TraceCall("CMimeEditDocHost::IOleClientSite::SaveObject");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: GetMoniker
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker, LPMONIKER *ppmnk)
{
TraceCall("CMimeEditDocHost::IOleClientSite::GetMoniker");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: GetContainer
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::GetContainer(LPOLECONTAINER *ppCont)
{
TraceCall("CMimeEditDocHost::IOleClientSite::GetContainer");
if(ppCont)
*ppCont=NULL;
return E_NOINTERFACE;
}
//+---------------------------------------------------------------
//
// Member: ShowObject
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::ShowObject()
{
// always shown.
// $TODO: do we need to restore the browser here if it is
// minimised?
TraceCall("CMimeEditDocHost::IOleClientSite::ShowObject");
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: OnShowWindow
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnShowWindow(BOOL fShow)
{
TraceCall("CMimeEditDocHost::IOleClientSite::OnShowWindow");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: RequestNewObjectLayout
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::RequestNewObjectLayout()
{
TraceCall("CMimeEditDocHost::IOleClientSite::RequestNewObjectLayout");
return E_NOTIMPL;
}
// IOleDocumentSite
//+---------------------------------------------------------------
//
// Member: ActivateMe
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::ActivateMe(LPOLEDOCUMENTVIEW pViewToActivate)
{
TraceCall("CMimeEditDocHost::IOleDocumentSite::ActivateMe");
return CreateDocView();
}
//+---------------------------------------------------------------
//
// Member: CreateDocView
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::CreateDocView()
{
HRESULT hr;
LPOLEDOCUMENT pOleDoc=NULL;
IServiceProvider *pSP;
TraceCall("CMimeEditDocHost::CreateDocView");
AssertSz(!m_pDocView, "why is this still set??");
AssertSz(m_lpOleObj, "uh? no docobject at this point?");
hr=OleRun(m_lpOleObj);
if(FAILED(hr))
goto Exit;
hr=m_lpOleObj->QueryInterface(IID_IOleDocument, (LPVOID*)&pOleDoc);
if(FAILED(hr))
goto Exit;
hr=pOleDoc->CreateView(this, NULL,0,&m_pDocView);
if(FAILED(hr))
goto CleanUp;
hr=m_pDocView->SetInPlaceSite(this);
if(FAILED(hr))
goto CleanUp;
hr=m_pDocView->Show(TRUE);
if(FAILED(hr))
goto CleanUp;
hr = m_lpOleObj->QueryInterface(IID_IServiceProvider, (LPVOID *)&pSP);
if (!FAILED(hr))
{
hr = pSP->QueryService(IID_IHTMLDocument2, IID_IHTMLDocument2, (LPVOID *)&m_pDoc);
pSP->Release();
}
CleanUp:
pOleDoc->Release();
Exit:
return hr;
}
// This must be greater than the most number of IDs that will ever be passed down
// to MimeEdit for any one group within the CMDSETID_OutlookExpress portion of
// QueryStatus below
const DWORD MAX_MIMEEDIT_CMDS = 20;
// I know this is totally cheesy, but...
// These next macros rely upon variables within the CMDSETID_OutlookExpress
// portion of QueryStatus
#define INC_FORMS(id) _IncrementCmdList(pCmd, rgCmdForms, rgpCmdForms, &cCmdForms, id)
#define INC_STD(id) _IncrementCmdList(pCmd, rgCmdStd, rgpCmdStd, &cCmdStd, id)
#define INC_MIMEEDIT(id) _IncrementCmdList(pCmd, rgCmdMimeEdit, rgpCmdMimeEdit, &cCmdMimeEdit, id)
inline void _IncrementCmdList(OLECMD *pCurCmd, OLECMD *pInCmdList, OLECMD **ppOutCmdList, DWORD *pdwIndex, DWORD cmdID)
{
DWORD dwIndex = *pdwIndex;
AssertSz(dwIndex < MAX_MIMEEDIT_CMDS, "Need to increment MAX_MIMEEDIT_CMDS");
pInCmdList[dwIndex].cmdID = cmdID;
pInCmdList[dwIndex].cmdf = 0;
ppOutCmdList[dwIndex] = pCurCmd;
dwIndex++;
*pdwIndex = dwIndex;
}
//+---------------------------------------------------------------
//
// Member: QueryStatus
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pCmdText)
{
TraceCall("CMimeEditDocHost::CMimeEditDocHost::QueryStatus");
HRESULT hr = OLECMDERR_E_UNKNOWNGROUP;
OLECMD *pCmd = rgCmds;
if (!rgCmds)
return E_INVALIDARG;
if (NULL == pguidCmdGroup)
{
// TraceInfo("IOleCmdTarget::QueryStatus - std group");
for (ULONG ul = 0; ul < cCmds; ul++, pCmd++)
{
if (0 != pCmd->cmdf)
continue;
switch (pCmd->cmdID)
{
case OLECMDID_UPDATECOMMANDS:
case OLECMDID_SETPROGRESSPOS:
case OLECMDID_SETPROGRESSTEXT:
pCmd->cmdf = MSOCMDF_ENABLED;
break;
}
}
hr = S_OK;
}
// Will be used when sending down command IDs
else if (IsEqualGUID(CMDSETID_OutlookExpress, *pguidCmdGroup))
{
ULONG ulTab = MEST_EDIT;
DWORD cCmdForms = 0,
cCmdStd = 0,
cCmdMimeEdit = 0;
OLECMD rgCmdForms[MAX_MIMEEDIT_CMDS],
rgCmdStd[MAX_MIMEEDIT_CMDS],
rgCmdMimeEdit[MAX_MIMEEDIT_CMDS],
*rgpCmdForms[MAX_MIMEEDIT_CMDS],
*rgpCmdStd[MAX_MIMEEDIT_CMDS],
*rgpCmdMimeEdit[MAX_MIMEEDIT_CMDS];
BOOL fHtml,
fActiveAndHtml,
fEditMode = FALSE,
fFormatMenu = FALSE;
HrIsEditMode(&fEditMode);
if (!fEditMode && m_pMsg)
{
DWORD dwFlags = 0;
m_pMsg->GetFlags(&dwFlags);
fHtml = (dwFlags & IMF_HTML);
}
else
fHtml = (S_OK == HrIsHTMLMode());
fActiveAndHtml = fHtml && m_fUIActive;
ExecGetI4(&CMDSETID_MimeEdit, MECMDID_SETSOURCETAB, &ulTab);
for (ULONG ul = 0; ul < cCmds; ul++, pCmd++)
{
ULONG cmdID = pCmd->cmdID;
if (0 != pCmd->cmdf)
continue;
switch (cmdID)
{
case ID_REPLY:
case ID_REPLY_ALL:
case ID_REPLY_GROUP:
case ID_FORWARD:
case ID_FORWARD_AS_ATTACH:
// If we have the sec UI showing then the reply, etc shouldn't work. We don't care
// here in MimeEdit if is isn't displayed. We can allow the other components to
// decide what happens in that case.
if(m_fSecDispInfo || m_fShowingErrorPage)
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_FONTS_LARGEST:
case ID_FONTS_LARGE:
case ID_FONTS_MEDIUM:
case ID_FONTS_SMALL:
case ID_FONTS_SMALLEST:
INC_FORMS(IDM_BASELINEFONT1 + (cmdID - ID_FONTS_SMALLEST));
break;
case ID_FONTS_FIXED:
pCmd->cmdf = QS_ENABLECHECK(!fHtml, m_fFixedFont);
break;
case ID_FIND_TEXT:
// For some reason, trident always marks this enabled, but if we are in the
// browser and the list view has focus, then the Exec won't work even though
// the QueryStatus returns enabled. Therefore, only enable this if active
// Once trident has fixed there problem here, we can enable calling into trident
// See RAID 13727
//INC_STD(OLECMDID_FIND);
pCmd->cmdf = QS_ENABLED(m_fUIActive);
break;
case ID_PRINT:
case ID_PRINT_NOW:
if (IsWindowVisible(m_hwnd))
INC_STD(OLECMDID_PRINT);
break;
case ID_POPUP_FONTS:
case ID_VIEW_MSG_SOURCE:
case ID_VIEW_SOURCE:
pCmd->cmdf = QS_ENABLED(TRUE);
break;
// This should be disabled if mail
case ID_UNSCRAMBLE:
{
DWORD dwFlags = 0;
if (m_fSecDispInfo || m_fShowingErrorPage)
{
pCmd->cmdf = QS_ENABLED(FALSE);
}
else
{
m_pBodyOptions->GetFlags(&dwFlags);
pCmd->cmdf = QS_ENABLED((0 == (dwFlags & BOPT_MAIL)) && !fEditMode);
}
break;
}
case ID_SAVE_STATIONERY:
case ID_NOTE_SAVE_STATIONERY:
{
DWORD dwFlags = 0;
m_pBodyOptions->GetFlags(&dwFlags);
pCmd->cmdf = QS_ENABLED(fHtml && IsWindowVisible(m_hwnd) &&
(0 == (BOPT_MULTI_MSGS_SELECTED & dwFlags)) && !m_fShowingErrorPage);
break;
}
// This should only be enabled if have attachments
case ID_SAVE_ATTACHMENTS:
case ID_NOTE_SAVE_ATTACHMENTS:
{
DWORD dwFlags = 0;
m_pBodyOptions->GetFlags(&dwFlags);
if (IsWindowVisible(m_hwnd) && (0 == (BOPT_MULTI_MSGS_SELECTED & dwFlags)))
INC_MIMEEDIT(MECMDID_SAVEATTACHMENTS);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
}
// We only care what happens with these if we are not in the edit tab. If not in the
// edit tab, then disable these menu items.
case ID_MOVE_TO_FOLDER:
case ID_COPY_TO_FOLDER:
case ID_NOTE_MOVE_TO_FOLDER:
case ID_NOTE_COPY_TO_FOLDER:
case ID_FORMATTING_TOOLBAR:
case ID_POPUP_LANGUAGE:
case ID_POPUP_LANGUAGE_DEFERRED:
if (ulTab != MEST_EDIT)
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_SPELLING:
INC_STD(OLECMDID_SPELL);
break;
case ID_CUT:
INC_STD(OLECMDID_CUT);
break;
case ID_NOTE_COPY:
case ID_COPY:
INC_STD(OLECMDID_COPY);
break;
case ID_PASTE:
INC_STD(OLECMDID_PASTE);
break;
case ID_SELECT_ALL:
INC_STD(OLECMDID_SELECTALL);
break;
case ID_UNDO:
INC_STD(OLECMDID_UNDO);
break;
case ID_REDO:
INC_STD(OLECMDID_REDO);
break;
case ID_SOURCE_EDIT:
INC_MIMEEDIT(MECMDID_SHOWSOURCETABS);
break;
case ID_DOCDIR_LTR:
INC_FORMS(IDM_DIRLTR);
break;
case ID_DOCDIR_RTL:
INC_FORMS(IDM_DIRRTL);
break;
case ID_INDENT_INCREASE:
if (fActiveAndHtml)
INC_FORMS(IDM_INDENT);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_INDENT_DECREASE:
if (fActiveAndHtml)
INC_FORMS(IDM_OUTDENT);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_FONTS_DIALOG:
if (fActiveAndHtml)
INC_FORMS(IDM_FONT);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_FORMAT_SETTINGS:
if (fActiveAndHtml)
INC_FORMS(IDM_BLOCKFMT);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_INSERT_TEXT:
if (m_fUIActive)
INC_MIMEEDIT(MECMDID_INSERTTEXTFILE);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_FORMAT_PARADLG:
if (m_fUIActive)
INC_MIMEEDIT(MECMDID_FORMATPARAGRAPH);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_POPUP_STYLE:
pCmd->cmdf = QS_ENABLED(fActiveAndHtml && (ulTab == MEST_EDIT));
break;
case ID_BACKGROUND_PICTURE:
case ID_BACKGROUND_SOUND:
case ID_POPUP_BACKGROUND_COLOR:
case ID_POPUP_STATIONERY:
case ID_POPUP_BACKGROUND:
pCmd->cmdf = QS_ENABLED(fHtml && (ulTab == MEST_EDIT));
break;
case ID_INSERT_PICTURE:
if (fActiveAndHtml)
INC_FORMS(IDM_IMAGE);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_INSERT_LINE:
if (fActiveAndHtml)
INC_FORMS(IDM_HORIZONTALLINE);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_UNLINK:
if (fActiveAndHtml)
INC_FORMS(IDM_UNLINK);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
case ID_EDIT_LINK:
pCmd->cmdf = QS_ENABLED(fActiveAndHtml);
break;
case ID_INSERT_SIGNATURE:
if (m_fUIActive && (ulTab == MEST_EDIT) && m_pBodyOptions && (S_OK == m_pBodyOptions->SignatureEnabled(FALSE)))
INC_MIMEEDIT(MECMDID_INSERTHTML);
else
pCmd->cmdf = QS_ENABLED(FALSE);
break;
default:
if ((ID_FORMAT_FIRST <= cmdID) && (ID_FORMAT_LAST >= cmdID))
pCmd->cmdf = QS_ENABLED(TRUE);
break;
}
}
if (cCmdForms)
{
DOUTL(8, "cCmdForms = %d", cCmdForms);
if (m_pCmdTarget && S_OK==m_pCmdTarget->QueryStatus(&CMDSETID_Forms3, cCmdForms, rgCmdForms, NULL))
{
OLECMD *pCmds = rgCmdForms,
**ppCmdsToReturn = rgpCmdForms;
for (DWORD i = 0; i < cCmdForms; i++, pCmds++, ppCmdsToReturn++)
(*ppCmdsToReturn)->cmdf = pCmds->cmdf;
}
}
if (cCmdStd)
{
DOUTL(8, "cCmdStd = %d", cCmdStd);
if (m_pCmdTarget && S_OK==m_pCmdTarget->QueryStatus(NULL, cCmdStd, rgCmdStd, NULL))
{
OLECMD *pCmds = rgCmdStd,
**ppCmdsToReturn = rgpCmdStd;
for (DWORD i = 0; i < cCmdStd; i++, pCmds++, ppCmdsToReturn++)
(*ppCmdsToReturn)->cmdf = pCmds->cmdf;
}
}
if (cCmdMimeEdit)
{
DOUTL(8, "cCmdMimeEdit = %d", cCmdMimeEdit);
if (m_pCmdTarget && S_OK==m_pCmdTarget->QueryStatus(&CMDSETID_MimeEdit, cCmdMimeEdit, rgCmdMimeEdit, NULL))
{
OLECMD *pCmds = rgCmdMimeEdit,
**ppCmdsToReturn = rgpCmdMimeEdit;
for (DWORD i = 0; i < cCmdMimeEdit; i++, pCmds++, ppCmdsToReturn++)
(*ppCmdsToReturn)->cmdf = pCmds->cmdf;
}
}
hr = S_OK;
}
else if (IsEqualGUID(CMDSETID_MimeEditHost, *pguidCmdGroup))
{
for (ULONG ul = 0; ul < cCmds; ul++, pCmd++)
{
if (0 != pCmd->cmdf)
continue;
switch (pCmd->cmdID)
{
case MEHOSTCMDID_SAVEATTACH_PATH:
case MEHOSTCMDID_UNSAFEATTACHMENTS:
case MEHOSTCMDID_SECURITY_ZONE:
case MEHOSTCMDID_SIGNATURE_ENABLED:
case MEHOSTCMDID_SIGNATURE_OPTIONS:
case MEHOSTCMDID_SIGNATURE:
case MEHOSTCMDID_HEADER_TYPE:
case MEHOSTCMDID_FLAGS:
case MEHOSTCMDID_QUOTE_CHAR:
case MEHOSTCMDID_REPLY_TICK_COLOR:
case MEHOSTCMDID_COMPOSE_FONT:
case MEHOSTCMDID_ADD_TO_ADDRESSBOOK:
case MEHOSTCMDID_ADD_TO_FAVORITES:
case MEHOSTCMDID_ONPARSECOMPLETE:
case MEHOSTCMDID_FONTCACHE:
case MEHOSTCMDID_BORDERFLAGS:
pCmd->cmdf = QS_ENABLED(TRUE);
break;
}
}
hr = S_OK;
}
else if (IsEqualGUID(CMDSETID_OESecurity, *pguidCmdGroup))
{
for (ULONG ul = 0; ul < cCmds; ul++, pCmd++)
{
if (0 != pCmd->cmdf)
continue;
switch (pCmd->cmdID)
{
case OECSECCMD_ENCRYPTED:
{
pCmd->cmdf = OLECMDF_SUPPORTED;
if (m_fIsEncrypted)
{
if(m_fSecDispInfo)
pCmd->cmdf |= OLECMDF_INVISIBLE;
else if (m_fEncryptionOK)
pCmd->cmdf |= OLECMDF_ENABLED;
}
else
pCmd->cmdf |= OLECMDF_INVISIBLE;
break;
}
case OECSECCMD_SIGNED:
{
pCmd->cmdf = OLECMDF_SUPPORTED;
if (m_fIsSigned)
{
if(m_fSecDispInfo)
pCmd->cmdf |= OLECMDF_INVISIBLE;
else if (m_fSignTrusted)
pCmd->cmdf |= OLECMDF_ENABLED;
}
else
pCmd->cmdf |= OLECMDF_INVISIBLE;
break;
}
}
}
hr = S_OK;
}
TraceInfoAssert(OLECMDERR_E_UNKNOWNGROUP != hr, "IOleCmdTarget::QueryStatus - unknown group");
return hr;
}
//+---------------------------------------------------------------
//
// Member: Exec
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdExecOpt, VARIANTARG *pvaIn, VARIANTARG *pvaOut)
{
TCHAR rgch[MAX_PATH];
HRESULT hr = S_OK;
TraceCall("CMimeEditDocHost::Exec");
if (NULL == pguidCmdGroup)
{
switch(nCmdID)
{
case OLECMDID_UPDATECOMMANDS:
OnUpdateCommands();
break;
case OLECMDID_SETPROGRESSPOS:
// when done downloading trident now hits us with a
// setprogresspos == -1 to indicate we should remove the "Done"
if (pvaIn->lVal == -1)
SetStatusText(NULL);
break;
case OLECMDID_SETPROGRESSTEXT:
if(pvaIn->vt == (VT_BSTR))
SetStatusText((LPCOLESTR)pvaIn->bstrVal);
break;
default:
hr = OLECMDERR_E_NOTSUPPORTED;
break;
}
}
// Will be used when sending down command IDs
else if (IsEqualGUID(CMDSETID_OutlookExpress, *pguidCmdGroup))
{
// TraceInfo("IOleCmdTarget::QueryStatus - std group");
hr = HrWMCommand(m_hwnd, nCmdID, 0);
}
else if (IsEqualGUID(CMDSETID_Forms3, *pguidCmdGroup))
{
if (nCmdID == IDM_PARSECOMPLETE)
// add code here to call download complete when 916 comes out.
OnDocumentReady();
else if (nCmdID == IDM_DIRRTL)
return m_pCmdTarget ? m_pCmdTarget->Exec(pguidCmdGroup, nCmdID, nCmdExecOpt, pvaIn, pvaOut) : E_FAIL;
else
hr = OLECMDERR_E_NOTSUPPORTED;
}
else if (IsEqualGUID(CMDSETID_MimeEdit, *pguidCmdGroup))
{
return m_pCmdTarget ? m_pCmdTarget->Exec(pguidCmdGroup, nCmdID, nCmdExecOpt, pvaIn, pvaOut) : E_FAIL;
}
else if (IsEqualGUID(CMDSETID_MimeEditHost, *pguidCmdGroup))
{
BOOL fCommandHandled = FALSE;
// CFrontPage doesn't initialize an m_pBodyOptions
if (m_pBodyOptions)
{
fCommandHandled = TRUE;
switch (nCmdID)
{
case MEHOSTCMDID_SOURCEEDIT_FLAGS:
if (pvaOut)
{
pvaOut->vt = VT_I4;
pvaOut->lVal = 0;
if (DwGetOption(OPT_SOURCE_EDIT_COLORING))
pvaOut->lVal |= MESRCFLAGS_COLOR;
} else
hr = E_INVALIDARG;
break;
case MEHOSTCMDID_SAVEATTACH_PATH:
{
if (pvaIn && pvaIn->vt == VT_BSTR && pvaIn->bstrVal)
{
if (WideCharToMultiByte(CP_ACP, 0, pvaIn->bstrVal, -1, rgch, ARRAYSIZE(rgch), NULL, NULL))
SetOption(OPT_SAVEATTACH_PATH, rgch, MAX_PATH, NULL, 0);
}
else if (pvaOut)
{
pvaOut->vt = VT_BSTR;
GetOption(OPT_SAVEATTACH_PATH, rgch, MAX_PATH);
hr = HrLPSZToBSTR(rgch, &pvaOut->bstrVal);
} else
hr = E_INVALIDARG;
break;
}
case MEHOSTCMDID_UNSAFEATTACHMENTS:
if (pvaOut)
{
BOOL fEditMode = FALSE;
pvaOut->vt = VT_I4;
HrIsEditMode(&fEditMode);
if (fEditMode) // allow open/save during edit/compose
pvaOut->lVal = 0;
else
pvaOut->lVal = DwGetOption(OPT_SECURITY_ATTACHMENT);
} else
hr = E_INVALIDARG;
break;
case MEHOSTCMDID_SECURITY_ZONE:
if (pvaOut)
{
pvaOut->vt = VT_I4;
#ifdef FORCE_UNTRUSTED
pvaOut->lVal = URLZONE_UNTRUSTED;
#else // FORCE_UNTRUSTED
if (DwGetOption(OPT_READ_IN_TEXT_ONLY))
{
// In text mode, never let scripts run.
pvaOut->lVal = URLZONE_UNTRUSTED;
}
else
{
pvaOut->lVal = DwGetOption(OPT_SECURITYZONE);
}
#endif // FORCE_UNTRUSTED
} else
hr = E_INVALIDARG;
break;
case MEHOSTCMDID_SIGNATURE_ENABLED:
{
Assert(pvaIn);
Assert(V_VT(pvaIn) == VT_I4);
hr = m_pBodyOptions->SignatureEnabled((V_I4(pvaIn) == MESIG_AUTO) ? TRUE : FALSE);
break;
}
case MEHOSTCMDID_SIGNATURE_OPTIONS:
{
DWORD outFlags = 0,
fBodyFlags = 0;
Assert(pvaOut);
V_VT(pvaOut) = VT_I4;
m_pBodyOptions->GetSignature(NULL, &fBodyFlags, NULL);
if (fBodyFlags != 0)
{
outFlags = (fBodyFlags & SIGOPT_HTML) ? MESIGOPT_HTML : MESIGOPT_PLAIN;
if (fBodyFlags & SIGOPT_TOP)
outFlags |= MESIGOPT_TOP;
if (fBodyFlags & SIGOPT_PREFIX)
outFlags |= MESIGOPT_PREFIX;
if (fBodyFlags & SIGOPT_BOTTOM)
outFlags |= MESIGOPT_BOTTOM;
}
V_I4(pvaOut) = outFlags;
break;
}
case MEHOSTCMDID_SPELL_LANGUAGE:
{
Assert(pvaOut);
pvaOut->vt = VT_BSTR;
if (GetOption(OPT_SPELL_LANGID, rgch, ARRAYSIZE(rgch)))
{
hr = HrLPSZToBSTR(rgch, &pvaOut->bstrVal);
}
else
hr = E_FAIL;
break;
}
case MEHOSTCMDID_SPELL_OPTIONS:
{
DWORD outFlags = 0;
Assert(pvaOut);
V_VT(pvaOut) = VT_I4;
if (DwGetOption(OPT_SPELLIGNORENUMBER))
outFlags |= MESPELLOPT_IGNORENUMBER;
if (DwGetOption(OPT_SPELLIGNOREUPPER))
outFlags |= MESPELLOPT_IGNOREUPPER;
if (DwGetOption(OPT_SPELLIGNOREDBCS))
outFlags |= MESPELLOPT_IGNOREDBCS;
if (DwGetOption(OPT_SPELLIGNOREPROTECT))
outFlags |= MESPELLOPT_IGNOREPROTECT;
if (DwGetOption(OPT_SPELLIGNOREURL))
outFlags |= MESPELLOPT_IGNOREURL;
if (DwGetOption(OPT_SPELLALWAYSSUGGEST))
outFlags |= MESPELLOPT_ALWAYSSUGGEST;
if (DwGetOption(OPT_SPELLCHECKONSEND))
outFlags |= MESPELLOPT_CHECKONSEND;
if (DwGetOption(OPT_SPELLCHECKONTYPE))
outFlags |= MESPELLOPT_CHECKONTYPE;
V_I4(pvaOut) = outFlags;
break;
}
case MEHOSTCMDID_SIGNATURE:
{
DWORD fFlags;
Assert(pvaOut);
V_VT(pvaOut) = VT_BSTR;
hr = m_pBodyOptions->GetSignature(NULL, &fFlags, &V_BSTR(pvaOut));
break;
}
case MEHOSTCMDID_HEADER_TYPE:
{
DWORD dwFlags = 0;
Assert(pvaOut);
V_VT(pvaOut) = VT_I4;
m_pBodyOptions->GetFlags(&dwFlags);
if (dwFlags & BOPT_USEREPLYHEADER)
{
if (dwFlags & BOPT_MAIL)
{
V_I4(pvaOut) = MEHEADER_MAIL;
if (DwGetOption(OPT_HARDCODEDHDRS))
V_I4(pvaOut) |= MEHEADER_FORCE_ENGLISH;
}
else
V_I4(pvaOut) = MEHEADER_NEWS;
}
else
V_I4(pvaOut) = MEHEADER_NONE;
break;
}
case MEHOSTCMDID_FLAGS:
{
DWORD outFlags = 0,
fBodyFlags;
Assert(pvaOut);
V_VT(pvaOut) = VT_I4;
hr = m_pBodyOptions->GetFlags(&fBodyFlags);
if (SUCCEEDED(hr))
{
if (fBodyFlags & BOPT_INCLUDEMSG)
outFlags = MEO_FLAGS_INCLUDEMSG;
if ((fBodyFlags & BOPT_HTML) || m_fSecDispInfo)
outFlags |= MEO_FLAGS_HTML;
if (fBodyFlags & BOPT_AUTOINLINE &&
DwGetOption(OPT_AUTO_IMAGE_INLINE)!=AUTO_INLINE_OFF)
{
outFlags |= MEO_FLAGS_AUTOINLINE;
if (DwGetOption(OPT_AUTO_IMAGE_INLINE) == AUTO_INLINE_SLIDE)
outFlags |= MEO_FLAGS_SLIDESHOW;
}
if (fBodyFlags & BOPT_SENDIMAGES)
outFlags |= MEO_FLAGS_SENDIMAGES;
if (fBodyFlags & BOPT_AUTOTEXT)
outFlags |= MEO_FLAGS_AUTOTEXT;
if (fBodyFlags & BOPT_BLOCKQUOTE)
outFlags |= MEO_FLAGS_BLOCKQUOTE;
if (fBodyFlags & BOPT_SENDEXTERNALS)
outFlags |= MEO_FLAGS_SENDEXTERNALIMGSRC;
if (fBodyFlags & BOPT_SPELLINGOREORIGINAL)
outFlags |= MEO_FLAGS_DONTSPELLCHECKQUOTED;
}
V_I4(pvaOut) = outFlags;
break;
}
case MEHOSTCMDID_QUOTE_CHAR:
{
BODYOPTINFO boi;
Assert(pvaOut);
boi.dwMask = BOPTF_QUOTECHAR;
hr = m_pBodyOptions->GetInfo(&boi);
V_VT(pvaOut) = VT_I4;
V_I4(pvaOut) = boi.chQuote;
break;
}
case MEHOSTCMDID_REPLY_TICK_COLOR:
{
BODYOPTINFO boi;
Assert(pvaOut);
boi.dwMask = BOPTF_REPLYTICKCOLOR;
hr = m_pBodyOptions->GetInfo(&boi);
V_VT(pvaOut) = VT_I4;
V_I4(pvaOut) = boi.dwReplyTickColor;
break;
}
case MEHOSTCMDID_COMPOSE_FONT:
{
BODYOPTINFO boi;
DWORD fBodyFlags = 0;
Assert(pvaOut);
hr = m_pBodyOptions->GetFlags(&fBodyFlags);
if (SUCCEEDED(hr) && (fBodyFlags & BOPT_NOFONTTAG))
{
V_BSTR(pvaOut) = NULL;
break;
}
boi.dwMask = BOPTF_COMPOSEFONT;
hr = m_pBodyOptions->GetInfo(&boi);
if (SUCCEEDED(hr))
{
V_VT(pvaOut) = VT_BSTR;
hr = HrLPSZToBSTR(boi.rgchComposeFont, &V_BSTR(pvaOut));
}
break;
}
case MEHOSTCMDID_IS_READ_IN_TEXT_ONLY:
{
if (VT_BOOL == pvaOut->vt)
{
if (m_fSecDispInfo || m_fShowingErrorPage || !DwGetOption(OPT_READ_IN_TEXT_ONLY))
pvaOut->boolVal = VARIANT_FALSE;
else
pvaOut->boolVal = VARIANT_TRUE;
hr = S_OK;
}
else
{
hr = E_INVALIDARG;
}
break;
}
case MEHOSTCMDID_HTML_HELP:
{
Assert(pvaOut);
V_VT(pvaOut) = VT_BOOL;
V_BOOL(pvaOut) = (m_fSecDispInfo || m_fShowingErrorPage)?VARIANT_TRUE:VARIANT_FALSE;
break;
}
default:
fCommandHandled = FALSE;
break;
}
}
if (fCommandHandled)
goto exit;
switch (nCmdID)
{
case MEHOSTCMDID_ADD_TO_ADDRESSBOOK:
{
Assert(pvaIn);
Assert(V_BSTR(pvaIn));
hr = HrAddToWab(V_BSTR(pvaIn));
break;
}
case MEHOSTCMDID_ADD_TO_FAVORITES:
{
BSTR bstrURL=0, bstrDescr=0;
LONG l;
Assert(pvaIn);
l=0;
IF_FAILEXIT(hr=SafeArrayGetElement(V_ARRAY(pvaIn), &l, &bstrDescr));
l=1;
IF_FAILEXIT(hr=SafeArrayGetElement(V_ARRAY(pvaIn), &l, &bstrURL));
hr = HrAddToFavorites(bstrDescr, bstrURL);
break;
}
case MEHOSTCMDID_SLIDESHOW_DELAY:
{
Assert(pvaOut);
V_VT(pvaOut) = VT_I4;
V_I4(pvaOut) = 3000; //In milleseconds
break;
}
case MEHOSTCMDID_ONPARSECOMPLETE:
{
if (!m_fBlockingOnSMime)
OnDocumentReady();
break;
}
case MEHOSTCMDID_FONTCACHE:
{
Assert(pvaOut);
if (g_lpIFontCache)
{
V_VT(pvaOut) = VT_UNKNOWN;
V_UNKNOWN(pvaOut) = g_lpIFontCache;
g_lpIFontCache->AddRef();
} else
hr = E_FAIL;
break;
}
case MEHOSTCMDID_BORDERFLAGS:
{
Assert(pvaOut);
V_VT(pvaOut) = VT_I4;
V_I4(pvaOut) = m_dwBorderFlags;
break;
}
// in the case where m_pBodyOptions is not initialized we're
// likely in a non-message window so just default to internet zone
case MEHOSTCMDID_SECURITY_ZONE:
{
Assert(pvaOut);
V_VT(pvaOut) = VT_I4;
V_I4(pvaOut) = URLZONE_INTERNET;
break;
}
default:
hr = OLECMDERR_E_NOTSUPPORTED;
break;
}
}
else if (IsEqualGUID(CMDSETID_OESecurity, *pguidCmdGroup))
{
if ((OECSECCMD_ENCRYPTED == nCmdID) || (OECSECCMD_SIGNED == nCmdID))
{
if(m_pSecureMessage && (CheckSecReceipt(m_pSecureMessage) == S_OK))
{
hr = HrShowSecurityProperty(m_hwnd, m_pSecureMessage);
}
else
hr = HrShowSecurityProperty(m_hwnd, m_pMsg);
}
else
hr = OLECMDERR_E_NOTSUPPORTED;
} else
hr = OLECMDERR_E_NOTSUPPORTED;
exit:
return hr;
}
HRESULT CMimeEditDocHost::HrAddToFavorites(BSTR bstrDescr, BSTR bstrURL)
{
HRESULT hr = E_FAIL;
hr = AddUrlToFavorites(m_hwnd, bstrURL, bstrDescr, TRUE);
if(FAILED(hr))
AthMessageBoxW(m_hwnd, MAKEINTRESOURCEW(idsAthenaMail), MAKEINTRESOURCEW(idsErrFavorites), NULL, MB_OK);
return (TraceResult(hr));
}
HRESULT CMimeEditDocHost::HrAddToWab(BSTR bstr)
{
LPWAB lpWab;
HRESULT hr;
INT idsErr=0;
ADRINFO AdrInfo;
LPSTR psz;
hr = HrCreateWabObject(&lpWab);
if (!FAILED(hr))
{
if (bstr)
{
ZeroMemory(&AdrInfo, sizeof(ADRINFO));
AdrInfo.lpwszAddress = bstr;
AdrInfo.lpwszDisplay = bstr;
hr = lpWab->HrAddToWAB(m_hwnd, &AdrInfo);
if (FAILED(hr) && hr!=MAPI_E_USER_CANCEL)
{
if(hr==MAPI_E_COLLISION)
idsErr=idsErrAddrDupe;
else
idsErr=idsErrAddToWAB;
}
if(idsErr)
AthMessageBoxW(m_hwnd, MAKEINTRESOURCEW(idsAthenaMail), MAKEINTRESOURCEW(idsErr), NULL, MB_OK);
}
lpWab->Release();
}
return hr;
}
//+---------------------------------------------------------------
//
// Member: WMSize
//
// Synopsis:
//
//---------------------------------------------------------------
void CMimeEditDocHost::WMSize(int cxBody, int cyBody)
{
RECT rc={0};
TraceCall("CMimeEditDocHost::WMSize");
if(m_pDocView)
{
rc.bottom=cyBody;
rc.right=cxBody;
m_pDocView->SetRect(&rc);
}
// notify the subclass of a wmsize
OnWMSize(&rc);
}
// *** IOleControlSite ***
//+---------------------------------------------------------------
//
// Member: OnControlInfoChanged
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnControlInfoChanged()
{
TraceCall("CMimeEditDocHost::OnControlInfoChanged");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: LockInPlaceActive
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::LockInPlaceActive(BOOL fLock)
{
TraceCall("CMimeEditDocHost::LockInPlaceActive");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: GetExtendedControl
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::GetExtendedControl(LPDISPATCH *ppDisp)
{
TraceCall("CMimeEditDocHost::GetExtendedControl");
if (ppDisp)
*ppDisp=NULL;
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: TransformCoords
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::TransformCoords(POINTL *pPtlHimetric, POINTF *pPtfContainer,DWORD dwFlags)
{
TraceCall("CMimeEditDocHost::TransformCoords");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: TranslateAccelerator
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::TranslateAccelerator(LPMSG lpMsg, DWORD grfModifiers)
{
TraceCall("CMimeEditDocHost::TranslateAccelerator");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: OnFocus
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnFocus(BOOL fGotFocus)
{
HRESULT hr = S_OK;
m_fUIActive = !!fGotFocus;
if (m_pDocView)
hr = m_pDocView->UIActivate(fGotFocus);
return hr;
}
//+---------------------------------------------------------------
//
// Member: ShowPropertyFrame
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::ShowPropertyFrame(void)
{
TraceCall("CMimeEditDocHost::ShowPropertyFrame");
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: OnUpdateCommands
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CMimeEditDocHost::OnUpdateCommands()
{
TraceCall("CMimeEditDocHost::OnUpdateCommands");
SendMessage(GetParent(m_hwnd), NWM_UPDATETOOLBAR, 0, 0);
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::Load(LPMIMEMESSAGE pMsg)
{
SECSTATE secState = {0};
DWORD dw = 0;
HRESULT hr;
m_fFixedFont = FALSE;
RegisterForHTMLDocEvents(FALSE);
m_fSecDispInfo = FALSE; // reset flag
m_fShowingErrorPage = FALSE;
m_fSecureReceipt = FALSE;
if(CheckSecReceipt(pMsg) == S_OK)
{
HrGetSecurityState(pMsg, &secState, NULL);
m_fSecureReceipt = TRUE;
m_fIsEncrypted = !!IsEncrypted(secState.type);
m_fIsSigned = !!IsSigned(secState.type);
m_fSignTrusted = !!IsSignTrusted(&secState);
m_fEncryptionOK = !!IsEncryptionOK(&secState);
hr = LoadSecurely(pMsg, &secState);
CleanupSECSTATE(&secState);
}
else if (IsSecure(pMsg) && SUCCEEDED(HrGetSecurityState(pMsg, &secState, NULL)))
{
m_fIsEncrypted = !!IsEncrypted(secState.type);
m_fIsSigned = !!IsSigned(secState.type);
m_fSignTrusted = !!IsSignTrusted(&secState);
m_fEncryptionOK = !!IsEncryptionOK(&secState);
hr = LoadSecurely(pMsg, &secState);
CleanupSECSTATE(&secState);
}
else
{
m_fIsEncrypted = FALSE;
m_fIsSigned = FALSE;
m_fSignTrusted = TRUE;
m_fEncryptionOK = TRUE;
hr = InternalLoad(pMsg);
}
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::InternalLoad(IMimeMessage *pMsg)
{
SECSTATE secState = {0};
DWORD dw = 0;
HRESULT hr;
DWORD dwBodyFlags = 0;
BOOLEAN fProcess = FALSE;
ReplaceInterface(m_pMsg, pMsg);
if(m_pBodyOptions)
{
m_pBodyOptions->GetFlags(&dwBodyFlags);
m_fMarkedRead = (0 == (dwBodyFlags & BOPT_UNREAD));
if (!m_fMarkedRead)
{
if (!m_fSecDispInfo && !!(dwBodyFlags & BOPT_MAIL))
fProcess = TRUE;
if (dwBodyFlags & BOPT_FROM_NOTE)
{
//Since opening a message in a note, it should be marked as read immediately.
HrMarkAsRead();
}
else
{
// ReplaceInterface(m_pMsg, pMsg);
if (m_pBodyOptions->GetMarkAsReadTime(&dw) == S_OK)
{
if (dw == 0)
HrMarkAsRead();
else
if (dw != OPTION_OFF)
SetTimer(m_hwnd, idTimerMarkAsRead, dw*1000, NULL);
}
else
HrMarkAsRead();
}
}
}
hr = m_pPrstMime->Load(m_pMsg);
if ((fProcess) && !(dwBodyFlags & BOPT_FROM_NOTE) && SUCCEEDED(hr) && (m_pEventSink))
{
m_pEventSink->EventOccurred(MEHC_CMD_PROCESS_RECEIPT, m_pMsg);
}
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::Save(LPMIMEMESSAGE pMsg, DWORD dwFlags)
{
DWORD idsWarning;
HRESULT hr;
Assert(m_pPrstMime);
hr = m_pPrstMime->Save(pMsg, dwFlags);
switch (hr)
{
case MIMEEDIT_E_CANNOTSAVEWHILESOURCEEDITING:
AthMessageBoxW(m_hwnd, MAKEINTRESOURCEW(idsAthena), MAKEINTRESOURCEW(idsErrCannotSaveInSourceEdit), NULL, MB_OK|MB_ICONEXCLAMATION);
hr = MAPI_E_USER_CANCEL;
break;
// brettm: for OE5 we no longer warn if trident is not readystate complete. In the case of active movie controls
// they never go readyState complete 'by design' as they never loaded the source url. The warning is annoying for
// msphone message forwarding. for images we check individual readystates anyway.
//case MIMEEDIT_W_DOWNLOADNOTCOMPLETE:
case MIMEEDIT_W_BADURLSNOTATTACHED:
if (IDYES != AthMessageBoxW(m_hwnd, MAKEINTRESOURCEW(idsAthena), MAKEINTRESOURCEW(idsErrBadMHTMLLinks), NULL, MB_YESNO|MB_ICONEXCLAMATION |MB_DEFBUTTON2))
hr = MAPI_E_USER_CANCEL;
break;
case MIMEEDIT_E_CANNOTSAVEUNTILPARSECOMPLETE:
AthMessageBoxW(m_hwnd, MAKEINTRESOURCEW(idsAthena), MAKEINTRESOURCEW(idsErrNotSaveUntilDownloadDone), NULL, MB_OK|MB_ICONEXCLAMATION);
hr = MAPI_E_USER_CANCEL;
}
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::GetClassID(CLSID *pClsID)
{
return E_NOTIMPL;
}
// ********************************************
HRESULT CMimeEditDocHost::HrOnDocObjCreate()
{
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::HrGetElement(LPCTSTR pszName, IHTMLElement **ppElem)
{
return ::HrGetElementImpl(m_pDoc, pszName, ppElem);
}
// ********************************************
HRESULT CMimeEditDocHost::HrSpellCheck(BOOL fSuppressDoneMsg)
{
return m_pCmdTarget ? m_pCmdTarget->Exec(NULL, OLECMDID_SPELL,
fSuppressDoneMsg ? OLECMDEXECOPT_DONTPROMPTUSER : OLECMDEXECOPT_PROMPTUSER , NULL, NULL) : E_FAIL;
}
// ********************************************
HRESULT CMimeEditDocHost::HrPrint(BOOL fPrompt)
{
VARIANTARG va;
HRESULT hr;
if (!m_pCmdTarget)
return E_FAIL;
va.vt = VT_BSTR;
va.bstrVal = NULL;
GetOEUserName(&va.bstrVal);
hr = m_pCmdTarget->Exec(NULL, OLECMDID_PRINT,
fPrompt ? OLECMDEXECOPT_PROMPTUSER : OLECMDEXECOPT_DONTPROMPTUSER, &va, NULL);
SysFreeString(va.bstrVal);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrIsEmpty(BOOL *pfEmpty)
{
return ExecGetBool(&CMDSETID_MimeEdit, MECMDID_EMPTY, pfEmpty);
}
// ********************************************
HRESULT CMimeEditDocHost::HrUnloadAll(UINT idsDefaultBody, DWORD dwFlags)
{
TCHAR rgch[CCHMAX_STRINGRES];
KillTimer(m_hwnd, idTimerMarkAsRead);
m_fIsEncrypted = FALSE;
m_fIsSigned = FALSE;
m_fSignTrusted = TRUE;
m_fEncryptionOK = TRUE;
HrInitNew(m_lpOleObj);
if (idsDefaultBody)
{
LoadString(g_hLocRes, idsDefaultBody, rgch, ARRAYSIZE(rgch));
HrSetText(rgch);
}
return S_OK;
}
// ********************************************
BOOL CMimeEditDocHost::WMCommand(HWND hwnd, int id, WORD wCmd)
{
return SUCCEEDED(HrWMCommand(hwnd, id, wCmd));
}
// ********************************************
BOOL CMimeEditDocHost::WMNotify(int idFrom, NMHDR *pnmh)
{
return FALSE;
}
// ********************************************
HRESULT CMimeEditDocHost::HrIsDirty(BOOL *pfDirty)
{
return ExecGetBool(&CMDSETID_MimeEdit, MECMDID_DIRTY, pfDirty);
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetDirtyFlag(BOOL fDirty)
{
return ExecSetBool(&CMDSETID_MimeEdit, MECMDID_DIRTY, fDirty);
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetStyle(DWORD dwStyle)
{
HRESULT hr = ExecSetI4(&CMDSETID_MimeEdit, MECMDID_STYLE, dwStyle);
if (SUCCEEDED(hr))
m_dwDocStyle = dwStyle;
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrGetStyle(DWORD *pdwStyle)
{
*pdwStyle = m_dwDocStyle;
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::HrEnableHTMLMode(BOOL fOn)
{
BOOL fEdit=FALSE;
m_fFixedFont = FALSE;
// if turning HTML mode on, turn on the source tabs
if (fOn && HrIsEditMode(&fEdit)==S_OK && fEdit)
ExecSetBool(&CMDSETID_MimeEdit, MECMDID_SHOWSOURCETABS, DwGetOption(OPT_VIEWSOURCETABS));
return ExecSetBool(&CMDSETID_MimeEdit, MECMDID_EDITHTML, fOn);
}
// ********************************************
HRESULT CMimeEditDocHost::HrIsHTMLMode()
{
ULONG cmdf=0;
QuerySingleMimeEditCmd(MECMDID_EDITHTML, &cmdf);
return (cmdf & OLECMDF_LATCHED) ? S_OK :S_FALSE;
}
// ********************************************
HRESULT CMimeEditDocHost::HrDowngradeToPlainText()
{
return ExecCommand(&CMDSETID_MimeEdit, MECMDID_DOWNGRADEPLAINTEXT);
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetText(LPSTR lpsz)
{
TCHAR rgch[CCHMAX_STRINGRES];
RegisterForHTMLDocEvents(FALSE);
m_fShowingErrorPage = TRUE;
if (HIWORD(lpsz)==0)
{
LoadString(g_hLocRes, LOWORD(lpsz), rgch, ARRAYSIZE(rgch));
lpsz = rgch;
}
return ExecSetText(&CMDSETID_MimeEdit, MECMDID_SETTEXT, lpsz);
}
// ********************************************
HRESULT CMimeEditDocHost::HrPerformROT13Encoding()
{
return ExecCommand(&CMDSETID_MimeEdit, MECMDID_ROT13);
}
// ********************************************
HRESULT CMimeEditDocHost::LoadHtmlErrorPage(LPCSTR pszURL)
{
HRESULT hr;
LPSTR pszUrlFree=NULL;
// if relative, wrap in our res:// handler
pszUrlFree = PszAllocResUrl((LPSTR)pszURL);
if (!pszUrlFree)
return E_OUTOFMEMORY;
hr = HrLoadURL(pszUrlFree);
if (SUCCEEDED(hr))
RegisterForHTMLDocEvents(TRUE);
m_fIsEncrypted = FALSE;
m_fIsSigned = FALSE;
m_fSignTrusted = TRUE;
m_fEncryptionOK = TRUE;
m_fShowingErrorPage = TRUE;
SafeMemFree(pszUrlFree);
return hr;
}
// ********************************************
// Base assumes that is URL to MHTML
HRESULT CMimeEditDocHost::HrLoadURL(LPCSTR pszURL)
{
BSTR bstr = NULL;
IMoniker *pMoniker = NULL;
IPersistMoniker *pPrstMnkr = NULL;
HRESULT hr;
hr = HrLPSZToBSTR(pszURL, &bstr);
if (FAILED(hr))
goto error;
hr = CreateURLMoniker(NULL, bstr, &pMoniker);
if (FAILED(hr))
goto error;
hr = m_lpOleObj->QueryInterface(IID_IPersistMoniker, (LPVOID*)&pPrstMnkr);
if (FAILED(hr))
goto error;
hr = pPrstMnkr->Load(FALSE, pMoniker, NULL, 0);
error:
SysFreeString(bstr);
SafeRelease(pMoniker);
SafeRelease(pPrstMnkr);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrInsertTextFile(LPSTR lpsz)
{
return ExecSetText(&CMDSETID_MimeEdit, MECMDID_INSERTTEXTFILE, lpsz);
}
// ********************************************
HRESULT CMimeEditDocHost::HrInsertTextFileFromDialog()
{
return ExecCommand(&CMDSETID_MimeEdit, MECMDID_INSERTTEXTFILE);
}
// ********************************************
HRESULT CMimeEditDocHost::HrViewSource(DWORD dwViewType)
{
return ExecSetI4(&CMDSETID_MimeEdit, MECMDID_VIEWSOURCE, dwViewType);
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetPreviewFormat(LPSTR lpsz)
{
BSTR bstr;
VARIANTARG var;
if (!m_pCmdTarget)
return E_FAIL;
HRESULT hr = HrLPSZToBSTR(lpsz, &bstr);
if (FAILED(hr))
goto Exit;
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = bstr;
hr = m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_PREVIEWFORMAT, OLECMDEXECOPT_DODEFAULT, &var, NULL);
SysFreeString(bstr);
Exit:
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetEditMode(BOOL fOn)
{
ExecSetBool(&CMDSETID_MimeEdit, MECMDID_EDITMODE, fOn);
if (fOn && HrIsHTMLMode()==S_OK)
ExecSetBool(&CMDSETID_MimeEdit, MECMDID_SHOWSOURCETABS, DwGetOption(OPT_VIEWSOURCETABS));
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::HrIsEditMode(BOOL *pfOn)
{
return ExecGetBool(&CMDSETID_MimeEdit, MECMDID_EDITMODE, pfOn);
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetCharset(HCHARSET hCharset)
{
return ExecSetI8(&CMDSETID_MimeEdit, MECMDID_CHARSET, reinterpret_cast<ULONGLONG>(hCharset));
}
// ********************************************
HRESULT CMimeEditDocHost::HrGetCharset(HCHARSET *phCharset)
{
HRESULT hr;
ULONGLONG ullCharset;
hr = ExecGetI8(&CMDSETID_MimeEdit, MECMDID_CHARSET, &ullCharset);
*phCharset = reinterpret_cast<HCHARSET>(ullCharset);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrSaveAsStationery(LPWSTR pwszFile)
{
BSTR bstr = NULL;
VARIANTARG varIn,
varOut;
HRESULT hr = S_OK;
V_VT(&varOut) = VT_EMPTY;
if (!m_pCmdTarget)
IF_FAILEXIT(hr = E_FAIL);
if (pwszFile)
{
IF_NULLEXIT(bstr = SysAllocString(pwszFile));
}
else
{
WCHAR wszPath[MAX_PATH];
HrGetStationeryPath(wszPath);
IF_NULLEXIT(bstr = SysAllocString(wszPath));
}
V_VT(&varIn) = VT_BSTR;
V_BSTR(&varIn) = bstr;
IF_FAILEXIT(hr = m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_SAVEASSTATIONERY, OLECMDEXECOPT_DODEFAULT, &varIn, &varOut));
if (V_VT(&varOut) == VT_BSTR)
{
IF_FAILEXIT(hr = HrAddToStationeryMRU(V_BSTR(&varOut)));
}
exit:
SysFreeString(bstr);
if (VT_EMPTY != V_VT(&varOut))
SysFreeString(V_BSTR(&varOut));
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrApplyStationery(LPWSTR pwszFile)
{
IStream *pstm = NULL;
IHTMLDocument2 *pDoc = NULL;
HRESULT hr = S_OK;
VARIANTARG var;
if (!m_pCmdTarget)
IF_FAILEXIT(hr = E_FAIL);
// Apply stationery
// if no filename in buffer, means No Stationery was called
if (*pwszFile)
{
// Don't need to deal with the unicode stream issue when
// returning from HrCreateBasedWebPage in this case. There
// are only a few attributes that are saved when applying
// stationery and the ones we care about seem OK right now.
IF_FAILEXIT(hr = HrCreateBasedWebPage(pwszFile, &pstm));
IF_FAILEXIT(hr = MimeEditDocumentFromStream(pstm, IID_IHTMLDocument2, (LPVOID*)&pDoc));
}
var.vt = VT_UNKNOWN;
var.punkVal = pDoc;
IF_FAILEXIT(hr = m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_APPLYDOCUMENT, OLECMDEXECOPT_DODEFAULT, &var, NULL));
exit:
ReleaseObj(pstm);
ReleaseObj(pDoc);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrUpdateFormatBar()
{
return E_NOTIMPL;
}
// ********************************************
HRESULT CMimeEditDocHost::HrClearFormatting()
{
return E_NOTIMPL;
}
// ********************************************
HRESULT CMimeEditDocHost::HrMEDocHost_Init(BOOL fInit)
{
WNDCLASSW wc={0};
if(fInit)
{
// RAID - 12563
// We need to check to see if the class has been registered
// already, because our DLL might get unloaded
if (0 == GetClassInfoWrapW(g_hInst, c_wszMEDocHostWndClass, &wc)) // already regisered
{
wc.lpfnWndProc = CMimeEditDocHost::ExtWndProc;
wc.hInstance = g_hInst;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = c_wszMEDocHostWndClass;
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wc.style = CS_DBLCLKS;
if(!RegisterClassWrapW(&wc))
return E_OUTOFMEMORY;
}
}
else if (0 != GetClassInfoWrapW(g_hInst, c_wszMEDocHostWndClass, &wc))
// don't need to enterCS for this, as it's the process going down.
UnregisterClassWrapW(c_wszDocHostWndClass, g_hInst);
return NOERROR;
}
// ********************************************
HRESULT CMimeEditDocHost::HrPostInit()
{
HRESULT hr = CreateDocObj((LPCLSID)&CLSID_MimeEdit);
if (FAILED(hr))
return hr;
hr = Show();
if(FAILED(hr))
return hr;
return HrOnDocObjCreate();
}
// ********************************************
HRESULT CMimeEditDocHost::HrInit(HWND hwndParent, DWORD dwFlags, IBodyOptions *pBodyOptions)
{
HRESULT hr = S_OK;
HWND hwnd = 0;
m_dwStyle=dwFlags;
Assert(!m_pBodyOptions);
if (pBodyOptions)
{
m_pBodyOptions = pBodyOptions;
pBodyOptions->AddRef();
}
if(!IsWindow(hwndParent))
IF_FAILEXIT(hr = E_INVALIDARG);
IF_FAILEXIT(hr=HrMEDocHost_Init(TRUE));
hwnd=CreateWindowExWrapW(WS_EX_NOPARENTNOTIFY,
c_wszMEDocHostWndClass, NULL,
WS_CLIPCHILDREN|WS_CLIPSIBLINGS|WS_CHILD|WS_TABSTOP,
0,0,0,0, hwndParent,
(HMENU)idREBody, g_hInst, (LPVOID)this);
IF_NULLEXIT(hwnd);
IF_FAILEXIT(hr = HrCreateColorMenu(ID_FORMAT_COLOR1, &m_hmenuColor, FALSE));
IF_FAILEXIT(hr = HrPostInit());
exit:
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrClose()
{
// Don't call HrUnloadAll on close as it's redundant to
// clear out the contents with an InitNew. We simply force the docobj
// down with it current content
SafeRelease(m_pBodyOptions);
CloseDocObj();
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetStatusBar(CStatusBar *pStatus)
{
SafeRelease(m_pStatus);
m_pStatus=pStatus;
if(pStatus)
pStatus->AddRef();
return NOERROR;
}
// ********************************************
HRESULT CMimeEditDocHost::HrUpdateToolbar(HWND hwndToolbar)
{
HRESULT hr=NOERROR;
ULONG cmdf=0;
if(!IsWindow(hwndToolbar))
return E_INVALIDARG;
QuerySingleMimeEditCmd(MECMDID_INSERTHTML, &cmdf);
if ((cmdf & OLECMDF_ENABLED) &&
m_pBodyOptions &&
m_pBodyOptions->SignatureEnabled(FALSE)==S_OK && m_fUIActive)
SendMessage(hwndToolbar, TB_ENABLEBUTTON, ID_INSERT_SIGNATURE, MAKELONG(TRUE, 0));
else
SendMessage(hwndToolbar, TB_ENABLEBUTTON, ID_INSERT_SIGNATURE, 0);
// if docobj has focus, query the command target to get info.
if (m_fUIActive)
hr=HrCmdTgtUpdateToolbar(m_pCmdTarget, hwndToolbar);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::GetTabStopArray(HWND *rgTSArray, int *pcArrayCount)
{
Assert(rgTSArray);
Assert(pcArrayCount);
Assert(*pcArrayCount > 0);
IOleWindow *pWindow = NULL;
HWND hWnd;
*pcArrayCount = 0;
HRESULT hr = m_pDoc->QueryInterface(IID_IOleWindow, (LPVOID *)&pWindow);
if (FAILED(hr))
goto error;
hr = pWindow->GetWindow(&hWnd);
if (FAILED(hr))
goto error;
*rgTSArray = hWnd;
*pcArrayCount = 1;
error:
SafeRelease(pWindow);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrInsertSignature(int id)
{
char szID[MAXSIGID], *pszID;
HRESULT hr=S_OK;
BSTR bstr;
DWORD dwSigOpt;
if (!m_pCmdTarget)
return E_FAIL;
Assert((ID_INSERT_SIGNATURE == id) || (id >= ID_SIGNATURE_FIRST && id <= ID_SIGNATURE_LAST));
Assert(m_pBodyOptions);
if(!m_pBodyOptions)
return E_FAIL;
if ((ID_INSERT_SIGNATURE == id) || FAILED(GetSigFromCmd(id, szID, ARRAYSIZE(szID))))
{
pszID = NULL;
}
else
{
pszID = szID;
}
if (m_pBodyOptions->SignatureEnabled(FALSE)==S_OK)
{
if (SUCCEEDED(hr = m_pBodyOptions->GetSignature(pszID, &dwSigOpt, &bstr)))
{
DWORD cmd;
VARIANTARG var;
if ((dwSigOpt & SIGOPT_PREFIX) && (0 == (dwSigOpt & SIGOPT_HTML)))
{
BSTR bstrPrefix;
if (HrLPSZToBSTR(c_szSigPrefix, &bstrPrefix)==S_OK)
{
UINT sigLen = lstrlenW(bstr),
preLen = lstrlenW(bstrPrefix);
// SysAllocStringLen includes one for the NULL
BSTR bstrTempBuf = SysAllocStringLen(NULL, preLen + sigLen);
if (bstrTempBuf)
{
memcpy(bstrTempBuf, bstrPrefix, preLen*sizeof(*bstrPrefix));
memcpy((bstrTempBuf + preLen), bstr, sigLen*sizeof(*bstr));
bstrTempBuf[preLen + sigLen] = L'\0';
SysFreeString(bstr);
bstr = bstrTempBuf;
}
SysFreeString(bstrPrefix);
}
}
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = bstr;
cmd = dwSigOpt&SIGOPT_HTML ? MECMDID_INSERTHTML : MECMDID_INSERTTEXT;
hr = m_pCmdTarget->Exec(&CMDSETID_MimeEdit, cmd, OLECMDEXECOPT_DODEFAULT, &var, NULL);
SysFreeString(bstr);
}
}
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrShow(BOOL fVisible)
{
ShowWindow(m_hwnd, fVisible ? SW_SHOW : SW_HIDE);
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::ViewCertificate(PCCERT_CONTEXT pCert, HCERTSTORE hcMsg)
{
return CommonUI_ViewSigningCertificate(m_hwnd, pCert, hcMsg);
}
// ********************************************
HRESULT CMimeEditDocHost::EditTrust(PCCERT_CONTEXT pCert, HCERTSTORE hcMsg)
{
return CommonUI_ViewSigningCertificateTrust(m_hwnd, pCert, hcMsg);
}
// ********************************************
HRESULT CMimeEditDocHost::UpdateBackAndStyleMenus(HMENU hmenu)
{
MENUITEMINFO miiBk;
HMENU hmenuTag=NULL;
ZeroMemory(&miiBk, sizeof(miiBk));
miiBk.cbSize=sizeof(miiBk);
miiBk.fMask = MIIM_ID | MIIM_SUBMENU;
if (GetMenuItemInfo(hmenu, ID_POPUP_BACKGROUND_COLOR, FALSE, &miiBk))
{
MENUITEMINFO miiBkColor;
HrCheckColor();
ZeroMemory(&miiBkColor, sizeof(miiBkColor));
miiBkColor.cbSize=sizeof(miiBkColor);
miiBkColor.fMask = MIIM_SUBMENU;
miiBkColor.hSubMenu = m_hmenuColor;
SetMenuItemInfo(hmenu, ID_POPUP_BACKGROUND_COLOR, FALSE, &miiBkColor);
}
if (!m_hmenuStyle)
{
Assert(m_pDoc);
HrCreateTridentMenu(m_pDoc, TM_TAGMENU, ID_FORMAT_FIRST, ID_FORMAT_FIRST - ID_FORMAT_LAST, &m_hmenuStyle);
Assert(m_hmenuStyle);
}
if(m_hmenuStyle)
{
VARIANTARG va;
MENUITEMINFO miiTag;
HrCheckTridentMenu(m_pDoc, TM_TAGMENU, ID_FORMAT_FIRST, ID_FORMAT_LAST, m_hmenuStyle);
ZeroMemory(&miiTag, sizeof(miiTag));
miiTag.cbSize=sizeof(miiTag);
miiTag.fMask = MIIM_SUBMENU;
miiTag.hSubMenu = m_hmenuStyle;
SetMenuItemInfo(hmenu, ID_POPUP_STYLE, FALSE, &miiTag);
}
return S_OK;
}
// ********************************************
void CMimeEditDocHost::UpdateInsertMenu(HMENU hmenu)
{
}
// ********************************************
void CMimeEditDocHost::UpdateEditMenu(HMENU hmenu)
{
}
// ********************************************
void CMimeEditDocHost::UpdateViewMenu(HMENU hmenu)
{
}
// ********************************************
HRESULT CMimeEditDocHost::HrOnInitMenuPopup(HMENU hmenuPopup, UINT uID)
{
if (m_pCmdTarget)
{
switch (uID)
{
case ID_POPUP_FILE:
break;
case ID_POPUP_FORMAT:
break;
case ID_POPUP_LANGUAGE:
{
// Now Let's try to insert document direction menu if applicable
VARIANTARG v = {0};
HRESULT hr;
hr = m_pCmdTarget->Exec(&CGID_ShellDocView,SHDVID_GETDOCDIRMENU, OLECMDEXECOPT_DODEFAULT, NULL, &v);
if (S_OK == hr)
{
MENUITEMINFOW mii;
HMENU hmenuDocDir = (HMENU)IntToPtr(v.lVal);
UINT uItemDir = 0, uItem = GetMenuItemCount(hmenuPopup);
WCHAR wszText[MAX_PATH];
ZeroMemory(&mii, sizeof(MENUITEMINFO));
mii.cbSize = sizeof(MENUITEMINFO);
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_TYPE;
mii.fType = MFT_SEPARATOR;
InsertMenuItemWrapW(hmenuPopup, (UINT)uItem, TRUE, &mii);
mii.fMask = MIIM_CHECKMARKS|MIIM_DATA|MIIM_ID|MIIM_STATE|MIIM_SUBMENU|MIIM_TYPE;
mii.fType = MFT_STRING;
mii.dwTypeData = wszText;
mii.cch = MAX_PATH;
while (GetMenuItemInfoWrapW(hmenuDocDir, uItemDir, TRUE, &mii))
{
mii.wID = ID_DOCDIR_LTR + uItemDir;
mii.fType |= MFT_RADIOCHECK;
mii.cch = ARRAYSIZE(wszText);
InsertMenuItemWrapW(hmenuPopup, (UINT)(uItemDir + uItem + 1), TRUE, &mii);
uItemDir++;
}
}
}
break;
case ID_POPUP_INSERT:
UpdateInsertMenu(hmenuPopup);
break;
case ID_POPUP_EDIT:
UpdateEditMenu(hmenuPopup);
break;
case ID_POPUP_VIEW:
UpdateViewMenu(hmenuPopup);
break;
case ID_POPUP_TOOLS:
break;
}
}
return NOERROR;
}
// ********************************************
HRESULT CMimeEditDocHost::HrWMMenuSelect(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
TCHAR szRes[CCHMAX_STRINGRES];
if (!m_pStatus)
return S_FALSE;
if (LOWORD(wParam)>=ID_LANG_FIRST && LOWORD(wParam) <= ID_LANG_LAST)
{
m_pStatus->ShowSimpleText(MAKEINTRESOURCE(idsViewLanguageGeneralHelp));
return S_OK;
}
if (LOWORD(wParam)>=ID_FORMAT_FIRST && LOWORD(wParam)<=ID_FORMAT_LAST)
{
// ~~~ did I choose the correct item for idsFmtTagGeneralHelp
m_pStatus->ShowSimpleText(MAKEINTRESOURCE(ID_HELP_CONTENTS));
return S_OK;
}
return S_FALSE;
}
// ********************************************
HRESULT CMimeEditDocHost::HrCheckColor()
{
HRESULT hr;
INT iFound = -1;
DWORD dwRGB;
hr = ExecGetI4(&CMDSETID_MimeEdit, MECMDID_BACKGROUNDCOLOR, &dwRGB);
if (0 == dwRGB)
iFound = 0;
else
iFound = GetColorIndex(dwRGB) - 1;
CheckMenuRadioItem(m_hmenuColor, ID_FORMAT_COLOR1, ID_FORMAT_COLOR16, ID_FORMAT_COLOR1 + iFound, MF_BYCOMMAND);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrWMDrawMenuItem(HWND hwnd, LPDRAWITEMSTRUCT pdis)
{
// There is a bug in win95 that will sign extend the ID so that the
// hiword is filled with FFFF. Take the low word of the ID to work
// around this.
UINT id = LOWORD(pdis->itemID);
if (id >= ID_FORMAT_COLOR1 && id <=ID_FORMAT_COLOR16)
Color_WMDrawItem(pdis, iColorMenu);
return NOERROR;
}
// ********************************************
HRESULT CMimeEditDocHost::HrWMMeasureMenuItem(HWND hwnd, LPMEASUREITEMSTRUCT pmis)
{
HDC hdc;
UINT id = pmis->itemID;
if (id >= ID_FORMAT_COLOR1 && id <=ID_FORMAT_COLOR16)
{
hdc = GetDC(hwnd);
if(hdc)
{
Color_WMMeasureItem(hdc, pmis, iColorMenu);
ReleaseDC( hwnd, hdc );
}
}
return NOERROR;
}
// ********************************************
HRESULT CMimeEditDocHost::HrBackgroundImage()
{
WCHAR wszURL[INTERNET_MAX_URL_LENGTH+10];
LPWSTR pwszBackName;
HRESULT hr = S_OK;
*wszURL = 0;
hr = ExecGetTextW(&CMDSETID_MimeEdit, MECMDID_BACKGROUNDIMAGE, &pwszBackName);
// ~~~ MimeEdit returns E_FAIL if no image found. MimeEdit will change to return S_OK is this case
// Once it is changed can delete these lines.
if (E_FAIL == hr)
hr = S_OK;
IF_FAILEXIT(hr);
if (pwszBackName != NULL)
StrCpyNW(wszURL, pwszBackName, INTERNET_MAX_URL_LENGTH);
if(DialogBoxParamWrapW(g_hLocRes, MAKEINTRESOURCEW(iddBkImage), m_hwnd, BkImageDlgProc, (LPARAM)wszURL)==IDCANCEL)
{
hr = S_OK;
goto exit;
}
// nothing has been changed, so do nothing.
if ((pwszBackName!=NULL && StrCmpIW(pwszBackName, wszURL)==0) ||
// there is no background at all.
(pwszBackName==NULL && lstrlenW(wszURL)==0))
goto exit;
InsertStationeryDir(wszURL);
hr = ExecSetTextW(&CMDSETID_MimeEdit, MECMDID_BACKGROUNDIMAGE, wszURL);
exit:
MemFree(pwszBackName);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrWMCommand(HWND hwnd, int id, WORD wCmd)
{
DWORD dwStdCmd = 0,
dwMECmd = 0,
dwF3Cmd = 0;
DWORD dw;
ULONG cmdf;
if(!m_pCmdTarget)
return S_FALSE;
// commands that don't care if we're UI Active
if (id >= ID_FORMAT_COLOR1 && id <= ID_FORMAT_COLOR16)
{
int index = id - ID_FORMAT_COLOR1;
ExecSetI4(&CMDSETID_MimeEdit, MECMDID_BACKGROUNDCOLOR, rgrgbColors16[index]);
return S_OK;
}
switch(id)
{
case ID_INSERT_TEXT:
HrInsertTextFileFromDialog();
return S_OK;
case ID_SOURCE_EDIT:
// toggle stat
cmdf=0;
QuerySingleMimeEditCmd(MECMDID_SHOWSOURCETABS, &cmdf);
dw = !(cmdf & OLECMDF_LATCHED);
SetDwOption(OPT_VIEWSOURCETABS, dw, 0, 0);
ExecSetBool(&CMDSETID_MimeEdit, MECMDID_SHOWSOURCETABS, dw);
return S_OK;
case ID_SAVE_ATTACHMENTS:
case ID_NOTE_SAVE_ATTACHMENTS:
dwMECmd = MECMDID_SAVEATTACHMENTS;
break;
case ID_PRINT:
case ID_PRINT_NOW:
HrPrint(id == ID_PRINT);
return S_OK;
case ID_SAVE_STATIONERY:
case ID_NOTE_SAVE_STATIONERY:
HrSaveAsStationery(NULL);
return S_OK;
case ID_UNSCRAMBLE:
HrPerformROT13Encoding();
return S_OK;
case ID_VIEW_MSG_SOURCE:
HrViewSource(MECMD_VS_MESSAGE);
return S_OK;
case ID_VIEW_SOURCE:
HrViewSource(MECMD_VS_HTML);
return S_OK;
case ID_BACKGROUND_SOUND:
HrBackgroundSound();
return S_OK;
case ID_BACKGROUND_PICTURE:
HrBackgroundImage();
return S_OK;
case ID_FIND_TEXT:
dwStdCmd = OLECMDID_FIND;
break;
case ID_FONTS_DIALOG:
dwMECmd = MECMDID_FORMATFONT;
break;
case ID_FORMAT_PARADLG:
dwMECmd = MECMDID_FORMATPARAGRAPH;
break;
case ID_FONTS_LARGEST:
case ID_FONTS_LARGE:
case ID_FONTS_MEDIUM:
case ID_FONTS_SMALL:
case ID_FONTS_SMALLEST:
dwF3Cmd = IDM_BASELINEFONT1 + id - ID_FONTS_SMALLEST;
break;
case ID_FONTS_FIXED:
m_fFixedFont = !m_fFixedFont;
if (m_fFixedFont)
ExecSetBool(&CMDSETID_MimeEdit, MECMDID_DOWNGRADEPLAINTEXT, TRUE);
else
m_pPrstMime->Load(m_pMsg);
return S_OK;
case ID_DOCDIR_LTR:
dwF3Cmd = IDM_DIRLTR;
break;
case ID_DOCDIR_RTL:
dwF3Cmd = IDM_DIRRTL;
break;
}
// commands that are only applicable to UI if we're UIActive
if(m_fUIActive)
{
if ((ID_INSERT_SIGNATURE == id) || (id >= ID_SIGNATURE_FIRST && id <= ID_SIGNATURE_LAST))
{
HrInsertSignature(id);
return S_OK;
}
if (id >= ID_FORMAT_FIRST && id <= ID_FORMAT_LAST)
{
TCHAR szBuf[MAX_PATH];
*szBuf = 0;
GetMenuString(m_hmenuStyle, id, szBuf, MAX_PATH, MF_BYCOMMAND);
Assert(*szBuf);//should not be empty
SideAssert(ExecSetText(&CMDSETID_Forms3, IDM_BLOCKFMT, szBuf) == S_OK);
return S_OK;
}
switch(id)
{
case ID_PASTE:
if(HrPasteToAttachment()!=S_OK)
dwStdCmd = OLECMDID_PASTE;
break;
case ID_EDIT_LINK:
return m_pCmdTarget->Exec(&CMDSETID_Forms3, IDM_HYPERLINK,
OLECMDEXECOPT_PROMPTUSER, NULL, NULL);
case ID_SELECT_ALL:
dwStdCmd = OLECMDID_SELECTALL;
break;
case ID_CUT:
dwStdCmd = OLECMDID_CUT;
break;
case ID_COPY:
dwStdCmd = OLECMDID_COPY;
break;
case ID_NOTE_COPY:
dwStdCmd = OLECMDID_COPY;
break;
case ID_UNDO:
dwStdCmd = OLECMDID_UNDO;
break;
case ID_REDO:
dwStdCmd = OLECMDID_REDO;
break;
case ID_UNLINK:
dwF3Cmd = IDM_UNLINK;
break;
case ID_INSERT_PICTURE:
dwF3Cmd = IDM_IMAGE;
break;
case ID_INSERT_LINE:
dwF3Cmd = IDM_HORIZONTALLINE;
break;
case ID_INDENT_INCREASE:
dwF3Cmd = IDM_INDENT;
break;
case ID_INDENT_DECREASE:
dwF3Cmd = IDM_OUTDENT;
break;
}
}
// Catch all standard group commands and execute them
if (dwStdCmd)
{
ExecCommand(NULL, dwStdCmd);
return S_OK;
}
// Catch all MimeEdit group commands and execute them
else if (dwMECmd)
{
ExecCommand(&CMDSETID_MimeEdit, dwMECmd);
return S_OK;
}
// Catch all Forms3 group commands and execute them
else if (dwF3Cmd)
{
ExecCommand(&CMDSETID_Forms3, dwF3Cmd);
return S_OK;
}
return OLECMDERR_E_NOTSUPPORTED;
}
// ********************************************
HRESULT CMimeEditDocHost::HrPasteToAttachment()
{
return E_NOTIMPL;
}
// ********************************************
HRESULT CMimeEditDocHost::HrGetWindow(HWND *pHwnd)
{
if(pHwnd==NULL)
return E_INVALIDARG;
*pHwnd=m_hwnd;
return NOERROR;
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetSize(LPRECT prc)
{
SetWindowPos(m_hwnd, NULL, prc->left, prc->top, prc->right-prc->left, prc->bottom-prc->top, SWP_NOZORDER);
return NOERROR;
}
// ********************************************
HRESULT CMimeEditDocHost::HrMarkAsRead()
{
// ignore if already read
if(!m_fMarkedRead && !m_fSecDispInfo)
{
if (m_pEventSink)
m_pEventSink->EventOccurred(MEHC_CMD_MARK_AS_READ, NULL);
m_fMarkedRead=TRUE;
}
return NOERROR;
}
// ********************************************
void CMimeEditDocHost::OnWMTimer()
{
// user has been looking at the message for >2 secs,
// mark message as read now.
DOUTL(4, "MAR: Timer:: messages marked as read now");
KillTimer(m_hwnd, idTimerMarkAsRead);
HrMarkAsRead();
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetNoSecUICallback(DWORD dwCookie, PFNNOSECUI pfnNoSecUI)
{
return E_NOTIMPL;
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetDragSource(BOOL fIsSource)
{
return E_NOTIMPL;
}
// ********************************************
HRESULT CMimeEditDocHost::HrTranslateAccelerator(LPMSG lpMsg)
{
// this code will attempt to get ctrl-tab working in source-view
// problem is we uideactivate trident and our host doesn't call our
// translateaccel is we're not uiactive. so we have to fudge activation.
// I turned off for beta1
if (lpMsg->message == WM_KEYDOWN &&
(lpMsg->wParam == VK_TAB) &&
(GetKeyState(VK_CONTROL)&0x8000))
{
// if showing the TAB's then control-tab should cycle them
CycleSrcTabs(!(GetKeyState(VK_SHIFT)&0x8000));
return S_OK;
}
if (!m_fUIActive || !m_pInPlaceActiveObj)
return S_FALSE;
return m_pInPlaceActiveObj->TranslateAccelerator(lpMsg);
}
// ********************************************
HRESULT CMimeEditDocHost::HrUIActivate(BOOL fActivate)
{
HRESULT hr=NOERROR;
if (m_pDocView)
hr = m_pDocView->UIActivate(fActivate);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetUIActivate()
{
SetFocus(m_hwndDocObj);
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::HrFrameActivate(BOOL fActivate)
{
IOleInPlaceActiveObject *pIPAO;
// we QI mimeedit to make sure we always pass it the frame activates so it can disable sound playing
// we can't use m_pInPlaceObject as it's only sent when we're UIActive.
if (m_lpOleObj &&
m_lpOleObj->QueryInterface(IID_IOleInPlaceActiveObject, (LPVOID *)&pIPAO)==S_OK)
{
pIPAO->OnFrameWindowActivate(fActivate);
pIPAO->Release();
}
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::HrHasFocus()
{
return m_fUIActive ? S_OK : S_FALSE;
}
// ********************************************
void CMimeEditDocHost::EnableStandardCmd(UINT idm, LPBOOL pbEnable)
{
OLECMD cmdEdit;
Assert(pbEnable);
cmdEdit.cmdf=0;
switch(idm)
{
case ID_CUT:
cmdEdit.cmdID = OLECMDID_CUT;
break;
case ID_NOTE_COPY:
case ID_COPY:
cmdEdit.cmdID = OLECMDID_COPY;
break;
case ID_PASTE:
cmdEdit.cmdID = OLECMDID_PASTE;
break;
case ID_SELECT_ALL:
cmdEdit.cmdID = OLECMDID_SELECTALL;
break;
case ID_UNDO:
cmdEdit.cmdID = OLECMDID_UNDO;
break;
default:
// Should never get here.
Assert(FALSE);
}
if (m_pCmdTarget && SUCCEEDED(m_pCmdTarget->QueryStatus(NULL, 1, &cmdEdit, NULL)))
*pbEnable = (cmdEdit.cmdf & OLECMDF_ENABLED);
}
// ********************************************
// HrRegisterNotify:
//
// Purpose:
// Generic version of HrRegisterLoadNotify. This allows
// a client (like CSecMsgService) to give enough information
// to become an event sink
// Takes:
// fRegister - TRUE if we're calling Advise
// szElement - [OPTIONAL] if given, we'll get that IHTMLElement
// and use it for the IConnectionPointContainer
// riidSink - IID for the connection point to find
// pUnkSink - IUnknown of our sink object
// pdwCookie - [OUT] cookie needed for Unadvise
// Returns:
// Trident HRs.
//
HRESULT CMimeEditDocHost::HrRegisterNotify(
BOOL fRegister,
LPCTSTR szElement,
REFIID riidSink,
IUnknown *pUnkSink,
DWORD *pdwCookie)
{
IConnectionPointContainer *pCPContainer=0;
IConnectionPoint *pCP=0;
IHTMLElement *pElem=0;
HRESULT hr;
if (!m_pDoc || !pdwCookie)
return E_POINTER;
if (fRegister && !pUnkSink)
return E_POINTER;
if (szElement)
{
hr = HrGetElement(szElement, &pElem);
if (SUCCEEDED(hr))
{
hr = pElem->QueryInterface(IID_IConnectionPointContainer, (LPVOID *)&pCPContainer);
pElem->Release();
}
}
else
{
hr = m_pDoc->QueryInterface(IID_IConnectionPointContainer, (LPVOID *)&pCPContainer);
}
if (FAILED(hr))
goto error;
hr = pCPContainer->FindConnectionPoint(riidSink, &pCP);
pCPContainer->Release();
if (FAILED(hr))
goto error;
if (fRegister)
{
Assert(*pdwCookie == 0);
hr = pCP->Advise(pUnkSink, pdwCookie);
if (FAILED(hr))
goto error;
}
else if (*pdwCookie)
{
hr = pCP->Unadvise(*pdwCookie);
*pdwCookie = NULL;
}
error:
ReleaseObj(pCP);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::RegisterForHTMLDocEvents(BOOL fOn)
{
if (fOn == !!m_fRegisteredForDocEvents)
return S_OK;
m_fRegisteredForDocEvents = !!fOn;
return HrRegisterNotify(fOn, NULL, DIID_HTMLDocumentEvents2,
fOn ? ((IUnknown *)(IDispatch *)this) : NULL,
&m_dwHTMLNotifyCookie);
}
// ********************************************
HRESULT CMimeEditDocHost::PublicFilterDataObject(IDataObject *pDO, IDataObject **ppDORet)
{
IDocHostUIHandler *pDHHand = NULL;
IServiceProvider *pSP = NULL;
HRESULT hr = S_OK;
// RAID 12020. Need to get IDocHostUIHandler of the body obj
hr = m_lpOleObj->QueryInterface(IID_IServiceProvider, (LPVOID*)&pSP);
if (SUCCEEDED(hr))
{
hr = pSP->QueryService(IID_IDocHostUIHandler, IID_IDocHostUIHandler, (LPVOID*)&pDHHand);
if (SUCCEEDED(hr))
{
hr = pDHHand->FilterDataObject(pDO, ppDORet);
pDHHand->Release();
}
pSP->Release();
}
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::HrSaveAttachment()
{
return ExecCommand(&CMDSETID_MimeEdit, MECMDID_SAVEATTACHMENTS);
}
// ********************************************
HRESULT CMimeEditDocHost::HrSetBkGrndPicture(LPTSTR pszPicture)
{
return ExecSetText(&CMDSETID_MimeEdit, MECMDID_BACKGROUNDIMAGE, pszPicture);
}
// ********************************************
HRESULT CMimeEditDocHost::ShowContextMenu(
DWORD dwID,
POINT *ppt,
IUnknown *pcmdtReserved,
IDispatch *pdispReserved)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::GetHostInfo(DOCHOSTUIINFO *pInfo)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::ShowUI(DWORD dwID, IOleInPlaceActiveObject *pActiveObject,
IOleCommandTarget *pCommandTarget, IOleInPlaceFrame *pFrame, IOleInPlaceUIWindow *pDoc)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::HideUI()
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::UpdateUI()
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::EnableModeless(BOOL fActivate)
{
// we don't have to support this, as any disable on a toplevel causes thread
// windows to get disabled anyway
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::OnDocWindowActivate(BOOL fActivate)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::OnFrameWindowActivate(BOOL fActivate)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::ResizeBorder(LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fRameWindow)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::TranslateAccelerator(LPMSG lpMsg, const GUID *pguidCmdGroup, DWORD nCmdID)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::GetOptionKeyPath(LPOLESTR *pchKey, DWORD dw)
{
TCHAR szPath[MAX_PATH];
// dupW uses CoTaskMemAlloc
StrCpyN(szPath, MU_GetRegRoot(), ARRAYSIZE(szPath));
StrCatBuff(szPath, c_szTrident, ARRAYSIZE(szPath));
*pchKey = PszToUnicode(CP_ACP, szPath);
if (szPath && !(*pchKey))
return (TraceResult(E_OUTOFMEMORY));
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::GetDropTarget(IDropTarget *pDropTarget, IDropTarget **ppDropTarget)
{
BOOL fEditModeOn = FALSE;
if (FAILED(HrIsEditMode(&fEditModeOn)) || !fEditModeOn)
return S_FALSE;
*ppDropTarget = (IDropTarget*)SendMessage(GetParent(m_hwnd), NWM_GETDROPTARGET, (WPARAM)pDropTarget, 0);
return NOERROR;
}
// ********************************************
HRESULT CMimeEditDocHost::GetExternal(IDispatch **ppDispatch)
{
return QueryInterface(IID_IDispatch, (LPVOID *)ppDispatch);
}
// ********************************************
HRESULT CMimeEditDocHost::TranslateUrl(DWORD dwTranslate, OLECHAR *pchURLIn, OLECHAR **ppchURLOut)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::FilterDataObject( IDataObject *pDO, IDataObject **ppDORet)
{
return MIMEEDIT_E_DODEFAULT;
}
// ********************************************
HRESULT CMimeEditDocHost::OnChanged(DISPID dispid)
{
if (dispid == DISPID_READYSTATE)
OnReadyStateChanged();
return S_OK;
}
// ********************************************
HRESULT CMimeEditDocHost::OnRequestEdit (DISPID dispid)
{
return S_OK;
}
// ********************************************
void CMimeEditDocHost::OnDocumentReady()
{
NMHDR nmhdr;
// Bug 74697
// Under certain circumstances, Darwin causes Trident to send us IDM_PARSECOMPLETE
// when we don't even have a message. To prevent spurious errors, bail out.
if (!m_pMsg)
return;
if(m_fSecDispInfo)
{
VARIANTARG va;
if(!m_pCmdTarget)
return;
if(m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_STYLE, OLECMDEXECOPT_DODEFAULT, NULL, &va)==S_OK &&
va.lVal == MESTYLE_PREVIEW)
return;
ExecSetBool(&CMDSETID_MimeEdit, MECMDID_TABLINKS, TRUE);
return;
}
nmhdr.hwndFrom = m_hwnd;
nmhdr.idFrom = GetDlgCtrlID(m_hwnd);
nmhdr.code = BDN_DOWNLOADCOMPLETE;
SendMessage(GetParent(m_hwnd), WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
}
// ********************************************
HRESULT CMimeEditDocHost::ExecGetBool(const GUID *guid, DWORD cmd, BOOL *pfValue)
{
VARIANTARG var;
V_VT(&var) = VT_BOOL;
if (!m_pCmdTarget)
return E_FAIL;
HRESULT hr = m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, NULL, &var);
if (SUCCEEDED(hr))
*pfValue = (VARIANT_TRUE == V_BOOL(&var)) ? TRUE : FALSE;
else
*pfValue = FALSE;
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecSetBool(const GUID *guid, DWORD cmd, BOOL fValue)
{
VARIANTARG var;
if (!m_pCmdTarget)
return E_FAIL;
V_VT(&var) = VT_BOOL;
V_BOOL(&var) = fValue ? VARIANT_TRUE : VARIANT_FALSE;
return m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, &var, NULL);
}
// ********************************************
HRESULT CMimeEditDocHost::ExecGetI4(const GUID *guid, DWORD cmd, DWORD *pdwValue)
{
VARIANTARG var;
HRESULT hr;
V_VT(&var) = VT_I4;
hr = m_pCmdTarget ? m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, NULL, &var) : E_FAIL;
*pdwValue = (SUCCEEDED(hr) ? V_I4(&var) : 0);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecSetI4(const GUID *guid, DWORD cmd, DWORD dwValue)
{
VARIANTARG var;
V_VT(&var) = VT_I4;
V_I4(&var) = dwValue;
return m_pCmdTarget ? m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, &var, NULL) : E_FAIL;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecGetI8(const GUID *guid, DWORD cmd, ULONGLONG *pullValue)
{
VARIANTARG var;
HRESULT hr;
V_VT(&var) = VT_I8;
hr = m_pCmdTarget ? m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, NULL, &var) : E_FAIL;
*pullValue = (SUCCEEDED(hr) ? V_UNION(&var, ullVal) : 0);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecSetI8(const GUID *guid, DWORD cmd, ULONGLONG ullValue)
{
VARIANTARG var;
V_VT(&var) = VT_I8;
V_UNION(&var, ullVal) = ullValue;
return m_pCmdTarget ? m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, &var, NULL) : E_FAIL;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecSetText(const GUID *guid, DWORD cmd, LPSTR psz)
{
BSTR bstr = NULL;
VARIANTARG var;
HRESULT hr = S_OK;
if (!m_pCmdTarget)
IF_FAILEXIT(hr = E_FAIL);
IF_FAILEXIT(hr = HrLPSZToBSTR(psz, &bstr));
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = bstr;
IF_FAILEXIT(hr = m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, &var, NULL));
exit:
SysFreeString(bstr);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecSetTextW(const GUID *guid, DWORD cmd, LPWSTR pwsz)
{
BSTR bstr = NULL;
VARIANTARG var;
HRESULT hr = S_OK;
if (!m_pCmdTarget)
IF_FAILEXIT(hr = E_FAIL);
IF_NULLEXIT(bstr = SysAllocString(pwsz));
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = bstr;
IF_FAILEXIT(hr = m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, &var, NULL));
exit:
SysFreeString(bstr);
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecGetText(const GUID *guid, DWORD cmd, LPSTR *ppsz)
{
VARIANTARG var;
HRESULT hr = S_OK;
if (!m_pCmdTarget)
IF_FAILEXIT(hr = E_FAIL);
*ppsz = NULL;
IF_FAILEXIT(hr = m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, NULL, &var));
Assert(V_VT(&var) == VT_BSTR);
hr = HrBSTRToLPSZ(CP_ACP, V_BSTR(&var), ppsz);
SysFreeString(V_BSTR(&var));
IF_FAILEXIT(hr);
exit:
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecGetTextW(const GUID *guid, DWORD cmd, LPWSTR *ppwsz)
{
VARIANTARG var;
HRESULT hr = S_OK;
V_VT(&var) = VT_EMPTY;
if (!m_pCmdTarget)
IF_FAILEXIT(hr = E_FAIL);
*ppwsz = NULL;
IF_FAILEXIT(hr = m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, NULL, &var));
Assert(V_VT(&var) == VT_BSTR);
IF_NULLEXIT(*ppwsz = PszDupW(V_BSTR(&var)));
exit:
if (VT_EMPTY != V_VT(&var))
SysFreeString(V_BSTR(&var));
return hr;
}
// ********************************************
HRESULT CMimeEditDocHost::ExecCommand(const GUID *guid, DWORD cmd)
{
if (!m_pCmdTarget)
return E_FAIL;
return m_pCmdTarget->Exec(guid, cmd, OLECMDEXECOPT_DODEFAULT, NULL, NULL);
}
// ********************************************
void CMimeEditDocHost::OnReadyStateChanged()
{
// MimeEdit keeps track of state for us. Left
// this in in case there is a need to have it
// in the future.
}
HRESULT CMimeEditDocHost::HrHandsOffStorage()
{
if (m_pMsg)
m_pMsg->HandsOffStorage();
if (m_pSecureMessage)
m_pSecureMessage->HandsOffStorage();
if (m_pSecurityErrorScreen)
m_pSecurityErrorScreen->HandsOffStorage();
return S_OK;
}
HRESULT CMimeEditDocHost::HrRefresh()
{
if (m_pCmdTarget)
ExecCommand(NULL, OLECMDID_REFRESH);
return S_OK;
}
HRESULT CMimeEditDocHost::HrBackgroundSound()
{
return ExecCommand(&CMDSETID_MimeEdit, MECMDID_INSERTBGSOUND);
}
HRESULT CMimeEditDocHost::QuerySingleMimeEditCmd(ULONG uCmd, ULONG *pcmdf)
{
OLECMD cmd={uCmd, 0};
if (m_pCmdTarget && S_OK==m_pCmdTarget->QueryStatus(&CMDSETID_MimeEdit, 1, &cmd, NULL))
{
*pcmdf = cmd.cmdf;
return S_OK;
}
return E_FAIL;
}
HRESULT CMimeEditDocHost::QuerySingleFormsCmd(ULONG uCmd, ULONG *pcmdf)
{
OLECMD cmd={uCmd, 0};
if (m_pCmdTarget && S_OK==m_pCmdTarget->QueryStatus(&CMDSETID_Forms3, 1, &cmd, NULL))
{
*pcmdf = cmd.cmdf;
return S_OK;
}
return E_FAIL;
}
HRESULT CMimeEditDocHost::QuerySingleStdCmd(ULONG uCmd, ULONG *pcmdf)
{
OLECMD cmd={uCmd, 0};
if (m_pCmdTarget && S_OK==m_pCmdTarget->QueryStatus(NULL, 1, &cmd, NULL))
{
*pcmdf = cmd.cmdf;
return S_OK;
}
return E_FAIL;
}
/////////////////////////////////////////////////////////////////////////////
//
// IDispatch
//
/////////////////////////////////////////////////////////////////////////////
// This is a really lightweight IDispatch implementation. We only expect
// to get invoked. Trident will call IDispatch::Invoke with the dispID
// of the event that happened or property that changed.
STDMETHODIMP CMimeEditDocHost::GetIDsOfNames(
REFIID riid,
OLECHAR ** rgszNames,
UINT cNames,
LCID lcid,
DISPID * rgDispId)
{
if (cNames==1 && StrCmpIW(rgszNames[0], L"hotmail")==0)
{
rgDispId[0] = 666;
return S_OK;
}
return E_NOTIMPL;
}
STDMETHODIMP CMimeEditDocHost::GetTypeInfo(
UINT /*iTInfo*/,
LCID /*lcid*/,
ITypeInfo **ppTInfo)
{
if (ppTInfo)
*ppTInfo=NULL;
return E_NOTIMPL;
}
STDMETHODIMP CMimeEditDocHost::GetTypeInfoCount(UINT *pctinfo)
{
if (pctinfo)
{
*pctinfo=0;
return NOERROR;
}
else
return E_POINTER;
}
STDMETHODIMP CMimeEditDocHost::Invoke(
DISPID dispIdMember,
REFIID /*riid*/,
LCID /*lcid*/,
WORD wFlags,
DISPPARAMS FAR* /*pDispParams*/,
VARIANT * pVarResult,
EXCEPINFO * /*pExcepInfo*/,
UINT * /*puArgErr*/)
{
IHTMLWindow2 *pWindow=0;
IHTMLEventObj *pEvent=0;
IHTMLElement *pElem=0;
BSTR bstr=0;
HRESULT hr=E_NOTIMPL;
if (dispIdMember == 666 &&
wFlags & DISPATCH_PROPERTYGET)
{
// hotmail on/off for welcome message
pVarResult->vt = VT_BOOL;
pVarResult->boolVal = HideHotmail() ? VARIANT_FALSE : VARIANT_TRUE;
return S_OK;
}
// Currently we only care about the button clicks.
if (dispIdMember == DISPID_HTMLDOCUMENTEVENTS_ONCLICK &&
(wFlags & DISPATCH_METHOD))
{
// Order of events:
// document gives us window gives us event object
// the event object can tell us which button was clicked
// event gives us source element gives us ID
// a couple lstrcmps will tell us which one got hit
if (!m_pDoc)
return E_UNEXPECTED;
m_pDoc->get_parentWindow(&pWindow);
if (pWindow)
{
pWindow->get_event(&pEvent);
if (pEvent)
{
pEvent->get_srcElement(&pElem);
if (pElem)
{
pElem->get_id(&bstr);
if (bstr)
{
hr = HandleButtonClicks(bstr);
SysFreeString(bstr);
}
pElem->Release();
}
pEvent->Release();
}
pWindow->Release();
}
}
return hr;
}
HRESULT CMimeEditDocHost::SetEventSink(IMimeEditEventSink *pEventSink)
{
ReplaceInterface(m_pEventSink, pEventSink);
return S_OK;
}
typedef struct tagCOMMANDSTRUCT {
WCHAR *string;
DWORD id;
} COMMANDSTRUCT, *LPCOMMANDSTRUCT;
COMMANDSTRUCT rgszCmdStrings[] =
{
{L"btnOpen", MEHC_BTN_OPEN},
{L"btnCert", MEHC_BTN_CERT},
{L"btnTrust", MEHC_BTN_TRUST},
{L"btnContinue", MEHC_BTN_CONTINUE},
{L"cmdConnect", MEHC_CMD_CONNECT},
{L"cmdDownload", MEHC_CMD_DOWNLOAD},
};
HRESULT CMimeEditDocHost::HandleButtonClicks(BSTR bstr)
{
HRESULT hr = S_OK;
LPCOMMANDSTRUCT prg = rgszCmdStrings;
DWORD cmdID=0;
BOOL fFound = FALSE;
Assert(bstr);
for (int i = 0; i < ARRAYSIZE(rgszCmdStrings); i++, prg++)
{
if (!StrCmpW(prg->string, bstr))
{
cmdID = prg->id;
fFound = TRUE;
break;
}
}
if (fFound)
{
// The notification needs to happen after the preview pane
// updates. Since there's no notifications here that actually
// return anything but S_FALSE I think this is pretty safe.
// -- From "The famous last words of Steve Serdy"
switch (cmdID)
{
case MEHC_BTN_OPEN:
hr = DoHtmlBtnOpen();
// Now we need update toolbar
m_pEventSink->EventOccurred(cmdID, NULL);
break;
case MEHC_BTN_CERT:
case MEHC_BTN_TRUST:
hr = DoHtmlBtnCertTrust(cmdID);
break;
case MEHC_BTN_CONTINUE:
hr = DoHtmlBtnContinue();
break;
default:
hr = E_NOTIMPL;
}
if (m_pEventSink && (cmdID != MEHC_BTN_OPEN))
hr = m_pEventSink->EventOccurred(cmdID, NULL);
}
return hr;
}
HRESULT CMimeEditDocHost::DoHtmlBtnOpen(void)
{
IHTMLElement * pElem = NULL;
HRESULT hr;
m_fSecDispInfo = FALSE;
// this process is non-critical; don't save errors
HrGetElementImpl(m_pDoc, c_szHTMLIDchkShowAgain, &pElem);
if (pElem)
{
VARIANT_BOOL boolVal;
HrGetSetCheck(FALSE, pElem, &boolVal);
SafeRelease(pElem);
if (VARIANT_TRUE == boolVal)
{
NMHDR nmhdr;
nmhdr.hwndFrom=m_hwnd;
nmhdr.idFrom=GetDlgCtrlID(m_hwnd);
nmhdr.code=BDN_MARKASSECURE;
SendMessage(GetParent(m_hwnd), WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
}
}
AssertSz(m_pSecureMessage, "Secure message should be set at this point");
hr = InternalLoad(m_pSecureMessage);
SafeRelease(m_pSecureMessage);
return hr;
}
HRESULT CMimeEditDocHost::DoHtmlBtnCertTrust(DWORD cmdID)
{
IMimeBody *pRoot = NULL;
HRESULT hr = S_OK;
HBODY hBody = NULL;
SECSTATE SecState ={0};
if(FAILED(HrGetSecurityState(m_pSecureMessage, &SecState, &hBody)))
return(hr);
CleanupSECSTATE(&SecState);
AssertSz(m_pSecureMessage, "Should have a secure message if getting Cert or Trust");
hr = m_pSecureMessage->BindToObject(hBody ? hBody : HBODY_ROOT, IID_IMimeBody, (void**)&pRoot);
if (pRoot)
{
PROPVARIANT var;
HCERTSTORE hcStore = NULL;
#ifdef _WIN64
if (SUCCEEDED(pRoot->GetOption(OID_SECURITY_HCERTSTORE_64, &var)) && (var.vt == VT_UI8))
hcStore = (HCERTSTORE)(var.pulVal);
hr = pRoot->GetOption(OID_SECURITY_CERT_SIGNING_64, &var);
if (SUCCEEDED(hr))
{
if ((PCCERT_CONTEXT)(var.pulVal))
{
if (MEHC_BTN_CERT == cmdID)
// View digital Cert was clicked
hr = ViewCertificate((PCCERT_CONTEXT)(var.pulVal), hcStore);
else
// Edit Trust was clicked
hr = EditTrust((PCCERT_CONTEXT)(var.pulVal), hcStore);
CertFreeCertificateContext((PCCERT_CONTEXT)(var.pulVal));
}
}
#else // !_WIN64
if (SUCCEEDED(pRoot->GetOption(OID_SECURITY_HCERTSTORE, &var)) && (var.vt == VT_UI4))
hcStore = (HCERTSTORE)var.ulVal;
hr = pRoot->GetOption(OID_SECURITY_CERT_SIGNING, &var);
if (SUCCEEDED(hr))
{
if ((PCCERT_CONTEXT)var.ulVal)
{
if (MEHC_BTN_CERT == cmdID)
// View digital Cert was clicked
hr = ViewCertificate((PCCERT_CONTEXT)var.ulVal, hcStore);
else
// Edit Trust was clicked
hr = EditTrust((PCCERT_CONTEXT)var.ulVal, hcStore);
CertFreeCertificateContext((PCCERT_CONTEXT )var.ulVal);
}
}
#endif // _WIN64
SafeRelease(pRoot);
if (hcStore)
CertCloseStore(hcStore, 0);
}
return hr;
}
HRESULT CMimeEditDocHost::HrScrollPage()
{
IHTMLWindow2 *pWindow=0;
IHTMLBodyElement *pBody;
IHTMLElement2 *pElem;
LONG cyClientHeight=0,
cyScrollTop=0,
cyScrollHeight=0;
HRESULT hr = E_FAIL;
if (m_pDoc)
m_pDoc->get_parentWindow(&pWindow);
if (pWindow)
{
if (HrGetBodyElement(m_pDoc, &pBody)==S_OK)
{
if (pBody->QueryInterface(IID_IHTMLElement2, (LPVOID *)&pElem)==S_OK)
{
pElem->get_clientHeight(&cyClientHeight);
pElem->get_scrollTop(&cyScrollTop);
pElem->get_scrollHeight(&cyScrollHeight);
if (!(cyScrollTop + cyClientHeight >= cyScrollHeight))
{
pWindow->scrollBy(0, cyClientHeight);
hr = S_OK;
}
pElem->Release();
}
pBody->Release();
}
pWindow->Release();
}
return hr;
}
HRESULT CMimeEditDocHost::DoHtmlBtnContinue(void)
{
HRESULT hr;
IHTMLElement *pElem = NULL;
// this process is non-critical; don't save errors
HrGetElementImpl(m_pDoc, c_szHTMLIDchkShowAgain, &pElem);
if (pElem)
{
VARIANT_BOOL boolVal;
HrGetSetCheck(FALSE, pElem, &boolVal);
if (VARIANT_TRUE == boolVal)
{
if (m_fIsSigned)
SetDontShowAgain(1, c_szDSDigSigHelp);
if (m_fIsEncrypted)
SetDontShowAgain(1, c_szDSEncryptHelp);
}
pElem->Release();
}
if (m_pSecurityErrorScreen)
{
m_fSecDispInfo = TRUE;
hr = InternalLoad(m_pSecurityErrorScreen);
SafeRelease(m_pSecurityErrorScreen);
}
else
{
m_fSecDispInfo = FALSE;
AssertSz(m_pSecureMessage, "Secure message should be set at this point.");
hr = InternalLoad(m_pSecureMessage);
RegisterForHTMLDocEvents(FALSE);
SafeRelease(m_pSecureMessage);
}
return hr;
}
HRESULT CopySecurePropsToMessage(IMimeMessage *pDestMsg, IMimePropertySet *pPropSet)
{
IMimePropertySet *pNewProps = NULL;
HRESULT hr;
hr = pDestMsg->BindToObject(HBODY_ROOT, IID_IMimePropertySet, (LPVOID *)&pNewProps);
if (SUCCEEDED(hr))
{
hr = pPropSet->CopyProps(0, NULL, pNewProps);
pNewProps->Release();
}
return hr;
}
LPCSTR rgszHdrKeep[] = {
PIDTOSTR(PID_HDR_NEWSGROUP),
PIDTOSTR(PID_HDR_NEWSGROUPS),
PIDTOSTR(PID_HDR_SUBJECT),
PIDTOSTR(PID_HDR_FROM),
PIDTOSTR(PID_HDR_APPARTO),
PIDTOSTR(PID_HDR_DATE),
PIDTOSTR(PID_HDR_REPLYTO),
PIDTOSTR(PID_HDR_TO),
PIDTOSTR(PID_HDR_CC),
PIDTOSTR(PID_HDR_APPROVED),
PIDTOSTR(PID_HDR_DISTRIB),
PIDTOSTR(PID_HDR_KEYWORDS),
PIDTOSTR(PID_HDR_ORG),
PIDTOSTR(PID_HDR_XMSPRI),
PIDTOSTR(PID_HDR_XPRI),
PIDTOSTR(PID_HDR_COMMENT),
PIDTOSTR(PID_HDR_SENDER)};
HRESULT CMimeEditDocHost::LoadSecurely(IMimeMessage *pMsg, SECSTATE *pSecState)
{
HRESULT hr=S_OK;
BOOL fNeedIntroScreen = FALSE,
fNeedErrorScreen = FALSE,
fRegisterDispatch = FALSE;
LPCTSTR szIntroResName=NULL;
IMimeMessage *pSecurityIntroScreen = NULL;
DWORD dwFlags = 0;
// Since we are reloading, go ahead and free the original secure message if there is one.
SafeRelease(m_pSecureMessage);
SafeRelease(m_pSecurityErrorScreen);
// N2 delete schema
if (g_dwSecurityCheckedSchemaProp)
{
PROPVARIANT var;
var.vt = VT_UI4;
if (SUCCEEDED(pMsg->GetBodyProp(HBODY_ROOT, PIDTOSTR(g_dwSecurityCheckedSchemaProp), 0, &var)))
{
if (1 == var.lVal)
goto LoadMessage;
}
}
m_pBodyOptions->GetFlags(&dwFlags);
if(!m_fSecureReceipt)
{
if (0 == (dwFlags & BOPT_SECURITYUIENABLED))
goto LoadMessage;
if (m_fIsSigned)
{
// don't need warning UI if the cert is trusted and the message is okay
fNeedErrorScreen = (!m_fSignTrusted && !(dwFlags & BOPT_REPLYORFORWARD));
// If sig is valid, we should update any certs and SMIMECapabilities in the address book.
if (m_fSignTrusted && (DwGetOption(OPT_AUTO_ADD_SENDERS_CERT_TO_WAB)))
{
FILETIME ftNull = {0};
HrAddSenderCertToWab(NULL, pMsg, NULL, NULL, NULL, ftNull, WFF_CREATE);
}
// check for help UI
szIntroResName = c_szDigSigHelpHTML;
fNeedIntroScreen = ((0 == DwGetDontShowAgain(c_szDSDigSigHelp)) && !(dwFlags & BOPT_REPLYORFORWARD));
}
if (m_fIsEncrypted)
{
fNeedErrorScreen |= (!m_fEncryptionOK && !(dwFlags & BOPT_REPLYORFORWARD));
// If want signed intro, don't need to test this one.
if (!fNeedIntroScreen)
fNeedIntroScreen = ((0 == DwGetDontShowAgain(c_szDSEncryptHelp)) && !(dwFlags & BOPT_REPLYORFORWARD));
szIntroResName = (m_fIsSigned ? c_szSAndEHelpHTML : c_szEncryptHelpHTML);
}
// Bug 2557 - prevent error screen when secure reciept request
if(pSecState->type & MST_RECEIPT_REQUEST)
fNeedIntroScreen = FALSE;
if (fNeedIntroScreen && szIntroResName)
{
// Since this is only for the opening screen, if things error, allow
// the user to continue. In order to allow this, will use a temporary hr.
HRESULT tempHR;
IStream *pStm = NULL;
tempHR = LoadResourceToHTMLStream(szIntroResName, &pStm);
if (SUCCEEDED(tempHR))
tempHR = HrCreateMessage(&pSecurityIntroScreen);
if (SUCCEEDED(tempHR))
tempHR = pSecurityIntroScreen->Load(pStm);
ReleaseObj(pStm);
// If there was an error, don't show the screen and NULL the var
if (FAILED(tempHR))
SafeRelease(pSecurityIntroScreen);
}
if (fNeedErrorScreen)
{
// If have problems here, must exit. Can't show message before showing
// this error screen.
IStream *pStm = NULL;
// Disable check box if message not from the store.
hr = HrOutputSecurityScript(&pStm, pSecState, (0 == (BOPT_FROMSTORE & dwFlags)));
if (SUCCEEDED(hr))
hr = HrCreateMessage(&m_pSecurityErrorScreen);
if (SUCCEEDED(hr))
hr = m_pSecurityErrorScreen->Load(pStm);
ReleaseObj(pStm);
if (FAILED(hr))
SafeRelease(m_pSecurityErrorScreen);
}
}
else
{
IImnAccount * pAcct = NULL;
TCHAR *pszSubject = NULL;
TCHAR *pszFrom = NULL;
FILETIME ftSigningTime;
FILETIME ftSentTime;
IStream *pStm = NULL;
SECSTATE secStateRec = {0};
// DWORD dw = 0;
// Get account for receipt
if(m_pBodyOptions->GetAccount(&pAcct) == S_OK)
{
// Find original meassage and get information from receipt and orig msg
hr = HandleSecReceipt(pMsg, pAcct, m_hwnd, &pszSubject, &pszFrom, &ftSentTime, &ftSigningTime);
}
else
hr = MIME_E_SECURITY_RECEIPT_CANTFINDSENTITEM;
HrGetSecurityState(pMsg, &secStateRec, NULL);
m_fSignTrusted = !!IsSignTrusted(&secStateRec);
if(hr == S_OK)
hr = HrOutputSecureReceipt(&pStm, pszSubject, pszFrom, &ftSentTime, &ftSigningTime, &secStateRec);
else if(hr == MIME_S_RECEIPT_FROMMYSELF)
hr = HrOutputUserSecureReceipt(&pStm, pMsg);
else
hr = HrOutputErrSecReceipt(&pStm, hr, &secStateRec);
// Display receipt
if (SUCCEEDED(hr))
{
SafeRelease(m_pSecurityErrorScreen);
hr = HrCreateMessage(&m_pSecurityErrorScreen);
}
if (SUCCEEDED(hr))
{
#ifdef YST
HBODY hBody = 0;
ReplaceInterface(m_pSecurityErrorScreen, pMsg);
m_pSecurityErrorScreen->SetTextBody(TXT_HTML, IET_CURRENT, NULL, pStm, &hBody);
HrRemoveAttachments(m_pSecurityErrorScreen, FALSE);
#endif // YST
hr = m_pSecurityErrorScreen->Load(pStm);
}
ReleaseObj(pStm);
if (FAILED(hr))
SafeRelease(m_pSecurityErrorScreen);
// If sig is valid, we should update any certs and SMIMECapabilities in the address book.
if (m_fSignTrusted && (DwGetOption(OPT_AUTO_ADD_SENDERS_CERT_TO_WAB)))
{
FILETIME ftNull = {0};
HrAddSenderCertToWab(NULL, pMsg, NULL, NULL, NULL, ftNull, WFF_CREATE);
}
CleanupSECSTATE(&secStateRec);
SafeMemFree(pszSubject);
SafeMemFree(pszFrom);
ReleaseObj(pAcct);
}
// Reset m_pSecureMessage before continue
if(m_pSecureMessage)
SafeRelease(m_pSecureMessage);
// If we didn't get any errors and we have some screens
// to add, copy props from original message into other screens
if (SUCCEEDED(hr) && (m_pSecurityErrorScreen || pSecurityIntroScreen))
{
IMimePropertySet *pPropSet = NULL;
fRegisterDispatch = TRUE;
ReplaceInterface(m_pSecureMessage, pMsg);
// Move over the headers
// If the bind fails, don't worry about it. Just means the headers won't be
// visable until the normal message is loaded.
if (SUCCEEDED(m_pSecureMessage->BindToObject(HBODY_ROOT, IID_IMimePropertySet, (LPVOID *)&pPropSet)))
{
IMimePropertySet *pCopyProps = NULL;
if (SUCCEEDED(pPropSet->Clone(&pCopyProps)))
{
if (SUCCEEDED(pCopyProps->DeleteExcept(ARRAYSIZE(rgszHdrKeep), rgszHdrKeep)))
{
if (pSecurityIntroScreen)
CopySecurePropsToMessage(pSecurityIntroScreen, pCopyProps);
if (SUCCEEDED(hr) && m_pSecurityErrorScreen)
CopySecurePropsToMessage(m_pSecurityErrorScreen, pCopyProps);
}
pCopyProps->Release();
}
pPropSet->Release();
}
// need to init the property
//N8 talk to Opie about this schema thing.
// I didn't understand the property concept when I did this. It
// works fine, but is too big a hammer for the job.
if (SUCCEEDED(hr) && !g_dwSecurityCheckedSchemaProp)
{
IMimePropertySchema *pSchema = NULL;
hr = MimeOleGetPropertySchema(&pSchema);
if (SUCCEEDED(hr))
hr = pSchema->RegisterProperty("Y-SecurityChecked", 0, 0, VT_LPSTR, &g_dwSecurityCheckedSchemaProp);
if (pSchema)
pSchema->Release();
}
}
LoadMessage:
if(m_fSecureReceipt)
{
m_fSecDispInfo = FALSE;
if(m_pSecurityErrorScreen)
hr = InternalLoad(m_pSecurityErrorScreen);
// Free all mems
SafeRelease(m_pSecurityErrorScreen);
}
else if (SUCCEEDED(hr))
{
if (pSecurityIntroScreen)
{
m_fSecDispInfo = TRUE;
hr = InternalLoad(pSecurityIntroScreen);
SafeRelease(pSecurityIntroScreen);
}
else if (m_pSecurityErrorScreen)
{
m_fSecDispInfo = TRUE;
hr = InternalLoad(m_pSecurityErrorScreen);
SafeRelease(m_pSecurityErrorScreen);
}
else if (m_pSecureMessage)
{
m_fSecDispInfo = FALSE;
hr = InternalLoad(m_pSecureMessage);
SafeRelease(m_pSecureMessage);
}
else
{
m_fSecDispInfo = FALSE;
Assert(!m_pSecurityErrorScreen && !pSecurityIntroScreen);
hr = InternalLoad(pMsg);
}
if (fRegisterDispatch)
RegisterForHTMLDocEvents(TRUE);
}
return hr;
}
HRESULT CMimeEditDocHost::CycleSrcTabs(BOOL fFwd)
{
ExecSetI4(&CMDSETID_MimeEdit, MECMDID_SETSOURCETAB, fFwd ? MEST_NEXT : MEST_PREVIOUS);
return S_OK;
}
HRESULT CMimeEditDocHost::HrEnableScrollBars(BOOL fEnable)
{
HRESULT hr = S_OK;
IHTMLBodyElement *pBody = NULL;
BSTR bstrValue = NULL;
if (m_pDoc)
{
IF_FAILEXIT(hr = m_pDoc->get_body((IHTMLElement**)&pBody));
if (fEnable)
{
bstrValue = SysAllocString(L"yes");
}
else
{
bstrValue = SysAllocString(L"no");
}
hr = pBody->put_scroll(bstrValue);
}
exit:
ReleaseObj(pBody);
SysFreeString(bstrValue);
return hr;
}