1229 lines
37 KiB
C++
1229 lines
37 KiB
C++
#include "pch.hxx"
|
|
#include "globals.h"
|
|
#include "resource.h"
|
|
#include "util.h"
|
|
#include "mehost.h"
|
|
#include "demand.h"
|
|
|
|
#define SetMenuItem(_hmenu, _id, _fOn) EnableMenuItem(_hmenu, _id, (_fOn)?MF_ENABLED:MF_DISABLED|MF_GRAYED)
|
|
|
|
extern BOOL
|
|
g_fHTML,
|
|
g_fIncludeMsg,
|
|
g_fQuote,
|
|
g_fSlideShow,
|
|
g_fAutoInline,
|
|
g_fSendImages,
|
|
g_fComposeFont,
|
|
g_fBlockQuote,
|
|
g_fAutoSig,
|
|
g_fSigHtml;
|
|
|
|
extern CHAR g_chQuote;
|
|
extern CHAR g_szComposeFont[MAX_PATH];
|
|
extern CHAR g_szSig[MAX_PATH];
|
|
extern LONG g_lHeaderType;
|
|
|
|
INT_PTR CALLBACK MhtmlDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
HRESULT SetEncodingOptions(IMimeMessage *pMsg, HCHARSET hCharset);
|
|
HRESULT IPersistMimeLoad(IUnknown *pUnk, IMimeMessage *pMsg);
|
|
|
|
CMeHost::CMeHost()
|
|
{
|
|
m_fEditMode=FALSE;
|
|
m_fHTMLMode=TRUE;
|
|
*m_szFileW=0;
|
|
*m_szFmt = 0;
|
|
m_pMsg=NULL;
|
|
m_pIntl=NULL;
|
|
}
|
|
|
|
|
|
CMeHost::~CMeHost()
|
|
{
|
|
SafeRelease(m_pIntl);
|
|
SafeRelease(m_pMsg);
|
|
}
|
|
|
|
|
|
ULONG CMeHost::AddRef()
|
|
{
|
|
return CDocHost::AddRef();
|
|
}
|
|
|
|
ULONG CMeHost::Release()
|
|
{
|
|
return CDocHost::Release();
|
|
}
|
|
|
|
|
|
HRESULT CMeHost::HrInit(HWND hwndMDIClient, IOleInPlaceFrame *pFrame)
|
|
{
|
|
HRESULT hr=E_FAIL;
|
|
IMimeMessage *pMsg=0;
|
|
|
|
if (pFrame==NULL)
|
|
return E_INVALIDARG;
|
|
|
|
hr=CDocHost::HrInit(hwndMDIClient, 99, dhbHost);
|
|
if (FAILED(hr))
|
|
goto error;
|
|
|
|
ReplaceInterface(m_pInPlaceFrame, pFrame);
|
|
|
|
hr=CDocHost::HrCreateDocObj((LPCLSID)&CLSID_MimeEdit);
|
|
if (FAILED(hr))
|
|
goto error;
|
|
|
|
hr=CDocHost::HrShow();
|
|
if (FAILED(hr))
|
|
goto error;
|
|
|
|
// need to init MimeEdit with a blank message
|
|
hr = CoCreateInstance(CLSID_IMimeMessage, NULL, CLSCTX_INPROC_SERVER, IID_IMimeMessage, (LPVOID *)&pMsg);
|
|
if (FAILED(hr))
|
|
goto error;
|
|
|
|
hr = pMsg->InitNew();
|
|
if (FAILED(hr))
|
|
goto error;
|
|
|
|
hr = IPersistMimeLoad(m_lpOleObj, pMsg);
|
|
|
|
// need to init MimeEdit with a blank message
|
|
hr = CoCreateInstance(CLSID_IMimeInternational, NULL, CLSCTX_INPROC_SERVER, IID_IMimeInternational, (LPVOID *)&m_pIntl);
|
|
if (FAILED(hr))
|
|
goto error;
|
|
|
|
error:
|
|
ReleaseObj(pMsg);
|
|
return hr;
|
|
}
|
|
|
|
static char c_szFilter[] = "Rfc 822 Messages (*.eml)\0*.eml\0\0";
|
|
HRESULT CMeHost::HrOpen(HWND hwnd)
|
|
{
|
|
OPENFILENAME ofn;
|
|
TCHAR szFile[MAX_PATH];
|
|
TCHAR szTitle[MAX_PATH];
|
|
TCHAR szDefExt[30];
|
|
|
|
if (!m_lpOleObj)
|
|
return E_FAIL;
|
|
|
|
lstrcpy(szFile, "c:\\*.eml");
|
|
lstrcpy(szDefExt, ".eml");
|
|
lstrcpy(szTitle, "Browse for message...");
|
|
ZeroMemory (&ofn, sizeof (ofn));
|
|
ofn.lStructSize = sizeof (ofn);
|
|
ofn.hwndOwner = hwnd;
|
|
ofn.lpstrFilter = c_szFilter;
|
|
ofn.nFilterIndex = 1;
|
|
ofn.lpstrFile = szFile;
|
|
ofn.nMaxFile = sizeof (szFile);
|
|
ofn.lpstrTitle = szTitle;
|
|
ofn.lpstrDefExt = szDefExt;
|
|
ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
|
|
|
|
// Show OpenFile Dialog
|
|
if (!GetOpenFileName(&ofn))
|
|
return E_OUTOFMEMORY;
|
|
|
|
return HrLoadFile(szFile);
|
|
}
|
|
|
|
|
|
|
|
HRESULT CMeHost::OnCommand(HWND hwnd, int id, WORD wCmd)
|
|
{
|
|
VARIANTARG va;
|
|
ULONG uCmd=0,
|
|
uCmdMimeEdit,
|
|
uPrompt = OLECMDEXECOPT_DODEFAULT;
|
|
VARIANTARG *pvaOut=0,
|
|
*pvaIn=0;
|
|
BSTR bstrFree=0;
|
|
CHAR rgch[MAX_PATH];
|
|
WCHAR rgchW[MAX_PATH];
|
|
|
|
switch (id)
|
|
{
|
|
case idmBackground:
|
|
return BackgroundPicture();
|
|
|
|
case idmTestBackRed:
|
|
return BackRed();
|
|
|
|
case idmTestForeRed:
|
|
return ForeRed();
|
|
|
|
case idmInsertFile:
|
|
uCmdMimeEdit = MECMDID_INSERTTEXTFILE;
|
|
|
|
// if shift it down prompt ourselves to test the other codepath
|
|
if (GetKeyState(VK_SHIFT)&0x8000)
|
|
{
|
|
lstrcpy(rgch, "c:\\foo.txt");
|
|
if (GenericPrompt(hwnd, "Insert File...", "pick a filename", rgch, MAX_PATH)!=S_OK)
|
|
return S_FALSE;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, rgch, -1, rgchW, MAX_PATH);
|
|
bstrFree = SysAllocString(rgchW);
|
|
va.vt = VT_BSTR;
|
|
va.bstrVal = bstrFree;
|
|
pvaIn = &va;
|
|
}
|
|
|
|
break;
|
|
|
|
case idmFont:
|
|
uCmdMimeEdit = MECMDID_FORMATFONT;
|
|
break;
|
|
|
|
case idmSetText:
|
|
uCmdMimeEdit = MECMDID_SETTEXT;
|
|
va.vt = VT_BSTR;
|
|
va.bstrVal = SysAllocString(L"This is a sample text string. <BR> It <b><i>can</b></i> be HTML.");
|
|
bstrFree = va.bstrVal;
|
|
pvaIn = &va;
|
|
break;
|
|
|
|
case idmSaveAsStationery:
|
|
SaveAsStationery();
|
|
break;
|
|
|
|
case idmSaveAsMHTML:
|
|
SaveAsMhtmlTest();
|
|
break;
|
|
|
|
case idmLang:
|
|
DialogBoxParam(g_hInst, MAKEINTRESOURCE(iddLang), m_hwnd, ExtLangDlgProc, (LPARAM)this);
|
|
break;
|
|
|
|
case idmFmtPreview:
|
|
DialogBoxParam(g_hInst, MAKEINTRESOURCE(iddFmt), m_hwnd, ExtFmtDlgProc, (LPARAM)this);
|
|
break;
|
|
|
|
case idmNoHeader:
|
|
uCmdMimeEdit = MECMDID_STYLE;
|
|
va.vt = VT_I4;
|
|
va.lVal = MESTYLE_NOHEADER;
|
|
pvaIn = &va;
|
|
break;
|
|
|
|
case idmPreview:
|
|
uCmdMimeEdit = MECMDID_STYLE;
|
|
va.vt = VT_I4;
|
|
va.lVal = MESTYLE_PREVIEW;
|
|
pvaIn = &va;
|
|
break;
|
|
|
|
case idmMiniHeader:
|
|
uCmdMimeEdit = MECMDID_STYLE;
|
|
va.vt = VT_I4;
|
|
va.lVal = MESTYLE_MINIHEADER;
|
|
pvaIn = &va;
|
|
break;
|
|
|
|
case idmFormatBar:
|
|
uCmdMimeEdit = MECMDID_STYLE;
|
|
va.vt = VT_I4;
|
|
va.lVal = MESTYLE_FORMATBAR;
|
|
pvaIn = &va;
|
|
break;
|
|
|
|
case idmViewSource:
|
|
case idmViewMsgSource:
|
|
uCmdMimeEdit = MECMDID_VIEWSOURCE;
|
|
va.vt = VT_I4;
|
|
va.lVal = (id == idmViewSource ? MECMD_VS_HTML : MECMD_VS_MESSAGE);
|
|
pvaIn = &va;
|
|
break;
|
|
|
|
case idmCut:
|
|
uCmd=OLECMDID_CUT;
|
|
break;
|
|
|
|
case idmCopy:
|
|
uCmd=OLECMDID_COPY;
|
|
break;
|
|
|
|
case idmPaste:
|
|
uCmd=OLECMDID_PASTE;
|
|
break;
|
|
|
|
case idmUndo:
|
|
uCmd=OLECMDID_UNDO;
|
|
break;
|
|
|
|
case idmRedo:
|
|
uCmd=OLECMDID_REDO;
|
|
break;
|
|
|
|
case idmSelectAll:
|
|
uCmd=OLECMDID_SELECTALL;
|
|
break;
|
|
|
|
case idmOpen:
|
|
HrOpen(hwnd);
|
|
return S_OK;
|
|
|
|
case idmHTMLMode:
|
|
m_fHTMLMode = !m_fHTMLMode;
|
|
|
|
va.vt = VT_BOOL;
|
|
va.boolVal = m_fHTMLMode ? VARIANT_TRUE : VARIANT_FALSE;
|
|
pvaIn = &va;
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_EDITHTML, OLECMDEXECOPT_DODEFAULT, &va, NULL);
|
|
|
|
if (!m_fHTMLMode &&
|
|
m_pCmdTarget &&
|
|
MessageBox(m_hwnd, "You are going from HTML to plaintext. Do you want to downgrade the document?", "MeHost", MB_YESNO)==IDYES)
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_DOWNGRADEPLAINTEXT, OLECMDEXECOPT_DODEFAULT, NULL, NULL);
|
|
|
|
return S_OK;
|
|
|
|
case idmEditDocument:
|
|
m_fEditMode = !m_fEditMode;
|
|
uCmdMimeEdit = MECMDID_EDITMODE;
|
|
va.vt = VT_BOOL;
|
|
va.boolVal = m_fEditMode ? VARIANT_TRUE : VARIANT_FALSE;
|
|
pvaIn = &va;
|
|
break;
|
|
|
|
case idmRot13:
|
|
uCmdMimeEdit = MECMDID_ROT13;
|
|
break;
|
|
|
|
case idmFind:
|
|
uCmd = OLECMDID_FIND;
|
|
break;
|
|
|
|
case idmSpelling:
|
|
uCmd = OLECMDID_SPELL;
|
|
break;
|
|
|
|
case idmPrint:
|
|
uCmd = OLECMDID_PRINT;
|
|
break;
|
|
|
|
case idmSaveAs:
|
|
SaveAs();
|
|
return 0;
|
|
}
|
|
|
|
if (m_pCmdTarget)
|
|
{
|
|
if (uCmd)
|
|
m_pCmdTarget->Exec(NULL, uCmd, uPrompt, pvaIn, pvaOut);
|
|
|
|
if (uCmdMimeEdit)
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, uCmdMimeEdit, uPrompt, pvaIn, pvaOut);
|
|
}
|
|
|
|
SysFreeString(bstrFree);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
LRESULT CMeHost::OnInitMenuPopup(HWND hwnd, HMENU hmenuPopup, UINT uPos)
|
|
{
|
|
MENUITEMINFO mii;
|
|
HMENU hmenuMain;
|
|
OLECMD rgMimeEditCmds[]= {{MECMDID_EDITMODE, 0},
|
|
{MECMDID_ROT13, 0},
|
|
{MECMDID_EDITHTML, 0}};
|
|
OLECMD rgStdCmds[]= {{OLECMDID_CUT, 0},
|
|
{OLECMDID_COPY, 0},
|
|
{OLECMDID_PASTE, 0},
|
|
{OLECMDID_SELECTALL, 0},
|
|
{OLECMDID_UNDO, 0},
|
|
{OLECMDID_REDO, 0},
|
|
{OLECMDID_FIND, 0}};
|
|
int rgidsStd[]= {idmCut,
|
|
idmCopy,
|
|
idmPaste,
|
|
idmSelectAll,
|
|
idmUndo,
|
|
idmRedo,
|
|
idmFind};
|
|
int rgidsMimeEdit[]= {idmEditDocument,
|
|
idmRot13,
|
|
idmHTMLMode};
|
|
int i,
|
|
idm;
|
|
VARIANTARG va;
|
|
ULONG u;
|
|
|
|
hmenuMain = GetMenu(hwnd);
|
|
mii.cbSize = sizeof(MENUITEMINFO);
|
|
mii.fMask = MIIM_ID | MIIM_SUBMENU;
|
|
GetMenuItemInfo(hmenuMain, uPos, TRUE, &mii);
|
|
|
|
switch (mii.wID)
|
|
{
|
|
case idmPopupFile:
|
|
EnableMenuItem(hmenuPopup, idmOpen, MF_BYCOMMAND|MF_ENABLED);
|
|
EnableMenuItem(hmenuPopup, idmPrint, MF_BYCOMMAND|MF_ENABLED);
|
|
EnableMenuItem(hmenuPopup, idmSaveAs, MF_BYCOMMAND|MF_ENABLED);
|
|
break;
|
|
|
|
case idmPopupEdit:
|
|
if (m_pCmdTarget)
|
|
{
|
|
if (m_pCmdTarget->QueryStatus(NULL, sizeof(rgStdCmds)/sizeof(OLECMD), rgStdCmds, NULL)==S_OK)
|
|
for(i=0; i<sizeof(rgStdCmds)/sizeof(OLECMD); i++)
|
|
SetMenuItem(hmenuPopup, rgidsStd[i], rgStdCmds[i].cmdf & OLECMDF_ENABLED);
|
|
|
|
if (m_pCmdTarget->QueryStatus(&CMDSETID_MimeEdit, sizeof(rgMimeEditCmds)/sizeof(OLECMD), rgMimeEditCmds, NULL)==S_OK)
|
|
for(i=0; i<sizeof(rgMimeEditCmds)/sizeof(OLECMD); i++)
|
|
{
|
|
SetMenuItem(hmenuPopup, rgidsMimeEdit[i], rgMimeEditCmds[i].cmdf & OLECMDF_ENABLED);
|
|
CheckMenuItem(hmenuPopup, rgidsMimeEdit[i], MF_BYCOMMAND|(rgMimeEditCmds[i].cmdf & OLECMDF_LATCHED ? MF_CHECKED: MF_UNCHECKED));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case idmPopupView:
|
|
u = MESTYLE_NOHEADER;
|
|
if (m_pCmdTarget &&
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_STYLE, OLECMDEXECOPT_DODEFAULT, NULL, &va)==S_OK)
|
|
u = va.lVal;
|
|
|
|
switch(u)
|
|
{
|
|
case MESTYLE_NOHEADER:
|
|
idm = idmNoHeader;
|
|
break;
|
|
case MESTYLE_MINIHEADER:
|
|
idm = idmMiniHeader;
|
|
break;
|
|
case MESTYLE_PREVIEW:
|
|
idm = idmPreview;
|
|
break;
|
|
case MESTYLE_FORMATBAR:
|
|
idm = idmFormatBar;
|
|
break;
|
|
}
|
|
CheckMenuRadioItem(hmenuPopup, idmNoHeader, idmFormatBar, idm, MF_BYCOMMAND|MF_ENABLED);
|
|
SetMenuItem(hmenuPopup, idmNoHeader, TRUE);
|
|
SetMenuItem(hmenuPopup, idmMiniHeader, TRUE);
|
|
SetMenuItem(hmenuPopup, idmPreview, TRUE);
|
|
SetMenuItem(hmenuPopup, idmFormatBar, TRUE);
|
|
break;
|
|
|
|
case idmPopupTools:
|
|
{
|
|
OLECMD CmdSpell = {OLECMDID_SPELL, 0};
|
|
|
|
SetMenuItem(hmenuPopup, idmFmtPreview, TRUE);
|
|
if (m_pCmdTarget)
|
|
m_pCmdTarget->QueryStatus(NULL, 1, &CmdSpell, NULL);
|
|
|
|
SetMenuItem(hmenuPopup, idmSpelling, CmdSpell.cmdf & OLECMDF_ENABLED);
|
|
}
|
|
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
HRESULT CMeHost::QueryStatus(const GUID *pguidCmdGroup, ULONG cCmds, OLECMD rgCmds[], OLECMDTEXT *pCmdText)
|
|
{
|
|
ULONG uCmd;
|
|
HRESULT hr;
|
|
|
|
if (pguidCmdGroup &&
|
|
IsEqualGUID(*pguidCmdGroup, CMDSETID_MimeEditHost))
|
|
{
|
|
for (uCmd=0; uCmd < cCmds; uCmd++)
|
|
rgCmds[uCmd].cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
|
|
return S_OK;
|
|
}
|
|
|
|
hr = CDocHost::QueryStatus(pguidCmdGroup, cCmds, rgCmds, pCmdText);
|
|
|
|
if (pguidCmdGroup==NULL)
|
|
{
|
|
for (uCmd=0; uCmd < cCmds; uCmd++)
|
|
{
|
|
switch(rgCmds[uCmd].cmdID)
|
|
{
|
|
case OLECMDID_PROPERTIES:
|
|
rgCmds[uCmd].cmdf = OLECMDF_SUPPORTED|OLECMDF_ENABLED;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT CMeHost::Exec(const GUID *pguidCmdGroup, DWORD nCmdID, DWORD nCmdExecOpt, VARIANTARG *pvaIn, VARIANTARG *pvaOut)
|
|
{
|
|
CHAR rgch[MAX_PATH];
|
|
WCHAR rgchW[MAX_PATH];
|
|
|
|
if (pguidCmdGroup &&
|
|
IsEqualGUID(*pguidCmdGroup, CMDSETID_MimeEditHost))
|
|
{
|
|
switch (nCmdID)
|
|
{
|
|
case MEHOSTCMDID_BORDERFLAGS:
|
|
if (pvaOut)
|
|
{
|
|
pvaOut->vt = VT_I4;
|
|
pvaOut->lVal = MEBF_OUTERCLIENTEDGE|MEBF_FORMATBARSEP;
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_SIGNATURE:
|
|
if (pvaOut)
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0, g_szSig, -1, rgchW, MAX_PATH);
|
|
|
|
pvaOut->vt = VT_BSTR;
|
|
pvaOut->bstrVal = SysAllocString(rgchW);
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_SIGNATURE_OPTIONS:
|
|
if (pvaOut)
|
|
{
|
|
pvaOut->vt = VT_I4;
|
|
pvaOut->lVal = MESIGOPT_TOP|(g_fSigHtml?MESIGOPT_HTML:MESIGOPT_PLAIN);
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_SIGNATURE_ENABLED:
|
|
if (pvaIn)
|
|
{
|
|
if (pvaIn->lVal == MESIG_AUTO && !g_fAutoSig)
|
|
return S_FALSE;
|
|
else
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_REPLY_TICK_COLOR:
|
|
if (pvaOut)
|
|
{
|
|
pvaOut->vt = VT_I4;
|
|
pvaOut->lVal = RGB(255,0,0);
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_HEADER_TYPE:
|
|
if (pvaOut)
|
|
{
|
|
pvaOut->vt = VT_I4;
|
|
pvaOut->lVal = g_lHeaderType;
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_QUOTE_CHAR:
|
|
if (pvaOut)
|
|
{
|
|
pvaOut->vt = VT_I4; // apply quoteing to plain-text stream
|
|
pvaOut->lVal = g_fQuote?g_chQuote:NULL;
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_SLIDESHOW_DELAY:
|
|
if (pvaOut)
|
|
{
|
|
pvaOut->vt = VT_I4;
|
|
pvaOut->lVal = 5;
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_COMPOSE_FONT:
|
|
if (pvaOut && g_fComposeFont)
|
|
{
|
|
MultiByteToWideChar(CP_ACP, 0, g_szComposeFont, -1, rgchW, MAX_PATH);
|
|
|
|
pvaOut->vt = VT_BSTR;
|
|
pvaOut->bstrVal = SysAllocString(rgchW);
|
|
}
|
|
|
|
return g_fComposeFont?S_OK:S_FALSE;
|
|
|
|
case MEHOSTCMDID_FLAGS:
|
|
if (pvaOut)
|
|
{
|
|
pvaOut->vt = VT_I4;
|
|
pvaOut->lVal = 0;
|
|
|
|
if (g_fAutoSig)
|
|
pvaOut->lVal |= MEO_FLAGS_AUTOTEXT;
|
|
|
|
if (g_fHTML && m_fHTMLMode)
|
|
pvaOut->lVal |= MEO_FLAGS_HTML;
|
|
|
|
if (g_fAutoInline)
|
|
pvaOut->lVal |= MEO_FLAGS_AUTOINLINE;
|
|
|
|
if (g_fSlideShow)
|
|
pvaOut->lVal |= MEO_FLAGS_SLIDESHOW;
|
|
|
|
if (g_fIncludeMsg)
|
|
pvaOut->lVal |= MEO_FLAGS_INCLUDEMSG;
|
|
|
|
if (g_fSendImages)
|
|
pvaOut->lVal |= MEO_FLAGS_SENDIMAGES;
|
|
|
|
if (g_fBlockQuote)
|
|
pvaOut->lVal |= MEO_FLAGS_BLOCKQUOTE;
|
|
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
case MEHOSTCMDID_ADD_TO_ADDRESSBOOK:
|
|
case MEHOSTCMDID_ADD_TO_FAVORITES:
|
|
if (pvaIn &&
|
|
pvaIn->vt == VT_BSTR &&
|
|
pvaIn->bstrVal != NULL)
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pvaIn->bstrVal, -1, rgch, MAX_PATH, NULL, NULL);
|
|
MessageBox(m_hwnd, rgch, nCmdID == MEHOSTCMDID_ADD_TO_FAVORITES ?
|
|
"CMeHost - AddToFavorites" :
|
|
"CMeHost - AddToAddressBook", MB_OK);
|
|
return S_OK;
|
|
}
|
|
else
|
|
return E_INVALIDARG;
|
|
|
|
}
|
|
return OLECMDERR_E_NOTSUPPORTED;
|
|
}
|
|
|
|
if (pguidCmdGroup==NULL)
|
|
{
|
|
switch (nCmdID)
|
|
{
|
|
case OLECMDID_PROPERTIES:
|
|
MessageBox(m_hwnd, "This is a place holder for the note properties dialog", "MePad", MB_OK);
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
return CDocHost::Exec(pguidCmdGroup, nCmdID, nCmdExecOpt, pvaIn, pvaOut);
|
|
}
|
|
|
|
|
|
INT_PTR CALLBACK MhtmlDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
DWORD dwFlags;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
CheckDlgButton(hwnd, idcHTML, BST_CHECKED);
|
|
CheckDlgButton(hwnd, idcPlain, BST_CHECKED);
|
|
CheckDlgButton(hwnd, idcImages, BST_CHECKED);
|
|
CheckDlgButton(hwnd, idcFiles, BST_CHECKED);
|
|
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
dwFlags = 0;
|
|
|
|
if (IsDlgButtonChecked(hwnd, idcImages))
|
|
dwFlags |= MECD_ENCODEIMAGES;
|
|
|
|
if (IsDlgButtonChecked(hwnd, idcPlain))
|
|
dwFlags |= MECD_PLAINTEXT;
|
|
|
|
if (IsDlgButtonChecked(hwnd, idcHTML))
|
|
dwFlags |= MECD_HTML;
|
|
|
|
if (IsDlgButtonChecked(hwnd, idcFiles))
|
|
dwFlags |= MECD_ENCODEFILEURLSONLY;
|
|
|
|
EndDialog(hwnd, dwFlags);
|
|
return TRUE;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, -1);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
INT_PTR CALLBACK CMeHost::ExtFmtDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CMeHost *pHost=(CMeHost *)GetWindowLong(hwnd, DWL_USER);
|
|
|
|
if (msg==WM_INITDIALOG)
|
|
{
|
|
pHost = (CMeHost *)lParam;
|
|
SetWindowLong(hwnd, DWL_USER, lParam);
|
|
}
|
|
|
|
return pHost?pHost->FmtDlgProc(hwnd, msg, wParam, lParam):FALSE;
|
|
}
|
|
|
|
|
|
INT_PTR CALLBACK CMeHost::FmtDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
WCHAR rgchW[MAX_PATH];
|
|
VARIANTARG va;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
GetWindowText(GetDlgItem(hwnd, idcEdit), m_szFmt, sizeof(m_szFmt));
|
|
MultiByteToWideChar(CP_ACP, 0, m_szFmt, -1, rgchW, MAX_PATH);
|
|
if (m_pCmdTarget)
|
|
{
|
|
va.vt = VT_BSTR;
|
|
va.bstrVal = (BSTR)rgchW;
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_PREVIEWFORMAT, OLECMDEXECOPT_DODEFAULT, &va, NULL);
|
|
}
|
|
|
|
// fall tro'
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, LOWORD(wParam));
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
SetWindowText(GetDlgItem(hwnd, idcEdit), m_szFmt);
|
|
SetFocus(GetDlgItem(hwnd, idcEdit));
|
|
break;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
UINT uCodePageFromCharset(IMimeInternational *pIntl, HCHARSET hCharset)
|
|
{
|
|
INETCSETINFO CsetInfo;
|
|
UINT uiCodePage = GetACP();
|
|
|
|
if (hCharset &&
|
|
(pIntl->GetCharsetInfo(hCharset, &CsetInfo)==S_OK))
|
|
uiCodePage = CsetInfo.cpiWindows ;
|
|
|
|
return uiCodePage;
|
|
}
|
|
|
|
|
|
INT_PTR CALLBACK CMeHost::ExtLangDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CMeHost *pHost=(CMeHost *)GetWindowLong(hwnd, DWL_USER);
|
|
|
|
if (msg==WM_INITDIALOG)
|
|
{
|
|
pHost = (CMeHost *)lParam;
|
|
SetWindowLong(hwnd, DWL_USER, lParam);
|
|
}
|
|
|
|
return pHost?pHost->LangDlgProc(hwnd, msg, wParam, lParam):FALSE;
|
|
}
|
|
|
|
|
|
INT_PTR CALLBACK CMeHost::LangDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
VARIANTARG va;
|
|
HKEY hk=0,
|
|
hkSub;
|
|
LONG cb;
|
|
DWORD n=0,
|
|
l,
|
|
dwCodePage,
|
|
dwType;
|
|
TCHAR rgch[MAX_PATH];
|
|
HWND hwndCombo = GetDlgItem(hwnd, idcLang);
|
|
HCHARSET hCharset;
|
|
HRESULT hr;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
l = SendMessage(hwndCombo, CB_GETCURSEL, 0 ,0);
|
|
dwCodePage = SendMessage(hwndCombo, CB_GETITEMDATA, l, 0);
|
|
m_pIntl->GetCodePageCharset(dwCodePage, CHARSET_BODY, &hCharset);
|
|
if (m_pCmdTarget)
|
|
{
|
|
va.vt = VT_I4;
|
|
va.lVal = (LONG)hCharset;
|
|
if (FAILED(hr=m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_CHARSET, OLECMDEXECOPT_DODEFAULT, &va, NULL)))
|
|
{
|
|
wsprintf(rgch, "Could not switch language hr=0x%x", hr);
|
|
MessageBox(m_hwnd, rgch, "MePad", MB_OK);
|
|
}
|
|
}
|
|
|
|
// fall tro'
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, LOWORD(wParam));
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
if (RegOpenKey(HKEY_CLASSES_ROOT, "MIME\\Database\\Codepage", &hk)==ERROR_SUCCESS)
|
|
{
|
|
while (RegEnumKey(hk, n++, rgch, MAX_PATH)==ERROR_SUCCESS)
|
|
{
|
|
dwCodePage = atoi(rgch);
|
|
|
|
if (RegOpenKey(hk, rgch, &hkSub)==ERROR_SUCCESS)
|
|
{
|
|
cb = MAX_PATH;
|
|
if (RegQueryValueEx(hkSub, "Description", 0, &dwType, (LPBYTE)rgch, (ULONG *)&cb)==ERROR_SUCCESS)
|
|
{
|
|
l = SendMessage(hwndCombo, CB_ADDSTRING, NULL, (LPARAM)rgch);
|
|
if (l>=0)
|
|
SendMessage(hwndCombo, CB_SETITEMDATA, l, dwCodePage);
|
|
|
|
}
|
|
CloseHandle(hkSub);
|
|
}
|
|
}
|
|
CloseHandle(hk);
|
|
};
|
|
|
|
if (m_pCmdTarget)
|
|
{
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_CHARSET, OLECMDEXECOPT_DODEFAULT, NULL, &va);
|
|
dwCodePage = uCodePageFromCharset(m_pIntl, (HCHARSET)va.lVal);
|
|
}
|
|
else
|
|
dwCodePage = 0;
|
|
|
|
l = SendMessage(hwndCombo, CB_GETCOUNT, NULL, NULL);
|
|
for (n=0; n<l; n++)
|
|
{
|
|
if ((DWORD)SendMessage(hwndCombo, CB_GETITEMDATA, n, NULL)==dwCodePage)
|
|
{
|
|
SendMessage(hwndCombo, CB_SETCURSEL, n, NULL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
SetFocus(hwndCombo);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
LRESULT CMeHost::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
VARIANTARG va;
|
|
int id;
|
|
BOOL fDirty=FALSE;
|
|
IOleDocumentView *pDocView;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_NCACTIVATE:
|
|
if (m_lpOleObj &&
|
|
m_lpOleObj->QueryInterface(IID_IOleDocumentView, (LPVOID *)&pDocView)==S_OK)
|
|
{
|
|
pDocView->UIActivate(LOWORD(wParam));
|
|
pDocView->Release();
|
|
}
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
if (m_pCmdTarget &&
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_DIRTY, 0, 0, &va)==S_OK &&
|
|
va.vt == VT_BOOL)
|
|
fDirty = va.boolVal == VARIANT_TRUE;
|
|
|
|
if (fDirty)
|
|
{
|
|
id = MessageBox(m_hwnd, "This message has been modified. Do you want to save the changes?",
|
|
"MimeEdit Host", MB_YESNOCANCEL);
|
|
if (id==IDCANCEL)
|
|
return 0;
|
|
|
|
if (id==IDYES)
|
|
{
|
|
if (Save()==MIMEEDIT_E_USERCANCEL)
|
|
return 0;
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
return CDocHost::WndProc(hwnd, msg, wParam, lParam);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HRESULT CMeHost::Save()
|
|
{
|
|
if (*m_szFileW==NULL)
|
|
return SaveAs();
|
|
|
|
return SaveToFile(m_szFileW);
|
|
}
|
|
|
|
HRESULT CMeHost::SaveAs()
|
|
{
|
|
OPENFILENAME ofn;
|
|
TCHAR szFile[MAX_PATH];
|
|
TCHAR szTitle[MAX_PATH];
|
|
TCHAR szDefExt[30];
|
|
|
|
if (!m_lpOleObj)
|
|
return E_FAIL;
|
|
|
|
lstrcpy(szFile, "c:\\*.eml");
|
|
lstrcpy(szDefExt, ".eml");
|
|
lstrcpy(szTitle, "Save Message As...");
|
|
ZeroMemory (&ofn, sizeof (ofn));
|
|
ofn.lStructSize = sizeof (ofn);
|
|
ofn.hwndOwner = m_hwnd;
|
|
ofn.lpstrFilter = c_szFilter;
|
|
ofn.nFilterIndex = 1;
|
|
ofn.lpstrFile = szFile;
|
|
ofn.nMaxFile = sizeof (szFile);
|
|
ofn.lpstrTitle = szTitle;
|
|
ofn.lpstrDefExt = szDefExt;
|
|
ofn.Flags = OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT;
|
|
|
|
if (*szFile==NULL)
|
|
return E_FAIL;
|
|
|
|
|
|
// Show OpenFile Dialog
|
|
if (!GetSaveFileName(&ofn))
|
|
return MIMEEDIT_E_USERCANCEL;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, szFile, -1, m_szFileW, MAX_PATH);
|
|
|
|
SetWindowText(m_hwnd, szFile);
|
|
return SaveToFile(m_szFileW);
|
|
}
|
|
|
|
HRESULT CMeHost::SaveAsMhtmlTest()
|
|
{
|
|
IMimeMessage *pMsg;
|
|
IHTMLDocument2 *pDoc;
|
|
IServiceProvider *pSP;
|
|
DWORD dwFlags;
|
|
|
|
if (m_lpOleObj->QueryInterface(IID_IServiceProvider, (LPVOID *)&pSP)==S_OK)
|
|
{
|
|
if (pSP->QueryService(IID_IHTMLDocument2, IID_IHTMLDocument2, (LPVOID *)&pDoc)==S_OK)
|
|
{
|
|
dwFlags = DialogBox(g_hInst, MAKEINTRESOURCE(iddSaveAsMHTML), m_hwnd, MhtmlDlgProc);
|
|
if (dwFlags != -1)
|
|
{
|
|
if (!FAILED(MimeEditCreateMimeDocument(pDoc, m_pMsg, dwFlags, &pMsg)))
|
|
{
|
|
SetEncodingOptions(pMsg, GetCharset());
|
|
pMsg->Commit(0);
|
|
MimeEditViewSource(m_hwnd, pMsg);
|
|
pMsg->Release();
|
|
}
|
|
}
|
|
pDoc->Release();
|
|
}
|
|
pSP->Release();
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CMeHost::SaveToFile(LPWSTR pszW)
|
|
{
|
|
IPersistMime *ppm;
|
|
IPersistFile *pPF;
|
|
IMimeMessage *pMsg;
|
|
HRESULT hr;
|
|
|
|
hr = m_lpOleObj->QueryInterface(IID_IPersistMime, (LPVOID *)&ppm);
|
|
if (!FAILED(hr))
|
|
{
|
|
hr = CoCreateInstance(CLSID_IMimeMessage, NULL, CLSCTX_INPROC_SERVER, IID_IMimeMessage, (LPVOID *)&pMsg);
|
|
if (!FAILED(hr))
|
|
{
|
|
pMsg->InitNew();
|
|
|
|
hr = pMsg->QueryInterface(IID_IPersistFile, (LPVOID *)&pPF);
|
|
if (!FAILED(hr))
|
|
{
|
|
hr = ppm->Save(pMsg, PMS_TEXT|PMS_HTML);
|
|
if (!FAILED(hr))
|
|
{
|
|
SetEncodingOptions(pMsg, GetCharset());
|
|
hr = pPF->Save(pszW, FALSE);
|
|
}
|
|
pPF->Release();
|
|
}
|
|
pMsg->Release();
|
|
}
|
|
ppm->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HCHARSET CMeHost::GetCharset()
|
|
{
|
|
VARIANTARG va;
|
|
HCHARSET hCharset=0;
|
|
|
|
if (m_pCmdTarget &&
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_CHARSET, OLECMDEXECOPT_DODEFAULT, NULL, &va)==S_OK)
|
|
hCharset = (HCHARSET)va.lVal;
|
|
|
|
// if no charset has been set yet, let's use system codepage
|
|
if (hCharset==NULL)
|
|
m_pIntl->GetCodePageCharset(GetACP(), CHARSET_BODY, &hCharset);
|
|
|
|
return hCharset;
|
|
}
|
|
|
|
HRESULT SetEncodingOptions(IMimeMessage *pMsg, HCHARSET hCharset)
|
|
{
|
|
PROPVARIANT rVariant;
|
|
|
|
// Save Format
|
|
rVariant.vt = VT_UI4;
|
|
rVariant.ulVal = (ULONG)SAVE_RFC1521;
|
|
pMsg->SetOption(OID_SAVE_FORMAT, &rVariant);
|
|
|
|
// Text body encoding
|
|
rVariant.ulVal = (ULONG)IET_QP;
|
|
pMsg->SetOption(OID_TRANSMIT_TEXT_ENCODING, &rVariant);
|
|
|
|
// Plain Text body encoding
|
|
rVariant.ulVal = (ULONG)IET_QP;
|
|
pMsg->SetOption(OID_XMIT_PLAIN_TEXT_ENCODING, &rVariant);
|
|
|
|
// HTML Text body encoding
|
|
rVariant.ulVal = (ULONG)IET_QP;
|
|
pMsg->SetOption(OID_XMIT_HTML_TEXT_ENCODING, &rVariant);
|
|
|
|
pMsg->SetCharset(hCharset, CSET_APPLY_ALL);
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
HRESULT IPersistMimeLoad(IUnknown *pUnk, IMimeMessage *pMsg)
|
|
{
|
|
IPersistMime *pPM;
|
|
HRESULT hr;
|
|
|
|
hr = pUnk->QueryInterface(IID_IPersistMime, (LPVOID *)&pPM);
|
|
if (!FAILED(hr))
|
|
{
|
|
hr = pPM->Load(pMsg);
|
|
pPM->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT CMeHost::BackRed()
|
|
{
|
|
IServiceProvider *pSP;
|
|
IHTMLDocument2 *pDoc;
|
|
IHTMLElement *pElem;
|
|
IHTMLBodyElement *pBody;
|
|
VARIANTARG v;
|
|
|
|
if (m_lpOleObj->QueryInterface(IID_IServiceProvider, (LPVOID *)&pSP)==S_OK)
|
|
{
|
|
if (pSP->QueryService(IID_IHTMLDocument2, IID_IHTMLDocument2, (LPVOID *)&pDoc)==S_OK)
|
|
{
|
|
pElem=0;
|
|
pDoc->get_body(&pElem);
|
|
if (pElem)
|
|
{
|
|
if (pElem->QueryInterface(IID_IHTMLBodyElement, (LPVOID *)&pBody)==S_OK)
|
|
{
|
|
v.vt = VT_BSTR;
|
|
v.bstrVal = SysAllocString(L"#FF0000");
|
|
if (v.bstrVal)
|
|
{
|
|
pBody->put_bgColor(v);
|
|
SysFreeString(v.bstrVal);
|
|
}
|
|
pBody->Release();
|
|
}
|
|
pElem->Release();
|
|
}
|
|
pDoc->Release();
|
|
}
|
|
pSP->Release();
|
|
}
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
HRESULT CMeHost::ForeRed()
|
|
{
|
|
IServiceProvider *pSP;
|
|
IHTMLDocument2 *pDoc;
|
|
IHTMLSelectionObject *pSel=0;
|
|
IOleCommandTarget *pCmdTarget;
|
|
IDispatch *pID;
|
|
|
|
if (m_lpOleObj->QueryInterface(IID_IServiceProvider, (LPVOID *)&pSP)==S_OK)
|
|
{
|
|
if (pSP->QueryService(IID_IHTMLDocument2, IID_IHTMLDocument2, (LPVOID *)&pDoc)==S_OK)
|
|
{
|
|
pDoc->get_selection(&pSel);
|
|
if (pSel)
|
|
{
|
|
pSel->createRange(&pID);
|
|
if (pID)
|
|
{
|
|
if (pID->QueryInterface(IID_IOleCommandTarget, (LPVOID *)&pCmdTarget)==S_OK)
|
|
{
|
|
VARIANTARG v;
|
|
v.vt = VT_BSTR;
|
|
v.bstrVal = SysAllocString(L"#FF0000");
|
|
if (v.bstrVal)
|
|
{
|
|
pCmdTarget->Exec(&CMDSETID_Forms3, IDM_BACKCOLOR, NULL, &v, NULL);
|
|
SysFreeString(v.bstrVal);
|
|
}
|
|
}
|
|
pID->Release();
|
|
}
|
|
pSel->Release();
|
|
}
|
|
pDoc->Release();
|
|
}
|
|
pSP->Release();
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
HRESULT CMeHost::SaveAsStationery()
|
|
{
|
|
VARIANTARG vaIn,
|
|
vaOut;
|
|
char rgch[MAX_PATH],
|
|
rgch2[MAX_PATH+50];
|
|
|
|
|
|
vaIn.vt = VT_BSTR;
|
|
vaIn.bstrVal = SysAllocString(L"C:\\PROGRAM FILES\\COMMON FILES\\MICROSOFT SHARED\\STATIONERY");
|
|
if (vaIn.bstrVal)
|
|
{
|
|
if (m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_SAVEASSTATIONERY, NULL, &vaIn, &vaOut)==S_OK)
|
|
{
|
|
if (WideCharToMultiByte(CP_ACP, 0, vaOut.bstrVal, SysStringLen(vaOut.bstrVal), rgch, MAX_PATH, NULL, NULL))
|
|
{
|
|
wsprintf(rgch2, "Stationery saved to %s", rgch);
|
|
MessageBox(m_hwnd, rgch, "SaveAsStationery", MB_OK);
|
|
}
|
|
SysFreeString(vaOut.bstrVal);
|
|
}
|
|
SysFreeString(vaIn.bstrVal);
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CMeHost::BackgroundPicture()
|
|
{
|
|
VARIANT va;
|
|
char szUrl[MAX_PATH];
|
|
WCHAR szUrlW[MAX_PATH];
|
|
BSTR bstr;
|
|
|
|
*szUrl=0;
|
|
|
|
if (m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_BACKGROUNDIMAGE, NULL, NULL, &va)==S_OK)
|
|
WideCharToMultiByte(CP_ACP, 0, va.bstrVal, -1, szUrl, MAX_PATH, NULL, NULL);
|
|
|
|
if (GenericPrompt(m_hwnd, "Edit Background Picture...", "Choose a picture", szUrl, MAX_PATH)==S_OK)
|
|
{
|
|
if (MultiByteToWideChar(CP_ACP, 0, szUrl, -1, szUrlW, MAX_PATH) &&
|
|
(bstr = SysAllocString(szUrlW)))
|
|
{
|
|
va.vt = VT_BSTR;
|
|
va.bstrVal = bstr;
|
|
m_pCmdTarget->Exec(&CMDSETID_MimeEdit, MECMDID_BACKGROUNDIMAGE, NULL, &va, NULL);
|
|
SysFreeString(bstr);
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CMeHost::HrLoadFile(LPSTR pszFile)
|
|
{
|
|
IPersistFile *pPF;
|
|
IMimeMessage *pMsg;
|
|
|
|
if (!m_lpOleObj)
|
|
return E_FAIL;
|
|
|
|
if (pszFile == NULL || *pszFile==NULL)
|
|
return E_FAIL;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, pszFile, -1, m_szFileW, MAX_PATH);
|
|
|
|
if (CoCreateInstance(CLSID_IMimeMessage, NULL, CLSCTX_INPROC_SERVER, IID_IMimeMessage, (LPVOID *)&pMsg)==S_OK)
|
|
{
|
|
if (pMsg->QueryInterface(IID_IPersistFile, (LPVOID *)&pPF)==S_OK)
|
|
{
|
|
if (pPF->Load(m_szFileW, 0)==S_OK)
|
|
{
|
|
if (IPersistMimeLoad(m_lpOleObj, pMsg)==S_OK)
|
|
{
|
|
SetWindowText(m_hwnd, pszFile);
|
|
ReplaceInterface(m_pMsg, pMsg);
|
|
}
|
|
}
|
|
pPF->Release();
|
|
}
|
|
pMsg->Release();
|
|
}
|
|
return S_OK;
|
|
}
|
|
|