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.
 
 
 
 
 
 

808 lines
19 KiB

/*
* e n v h o s t . c p p
*
* Purpose:
*
* History
*
* Copyright (C) Microsoft Corp. 1995, 1996.
*/
#include <pch.hxx>
#include "resource.h"
#include "envcid.h"
#include "commdlg.h"
#include "docobj.h"
#include "dllmain.h"
#include "msoert.h"
#include "mimeole.h"
#include "envhost.h"
#include "richedit.h"
#include "init.h"
#include "shellapi.h"
HINSTANCE s_hRichEdit;
HINSTANCE g_hLocRes ;
HACCEL g_hAccelMailSend;
HRESULT HrRicheditStreamOut(HWND hwndRE, LPSTREAM pstm, ULONG uSelFlags);
void SaveFocus(BOOL fActive, HWND *phwnd);
static const TCHAR c_szGWNoteWndClass[] = "GW_Note";
//+---------------------------------------------------------------
//
// Member: Constructor
//
// Synopsis:
//
//---------------------------------------------------------------
CEnvHost::CEnvHost(IUnknown *pUnkOuter) : CPrivateUnknown(pUnkOuter)
{
DllAddRef();
}
//+---------------------------------------------------------------
//
// Member: Destructor
//
// Synopsis:
//
//---------------------------------------------------------------
CEnvHost::~CEnvHost()
{
DllRelease();
}
//+---------------------------------------------------------------
//
// Member: PrivateQueryInterface
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CEnvHost::PrivateQueryInterface(REFIID riid, LPVOID *lplpObj)
{
if(!lplpObj)
return E_INVALIDARG;
*lplpObj = NULL;
if (IsEqualIID(riid, IID_IUnknown))
*lplpObj = (LPVOID)(IMsoEnvelopeHost *)this;
else if (IsEqualIID(riid, IID_IMsoEnvelopeHost))
*lplpObj = (LPVOID)(IMsoEnvelopeHost *)this;
else
{
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
HRESULT CEnvHost::CreateNote(IUnknown *punk, REFCLSID clsidCreate, LPCWSTR wszTheme, LPCWSTR wszAuthor, LPCWSTR wszPrefix, DWORD grfCreate)
{
return HrCreateNote(clsidCreate, grfCreate);
}
HRESULT CEnvHost::LockServer(BOOL fLock)
{
return S_OK;
}
//+---------------------------------------------------------------
//
// Member: Constructor
//
// Synopsis:
//
//---------------------------------------------------------------
CGWNote::CGWNote(IUnknown *pUnkOuter) : CPrivateUnknown(pUnkOuter)
{
m_pEnv=NULL;
m_hwnd=NULL;
m_hwndRE=NULL;
m_pComponent=NULL;
m_hwndFocus=NULL;
DllAddRef();
}
//+---------------------------------------------------------------
//
// Member: Destructor
//
// Synopsis:
//
//---------------------------------------------------------------
CGWNote::~CGWNote()
{
DllRelease();
}
//+---------------------------------------------------------------
//
// Member: PrivateQueryInterface
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CGWNote::PrivateQueryInterface(REFIID riid, LPVOID *lplpObj)
{
if(!lplpObj)
return E_INVALIDARG;
*lplpObj = NULL;
if (IsEqualIID(riid, IID_IUnknown))
*lplpObj = (LPVOID)(IPersistMime *)this;
else if (IsEqualIID(riid, IID_IServiceProvider))
*lplpObj = (LPVOID)(IServiceProvider *)this;
else if (IsEqualIID(riid, IID_IPersistMime))
*lplpObj = (LPVOID)(IPersistMime *)this;
else if (IsEqualIID(riid, IID_IMsoEnvelopeSite))
*lplpObj = (LPVOID)(IMsoEnvelopeSite *)this;
else if (IsEqualIID(riid, IID_IMsoComponentManager))
*lplpObj = (LPVOID)(IMsoComponentManager *)this;
else
{
return E_NOINTERFACE;
}
AddRef();
return NOERROR;
}
//+---------------------------------------------------------------
//
// Member: GetClassID
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CGWNote::GetClassID(CLSID *pClassID)
{
*pClassID = CLSID_GWEnvelopeHost;
return NOERROR;
}
// *** IServiceProvider ***
//+---------------------------------------------------------------
//
// Member: QueryService
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CGWNote::QueryService(REFGUID guidService, REFIID riid, LPVOID *ppvObject)
{
if (IsEqualGUID(guidService, IID_IMsoComponentManager))
return PrivateQueryInterface(riid, ppvObject);
return E_NOINTERFACE;
}
// *** IPersistMime ***
//+---------------------------------------------------------------
//
// Member: Load
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CGWNote::Load(IMimeMessage *pMsg)
{
return E_NOTIMPL;
}
//+---------------------------------------------------------------
//
// Member: Save
//
// Synopsis:
//
//---------------------------------------------------------------
HRESULT CGWNote::Save(IMimeMessage *pMsg, DWORD dwFlags)
{
IPersistMime *pPM;
IStream *pstm;
HRESULT hr;
// save envelope props
if (m_pEnv &&
m_pEnv->QueryInterface(IID_IPersistMime, (LPVOID *)&pPM)==S_OK)
{
hr = pPM->Save(pMsg, dwFlags);
pPM->Release();
}
// save body props
if (MimeOleCreateVirtualStream(&pstm)==S_OK)
{
if (HrRicheditStreamOut(m_hwndRE, pstm, SF_TEXT)==S_OK)
pMsg->SetTextBody(TXT_PLAIN, IET_BINARY, NULL, pstm, NULL);
pstm->Release();
}
return hr;
}
HRESULT CGWNote::RequestResize(int *pcHeight)
{
RECT rc;
m_cyEnv = *pcHeight;
GetClientRect(m_hwnd, &rc);
rc.top +=2;
rc.bottom = m_cyEnv+2;
m_pEnv->Resize(&rc);
GetClientRect(m_hwnd, &rc);
rc.top += m_cyEnv + 4;
rc.bottom -=2;
SetWindowPos(m_hwndRE, NULL, 0, rc.top, rc.right-rc.left, rc.bottom-rc.top, SWP_NOZORDER);
return S_OK;
}
HRESULT CGWNote::CloseNote(DWORD grfClose)
{
SendMessage(m_hwnd, WM_CLOSE, 0, 0);
return S_OK;
}
HRESULT CGWNote::GetBody(IStream *pstm, DWORD dwCodePage, DWORD grfBody)
{
return E_NOTIMPL;
}
HRESULT CGWNote::SetBody(IStream *pstm, DWORD dwCodePage, DWORD grfBody)
{
return S_OK;
}
HRESULT CGWNote::SetFocus(BOOL fTab)
{
if (fTab)
::SetFocus(m_hwndRE);
return S_OK;
}
HRESULT CGWNote::OnEnvSetFocus()
{
return S_OK;
}
HRESULT CGWNote::OnPropChange(ULONG dispid)
{
return S_OK;
}
HRESULT CGWNote::IsBodyDirty()
{
return S_OK;
}
HRESULT CGWNote::HandsOff()
{
return S_OK;
}
HRESULT CGWNote::GetMsoInst(HMSOINST *phinst)
{
return E_NOTIMPL;
}
HRESULT CGWNote::GetFrameWnd(HWND *phwndFrame)
{
return E_NOTIMPL;
}
HRESULT CGWNote::DisplayMessage(HRESULT hr, LPCWSTR wszError, DWORD grfMsg)
{
return S_OK;
}
LRESULT CGWNote::ExtWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
CGWNote *pNote;
if(msg==WM_CREATE)
{
pNote=(CGWNote *)((LPCREATESTRUCT)lParam)->lpCreateParams;
if(!pNote)
return -1;
if(FAILED(pNote->OnCreate(hwnd)))
return -1;
}
pNote = (CGWNote *)GetWndThisPtr(hwnd);
if(pNote)
return pNote->WndProc(hwnd, msg, wParam, lParam);
else
return DefWindowProc(hwnd, msg, wParam, lParam);
}
LRESULT CGWNote::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
LONG lret;
switch (msg)
{
case WM_NOTIFY:
return (WMNotify(wParam, (NMHDR *)lParam)==S_OK);
case WM_COMMAND:
if (WMCommand( GET_WM_COMMAND_HWND(wParam, lParam),
GET_WM_COMMAND_ID(wParam, lParam),
GET_WM_COMMAND_CMD(wParam, lParam))==S_OK)
return 0;
break;
case WM_SIZE:
RequestResize((int *)&m_cyEnv);
break;
case WM_NCDESTROY:
OnNCDestroy();
break;
}
lret = DefWindowProc(hwnd, msg, wParam, lParam);
if(msg==WM_ACTIVATE)
{
// post-process wm_activates to set focus back to
// control
SaveFocus((BOOL)(LOWORD(wParam)), &m_hwndFocus);
g_pActiveNote = (LOWORD(wParam)==WA_INACTIVE)?NULL:this;
}
return lret;
}
HRESULT CGWNote::Init(REFCLSID clsidEnvelope, DWORD dwFlags)
{
HRESULT hr=S_OK;
HWND hwnd;
WNDCLASS wc;
HMENU hMenu;
TraceCall("CDocHost::Init");
if (!GetClassInfo(g_hInst, c_szGWNoteWndClass, &wc))
{
ZeroMemory(&wc, sizeof(WNDCLASS));
wc.lpfnWndProc = CGWNote::ExtWndProc;
wc.hInstance = g_hInst;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.lpszClassName = c_szGWNoteWndClass;
wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
wc.style = CS_DBLCLKS;
if(!RegisterClass(&wc))
return E_OUTOFMEMORY;
}
hMenu = LoadMenu(g_hInst, "GWNOTEMENU");
if (!hMenu)
return E_OUTOFMEMORY;
hwnd=CreateWindowEx(WS_EX_WINDOWEDGE|WS_EX_CONTROLPARENT,
c_szGWNoteWndClass,
"GW Note Control",
WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN,
0,
0,
400,
400,
NULL,
hMenu,
g_hInst,
(LPVOID)this);
if(!hwnd)
{
hr=E_OUTOFMEMORY;
goto error;
}
hr = InitEnvelope(clsidEnvelope, dwFlags);
error:
return hr;
}
HRESULT CGWNote::OnCreate(HWND hwnd)
{
CHARFORMAT cf={0};
m_hwnd = hwnd;
SetWindowLong(hwnd, GWL_USERDATA, (LPARAM)this);
m_hwndRE = CreateWindowEx(WS_EX_CLIENTEDGE,
"RichEdit",
"",
//ES_MULTILINE|ES_SAVESEL|ES_AUTOVSCROLL|ES_SELECTIONBAR|ES_WANTRETURN|WS_VSCROLL|WS_CHILD|WS_TABSTOP|WS_VISIBLE,
ES_SAVESEL|ES_WANTRETURN|ES_MULTILINE|WS_CHILD|WS_TABSTOP|WS_VISIBLE|ES_AUTOVSCROLL|WS_VSCROLL,
0, 0, 0, 0,
hwnd,
(HMENU)99,
g_hInst,
NULL);
if (!m_hwndRE)
return E_FAIL;
cf.cbSize = sizeof(CHARFORMAT);
cf.dwMask = CFM_COLOR|CFM_FACE;
cf.crTextColor = RGB(0,0,255);
lstrcpy(cf.szFaceName, "Verdana");
SendMessage(m_hwndRE, EM_SETCHARFORMAT, 0, (LPARAM)&cf);
SendMessage(m_hwndRE, EM_SETCHARFORMAT, SCF_ALL, (LPARAM)&cf);
SendMessage(m_hwndRE, EM_SETEVENTMASK, 0, ENM_KEYEVENTS);
AddRef();
return S_OK;
}
HRESULT CGWNote::OnNCDestroy()
{
SafeRelease(m_pEnv);
if (m_pComponent)
{
m_pComponent->Terminate();
SafeRelease(m_pComponent);
}
SetWindowLong(m_hwnd, GWL_USERDATA, NULL);
m_hwnd = NULL;
Release();
return S_OK;
}
HRESULT CGWNote::Show()
{
ShowWindow(m_hwnd, SW_SHOW);
return S_OK;
}
HRESULT CGWNote::InitEnvelope(REFCLSID clsidEnvelope, DWORD dwFlags)
{
HRESULT hr;
RECT rc;
hr = CoCreateInstance(clsidEnvelope, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER, IID_IMsoEnvelope, (LPVOID *)&m_pEnv);
if (FAILED(hr))
goto error;
hr = m_pEnv->Init(NULL, (IMsoEnvelopeSite *)this, dwFlags);
if (FAILED(hr))
goto error;
hr = m_pEnv->SetParent(m_hwnd);
if (FAILED(hr))
goto error;
hr = m_pEnv->Show(TRUE);
if (FAILED(hr))
goto error;
m_pEnv->SetFocus(ENV_FOCUS_INITIAL);
error:
return hr;
}
HRESULT CGWNote::TranslateAcclerator(MSG *lpmsg)
{
if (!g_hAccelMailSend)
g_hAccelMailSend= LoadAccelerators(g_hInst, MAKEINTRESOURCE(idacMail_SendNote));
if (::TranslateAccelerator(m_hwnd, g_hAccelMailSend, lpmsg))
return S_OK;
if (m_pComponent &&
m_pComponent->FPreTranslateMessage(lpmsg))
return S_OK;
return S_FALSE;
}
DWORD CALLBACK EditStreamOutCallback(DWORD dwCookie, LPBYTE pbBuff, LONG cb, LONG FAR *pcb)
{
return ((LPSTREAM)dwCookie)->Write(pbBuff, cb, (ULONG *)pcb);
}
HRESULT HrRicheditStreamOut(HWND hwndRE, LPSTREAM pstm, ULONG uSelFlags)
{
EDITSTREAM es;
if(!pstm)
return E_INVALIDARG;
if(!IsWindow(hwndRE))
return E_INVALIDARG;
HrRewindStream(pstm);
es.dwCookie = (DWORD)pstm;
es.pfnCallback=(EDITSTREAMCALLBACK)EditStreamOutCallback;
SendMessage(hwndRE, EM_STREAMOUT, uSelFlags, (LONG)&es);
return S_OK;
}
BOOL CGWNote::FRegisterComponent(IMsoComponent *piComponent, const MSOCRINFO *pcrinfo, DWORD *pdwComponentID)
{
if (m_pComponent) // only one register allowed
return E_FAIL;
ReplaceInterface(m_pComponent, piComponent);
*pdwComponentID=666;
return TRUE;
}
BOOL CGWNote::FRevokeComponent(DWORD dwComponentID)
{
return TRUE;
}
BOOL CGWNote::FUpdateComponentRegistration(DWORD dwComponentID, const MSOCRINFO *pcrinfo)
{
return FALSE;
}
BOOL CGWNote::FOnComponentActivate(DWORD dwComponentID)
{
return FALSE;
}
BOOL CGWNote::FSetTrackingComponent(DWORD dwComponentID, BOOL fTrack)
{
return FALSE;
}
void CGWNote::OnComponentEnterState(DWORD dwComponentID, ULONG uStateID, ULONG uContext,ULONG cpicmExclude,IMsoComponentManager **rgpicmExclude, DWORD dwReserved)
{
}
BOOL CGWNote::FOnComponentExitState(DWORD dwComponentID, ULONG uStateID, ULONG uContext,ULONG cpicmExclude,IMsoComponentManager **rgpicmExclude)
{
return FALSE;
}
BOOL CGWNote::FInState(ULONG uStateID, void *pvoid)
{
return FALSE;
}
BOOL CGWNote::FContinueIdle ()
{
return FALSE;
}
BOOL CGWNote::FPushMessageLoop(DWORD dwComponentID, ULONG uReason, void *pvLoopData)
{
return FALSE;
}
BOOL CGWNote::FCreateSubComponentManager(IUnknown *piunkOuter, IUnknown *piunkServProv,REFIID riid, void **ppvObj)
{
return FALSE;
}
BOOL CGWNote::FGetParentComponentManager(IMsoComponentManager **ppicm)
{
return FALSE;
}
BOOL CGWNote::FGetActiveComponent(DWORD dwgac, IMsoComponent **ppic, MSOCRINFO *pcrinfo, DWORD dwReserved)
{
return FALSE;
}
BOOL CGWNote::FDebugMessage(HMSOINST hinst, UINT message, WPARAM wParam, LPARAM lParam)
{
return FALSE;
}
HRESULT CGWNote::WMCommand(HWND hwndCmd, int id, WORD wCmd)
{
if (wCmd > 1)
return S_FALSE;
switch(id)
{
case idmNewMsg:
ShellExecute(m_hwnd, NULL, "mailto:", 0, 0, SW_SHOW);
return S_OK;
case idmProperties:
MessageBox(m_hwnd, "PlaceHolder", "Properties", MB_OK);
return S_OK;
case idmSaveAs:
return SaveAs();
case idmClose:
PostMessage(m_hwnd, WM_CLOSE, 0, 0);
return S_OK;
case idmCheckNames:
return HrHeaderExecCommand(MSOEENVCMDID_CHECKNAMES, MSOCMDEXECOPT_PROMPTUSER, NULL);
case idmPickRecipients:
return HrHeaderExecCommand(MSOEENVCMDID_SELECTRECIPIENTS, MSOCMDEXECOPT_DODEFAULT, NULL);
case idmViewContacts:
return HrHeaderExecCommand(MSOEENVCMDID_VIEWCONTACTS, MSOCMDEXECOPT_DODEFAULT, NULL);
default:
MessageBox(m_hwnd, "Not Yet Implemented", "Menu Command", MB_OK);
return S_OK;
}
return S_FALSE;
}
HRESULT CGWNote::HrHeaderExecCommand(UINT uCmdID, DWORD nCmdExecOpt, VARIANTARG *pvaIn)
{
HRESULT hr = S_FALSE;
IOleCommandTarget *pCmdTarget;
if(m_pEnv &&
m_pEnv->QueryInterface(IID_IOleCommandTarget, (LPVOID *)&pCmdTarget)==S_OK)
{
hr = pCmdTarget->Exec(&CGID_Envelope, uCmdID, nCmdExecOpt, pvaIn, NULL);
pCmdTarget->Release();
}
return hr;
}
HRESULT CGWNote::WMNotify(int idFrom, NMHDR *pnmh)
{
MSGFILTER *pmf=(MSGFILTER *)pnmh;
BOOL fShift;
switch (pnmh->code)
{
case EN_MSGFILTER:
if (pmf->msg == WM_KEYDOWN && pmf->wParam == VK_TAB && !(GetKeyState(VK_CONTROL) & 0x8000))
{
// shift tab puts focus in the envelope
if (GetKeyState(VK_SHIFT)&0x8000 && m_pEnv)
{
m_pEnv->SetFocus(ENV_FOCUS_TAB);
return S_OK;
}
}
break;
}
return S_FALSE;
}
void SaveFocus(BOOL fActive, HWND *phwnd)
{
if(fActive&&IsWindow(*phwnd))
SetFocus(*phwnd);
else
*phwnd=GetFocus();
}
static char c_szFilter[] = "Rfc 822 Messages (*.eml)\0*.eml\0\0";
HRESULT CGWNote::SaveAs()
{
OPENFILENAME ofn;
TCHAR szFile[MAX_PATH];
TCHAR szTitle[MAX_PATH];
TCHAR szDefExt[30];
WCHAR szFileW[MAX_PATH];
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, szFileW, MAX_PATH);
return SaveToFile(szFileW);
}
HRESULT CGWNote::SaveToFile(LPWSTR pszW)
{
IPersistMime *ppm;
IPersistFile *pPF;
IMimeMessage *pMsg;
HRESULT 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 = Save(pMsg, 0);
if (!FAILED(hr))
{
hr = pPF->Save(pszW, FALSE);
}
pPF->Release();
}
pMsg->Release();
}
return hr;
}
HRESULT CGWNote::DirtyToolbars(void)
{
return S_OK;
}
HRESULT CGWNote::SetHelpMode(BOOL fEnter)
{
return S_OK;
}
HRESULT CGWNote::TranslateAccelerators(MSG *pMsg)
{
return S_FALSE;
}