able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/shdocvw/shembed.cpp

1711 lines
46 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "priv.h"
#include "sccls.h"
#include <mluisupp.h>
#define IPSMSG(psz) TraceMsg(TF_SHDCONTROL, "she TR-IPS::%s called", psz)
#define IPSMSG2(psz, hres) TraceMsg(TF_SHDCONTROL, "she TR-IPS::%s %x", psz, hres)
#define IPSMSG3(pszName, psz) TraceMsg(TF_SHDCONTROL, "she TR-IPS::%s:%s called", pszName,psz)
#define IOOMSG(psz) TraceMsg(TF_SHDCONTROL, "she TR-IOO::%s called", psz)
#define IOOMSGX(psz, hres) TraceMsg(TF_SHDCONTROL, "she TR-IOO::%s returning %x", psz, hres)
#define IOOMSG2(psz, i) TraceMsg(TF_SHDCONTROL, "she TR-IOO::%s called with (%d)", psz, i)
#define IOOMSG3(psz, i, j) TraceMsg(TF_SHDCONTROL, "she TR-IOO::%s called with (%d, %d)", psz, i, j)
#define IVOMSG(psz) TraceMsg(TF_SHDCONTROL, "she TR-IVO::%s called", psz)
#define IVOMSG2(psz, i) TraceMsg(TF_SHDCONTROL, "she TR-IVO::%s called with (%d)", psz, i)
#define IVOMSG3(psz, i, j) TraceMsg(TF_SHDCONTROL, "she TR-IVO::%s with (%d, %d)", psz, i, j)
#define CCDMSG(psz, punk) TraceMsg(TF_SHDCONTROL, "she TR-CSV::%s called punk=%x", psz, punk)
#define IDTMSG(psz) TraceMsg(TF_SHDCONTROL, "she TR-IDT::%s called", psz)
#define IDTMSG2(psz, i) TraceMsg(TF_SHDCONTROL, "she TR-IDT::%s called with %d", psz, i)
#define IDTMSG3(psz, x) TraceMsg(TF_SHDCONTROL, "she TR-IDT::%s %x", psz, x)
#define IDTMSG4(psz, i, j) TraceMsg(TF_SHDCONTROL, "she TR-IDT::%s called with %x,%x", psz, i, j)
#define IIPMSG(psz) TraceMsg(TF_SHDCONTROL, "she TR-IOIPO::%s called", psz)
#define IIAMSG(psz) TraceMsg(TF_SHDCONTROL, "she TR-IOIPAO::%s called", psz)
#define IEVMSG(psz, i, j, ps) TraceMsg(TF_SHDCONTROL, "she TR-IEV::%s called celt=%d, _iCur=%d, %x", psz, i, j, ps)
const TCHAR c_szShellEmbedding[] = TEXT("Shell Embedding");
//
// A special lindex value to be passed to ::Draw member indicating
// that it is an internal call from ::GetData
//
#define LINDEX_INTERNAL 12345
// REVIEW: We may want to use the functions in UTIL.C -- they look more efficient...
//
//=========================================================================
// Helper functions
//=========================================================================
#define HIM_PER_IN 2540
int g_iXppli = 0;
int g_iYppli = 0;
void GetLogPixels()
{
HDC hdc = GetDC(NULL);
if (hdc)
{
g_iXppli = GetDeviceCaps(hdc, LOGPIXELSX);
g_iYppli = GetDeviceCaps(hdc, LOGPIXELSY);
ReleaseDC(NULL, hdc);
}
}
// Scalar conversion of MM_HIMETRIC to MM_TEXT
void MetricToPixels(SIZEL* psize)
{
ASSERT(g_iXppli);
psize->cx = MulDiv(psize->cx, g_iXppli, HIM_PER_IN);
psize->cy = MulDiv(psize->cy, g_iYppli, HIM_PER_IN);
}
// Scalar conversion of MM_TEXT to MM_HIMETRIC
void PixelsToMetric(SIZEL* psize)
{
ASSERT(g_iYppli);
psize->cx = MulDiv(psize->cx, HIM_PER_IN, g_iXppli);
psize->cy = MulDiv(psize->cy, HIM_PER_IN, g_iYppli);
}
//=========================================================================
// CShellEmbedding implementaiton
//=========================================================================
HRESULT CShellEmbedding::v_InternalQueryInterface(REFIID riid, LPVOID * ppvObj)
{
static const QITAB qit[] = {
QITABENT(CShellEmbedding, IPersist),
QITABENT(CShellEmbedding, IOleObject),
QITABENT(CShellEmbedding, IViewObject2),
QITABENTMULTI(CShellEmbedding, IViewObject, IViewObject2),
QITABENT(CShellEmbedding, IDataObject),
QITABENT(CShellEmbedding, IOleInPlaceObject),
QITABENTMULTI(CShellEmbedding, IOleWindow, IOleInPlaceObject),
QITABENT(CShellEmbedding, IOleInPlaceActiveObject),
QITABENT(CShellEmbedding, IInternetSecurityMgrSite),
{ 0 },
};
return QISearch(this, qit, riid, ppvObj);
}
CShellEmbedding::CShellEmbedding(IUnknown* punkOuter, LPCOBJECTINFO poi, const OLEVERB* pverbs)
: _pverbs(pverbs)
, _nActivate(OC_DEACTIVE)
, CAggregatedUnknown(punkOuter)
{
TraceMsg(TF_SHDCONTROL, "ctor CShellEmbedding %x", this);
DllAddRef();
_RegisterWindowClass();
_pObjectInfo = poi;
_size.cx = 50;
_size.cy = 20;
// make sure some globals are set
GetLogPixels();
// let our logical size match our physical size
_sizeHIM = _size;
PixelsToMetric(&_sizeHIM);
}
CShellEmbedding::~CShellEmbedding()
{
ASSERT(_hwnd==NULL);
// IE v 4.1 bug 44541. In an Office 97 user form, we were seeing this destructor get entered
// with a non-null hwnd, which would cause a fault the next time the hwnd received a message.
//
if (_hwnd)
{
DestroyWindow(_hwnd);
_hwnd = NULL;
}
ASSERT(_hwndChild==NULL);
ASSERT(_pcli==NULL);
ASSERT(_pipsite==NULL);
ASSERT(_pipframe==NULL);
ASSERT(_pipui==NULL);
//
// WARNING: Don't call any of virtual functions of this object
// itself for clean-up purpose. The Vtable is alreadly adjusted
// and we won't be able to perform any full clean up. Do it
// right before you delete in CShellEmbedding::CSVInner::Release.
//
TraceMsg(TF_SHDCONTROL, "dtor CShellEmbedding %x", this);
// Warning: if the client site has not been released do not release the advise
// object as some applications like VC5 will fault on this...
if (_padv) {
_padv->OnClose();
if (!_pcli)
ATOMICRELEASE(_padv);
}
if (!_pcli)
{
ATOMICRELEASE(_pdah);
ATOMICRELEASE(_poah);
}
ATOMICRELEASE(_pstg);
ATOMICRELEASE(_pcliHold);
DllRelease();
}
// **************** IPersist ****************
HRESULT CShellEmbedding::GetClassID(CLSID *pClassID)
{
*pClassID = CLSIDOFOBJECT(this);
return S_OK;
}
BOOL CShellEmbedding::_ShouldDraw(LONG lindex)
{
// Don't draw if the window is visible.
return ! (_pipsite && lindex!=LINDEX_INTERNAL);
}
// **************** IViewObject ****************
HRESULT CShellEmbedding::Draw(
DWORD dwDrawAspect,
LONG lindex,
void *pvAspect,
DVTARGETDEVICE *ptd,
HDC hdcTargetDev,
HDC hdcDraw,
LPCRECTL lprcBounds,
LPCRECTL lprcWBounds,
BOOL ( __stdcall *pfnContinue )(ULONG_PTR dwContinue),
ULONG_PTR dwContinue)
{
IVOMSG3(TEXT("Draw called"), lprcBounds->top, lprcBounds->bottom);
// WARNING: this looks wrong to me -- I think we should always respond
// to a Draw request, as the hdcDraw may not be the screen!
//
// Don't draw if the window is visible.
if (!_ShouldDraw(lindex)) {
return S_OK;
}
if (_hwnd) {
int iDC = SaveDC(hdcDraw);
RECTL rcBounds = *lprcBounds;
::LPtoDP(hdcDraw, (LPPOINT)&rcBounds, 2);
IVOMSG3(TEXT("Draw DP=="), rcBounds.top, rcBounds.bottom);
TraceMsg(TF_SHDCONTROL, "she Draw cx=%d cy=%d", rcBounds.right-rcBounds.left, rcBounds.bottom-rcBounds.top);
SetMapMode(hdcDraw, MM_TEXT); // make it 1:1
SetMapMode(hdcDraw, MM_ANISOTROPIC); // inherit call from MM_TEXT
POINT pt;
SetViewportOrgEx(hdcDraw, rcBounds.left, rcBounds.top, &pt);
// APPCOMPAT: WordPad does a GetExtent to get the size and passes that in as lprcBounds
// *without* doing a SetExtent, so when we resize larger (due to a BROWSE verb) _hwnd
// is still the old size. So we IntersectClipRect to _hwnd but WordPad draws the border
// to rcBounds. Ugly.
RECT rc;
GetClientRect(_hwnd, &rc);
IntersectClipRect(hdcDraw, 0, 0, rc.right, rc.bottom);
SendMessage(_hwnd, WM_PRINT, (WPARAM)hdcDraw,
PRF_NONCLIENT|PRF_CLIENT|PRF_CHILDREN|PRF_ERASEBKGND);
SetViewportOrgEx(hdcDraw, pt.x, pt.y, NULL);
RestoreDC(hdcDraw, iDC);
return S_OK;
}
return OLE_E_BLANK;
}
HRESULT CShellEmbedding::GetColorSet(
DWORD dwDrawAspect,
LONG lindex,
void *pvAspect,
DVTARGETDEVICE *ptd,
HDC hicTargetDev,
LOGPALETTE **ppColorSet)
{
IVOMSG(TEXT("GetColorSet"));
return S_FALSE; // Indicating that the object doesn't care
}
HRESULT CShellEmbedding::Freeze(
DWORD dwDrawAspect,
LONG lindex,
void *pvAspect,
DWORD *pdwFreeze)
{
IVOMSG(TEXT("Freeze"));
*pdwFreeze = 0;
return S_OK;
}
HRESULT CShellEmbedding::Unfreeze(DWORD dwFreeze)
{
IVOMSG(TEXT("Unfreeze"));
return S_OK;
}
HRESULT CShellEmbedding::SetAdvise(
DWORD aspects,
DWORD advf,
IAdviseSink *pAdvSink)
{
IVOMSG2(TEXT("SetAdvise"), pAdvSink);
if (advf & ~(ADVF_ONLYONCE | ADVF_PRIMEFIRST))
return E_INVALIDARG;
if (pAdvSink != _padv)
{
ATOMICRELEASE(_padv);
if (pAdvSink)
{
_padv = pAdvSink;
_padv->AddRef();
}
}
_asp = aspects;
_advf = advf;
if (advf & ADVF_PRIMEFIRST)
_SendAdvise(OBJECTCODE_VIEWCHANGED);
return S_OK;
}
HRESULT CShellEmbedding::GetAdvise(
DWORD *pAspects,
DWORD *pAdvf,
IAdviseSink **ppAdvSink)
{
IVOMSG(TEXT("GetAdvise"));
if (pAspects) {
*pAspects = _asp;
}
if (pAdvf) {
*pAdvf = _advf;
}
if (ppAdvSink) {
*ppAdvSink = _padv;
if (_padv) {
_padv->AddRef();
}
}
return S_OK;
}
// **************** IViewObject2 ****************
HRESULT CShellEmbedding::GetExtent(
DWORD dwDrawAspect,
LONG lindex,
DVTARGETDEVICE *ptd,
LPSIZEL lpsizel)
{
TraceMsg(TF_SHDCONTROL, "she GetExtent cx=%d cy=%d", _size.cx, _size.cy);
lpsizel->cx = _size.cx;
lpsizel->cy = _size.cy;
PixelsToMetric(lpsizel);
return S_OK;
}
//
// **************** IOleObject ****************
//
void CShellEmbedding::_OnSetClientSite()
{
if (_pcli)
{
IOleInPlaceSite* pipsite;
if (SUCCEEDED(_pcli->QueryInterface(IID_IOleInPlaceSite, (LPVOID*)&pipsite)))
{
_CreateWindowOrSetParent(pipsite);
pipsite->Release();
}
}
else if (_hwnd)
{
DestroyWindow(_hwnd);
_hwnd = NULL;
}
}
HRESULT CShellEmbedding::SetClientSite(IOleClientSite *pClientSite)
{
IOOMSG2(TEXT("SetClientSite"), pClientSite);
// If I have a client site on hold, get rid of it.
//
ATOMICRELEASE(_pcliHold);
if (_pcli == pClientSite)
{
// mshtml is hitting their initialization code twice
// no need for us to do anything here.
}
else
{
ATOMICRELEASE(_pcli);
ATOMICRELEASE(_pipsite);
ATOMICRELEASE(_pipframe);
ATOMICRELEASE(_pipui);
_pcli = pClientSite;
if (_pcli)
_pcli->AddRef();
_OnSetClientSite();
}
return S_OK;
}
//
// This function create _hwnd (the parent of this embedding) if it not
// created yet. Otherwise, it simply SetParent appropriately.
//
// NOTE: When this object is embedded in PowerPoint 95, the first
// CreateWindowEx fails when this function if called from SetClientSite
// for some unknown reason.
// It, however, succeeds when it is called from DoVerb. We should find
// it out.
//
HRESULT CShellEmbedding::_CreateWindowOrSetParent(IOleWindow* pwin)
{
HWND hwndParent = NULL;
HRESULT hres = S_OK;
//
// NOTES: Unlike IE3.0, we don't fail even if pwin->GetWindow fails.
// It allows Trident to SetClientSite (and Navigate) before they
// are In-place Activated. In that case (hwndParent==NULL), we
// create a top-level window hidden and use it for navigation.
// When we are being InPlaceActivated, we hit this function again
// and set the parent (and window styles) correctly. Notice that
// we need to set WS_POPUP to avoid the Window Manager automatically
// add other random styles for verlapped window.
//
pwin->GetWindow(&hwndParent);
#ifdef DEBUG
// Pretend that GetWindow failed here.
if (_hwnd==NULL && (g_dwPrototype & 0x00000200))
{
TraceMsg(DM_TRACE, "CSE::_CreateWindowOrSetParent pretend unsuccessful GetWindow");
hwndParent = NULL;
}
#endif
_fOpen = TRUE;
if (_hwnd)
{
SetParentHwnd(_hwnd, hwndParent);
}
else
{
_hwnd = SHNoFusionCreateWindowEx(
WS_EX_WINDOWEDGE,
c_szShellEmbedding, NULL,
(hwndParent ?
(WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_TABSTOP)
: (WS_POPUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_TABSTOP)),
0, 0, _rcPos.right - _rcPos.left, _rcPos.bottom - _rcPos.top,
hwndParent,
(HMENU)0,
HINST_THISDLL,
(LPVOID)SAFECAST(this, CImpWndProc*));
if (!_hwnd)
{
hres = E_FAIL;
TraceMsg(TF_SHDCONTROL, "sdv TR-IOO::_CreateWindowOrSetParent CreateWindowEx failed (%d)", GetLastError());
}
}
return hres;
}
HRESULT CShellEmbedding::GetClientSite(IOleClientSite **ppClientSite)
{
IOOMSG(TEXT("GetClientSite"));
*ppClientSite = _pcli;
if (_pcli) {
_pcli->AddRef();
}
return S_OK;
}
HRESULT CShellEmbedding::SetHostNames(
LPCOLESTR szContainerApp,
LPCOLESTR szContainerObj)
{
IOOMSG(TEXT("SetHostNames"));
// We are not interested in host name
return S_OK;
}
// A container application calls IOleObject::Close when it wants
// to move the object from a running to a loaded state. Following
// such a call, the object still appears in its container but is
// not open for editing. Calling IOleObject::Close on an object
// that is loaded but not running has no effect.
//
HRESULT CShellEmbedding::Close(DWORD dwSaveOption)
{
IOOMSG2(TEXT("Close"), dwSaveOption);
// Change the state of object back to TEXT("loaded") state.
BOOL fSave = FALSE;
if (_fDirty &&
((OLECLOSE_SAVEIFDIRTY==dwSaveOption)
|| (dwSaveOption==OLECLOSE_PROMPTSAVE))) {
fSave = TRUE;
}
if (fSave) {
_SendAdvise(OBJECTCODE_SAVEOBJECT);
_SendAdvise(OBJECTCODE_SAVED);
}
_SendAdvise(OBJECTCODE_CLOSED);
_fOpen = FALSE;
// "loaded but not running" is confusing wording... If you look
// at the OLEIVERB_HIDE comment in _OnActivateChange, it mentions
// that OLEIVERB_HIDE puts it in the state "just after loading"
// and puts us in OC_DEACTIVE state. Let's do that here as well.
//
// it just came to my awareness that OCs UIDeactivate,
// not IPDeactivate...
_DoActivateChange(NULL, OC_DEACTIVE, FALSE);
// It seems like some containers (Trident frame set) don't
// do a SetClientSite(NULL) on us, so do it here. Old code here
// did a DestroyWindow(_hwnd), which SetClientSite(NULL) will do.
// NOTE: VB does call SetClientSite, but they do it after Close.
// If we already have one on hold, release it.
//
ATOMICRELEASE(_pcliHold);
// Hold onto our client site. We may need it if we're DoVerbed, as Office tends to do.
//
IOleClientSite *pOleClientSite = _pcli;
if (pOleClientSite)
{
pOleClientSite->AddRef();
}
SetClientSite(NULL);
_pcliHold = pOleClientSite;
return S_OK;
}
HRESULT CShellEmbedding::SetMoniker(
DWORD dwWhichMoniker,
IMoniker *pmk)
{
IOOMSG(TEXT("SetMoniker"));
// We are not interested in moniker.
return S_OK;
}
HRESULT CShellEmbedding::GetMoniker(
DWORD dwAssign,
DWORD dwWhichMoniker,
IMoniker **ppmk)
{
IOOMSG(TEXT("GetMoniker"));
return E_NOTIMPL;
}
HRESULT CShellEmbedding::InitFromData(
IDataObject *pDataObject,
BOOL fCreation,
DWORD dwReserved)
{
IOOMSG(TEXT("InitFromData"));
// LATER: We may want to implement this later.
return E_FAIL;
}
HRESULT CShellEmbedding::GetClipboardData(
DWORD dwReserved,
IDataObject **ppDataObject)
{
IOOMSG(TEXT("GetClipboardData"));
return E_FAIL;
}
HRESULT CShellEmbedding::DoVerb(
LONG iVerb,
LPMSG lpmsg,
IOleClientSite *pActiveSite,
LONG lindex,
HWND hwndParent,
LPCRECT lprcPosRect)
{
IOOMSG2(TEXT("DoVerb"), iVerb);
HRESULT hres = S_OK;
// If I don't have a client site, but I have one on "hold", I need to set it up again.
//
if (_pcli == NULL
&& _pcliHold)
{
IOleClientSite *pOleClientSite = _pcliHold;
_pcliHold = NULL;
SetClientSite(pOleClientSite);
pOleClientSite->Release();
}
switch(iVerb)
{
case OLEIVERB_HIDE:
hres = _DoActivateChange(NULL, OC_DEACTIVE, FALSE);
break;
case OLEIVERB_OPEN:
hres = E_FAIL;
break;
case OLEIVERB_PRIMARY:
case OLEIVERB_SHOW:
if (_pipsite) {
return S_OK;
}
// Fall through
case OLEIVERB_UIACTIVATE:
hres = _DoActivateChange(pActiveSite, OC_UIACTIVE, TRUE); //TRUE => We want to force UIACTIVE even if we are already active.
break;
case OLEIVERB_INPLACEACTIVATE:
hres = _DoActivateChange(pActiveSite, OC_INPLACEACTIVE, FALSE);
break;
default:
hres = E_FAIL; // OLEOBJ_S_INVALDVERB;
break;
}
IOOMSGX(TEXT("DoVerb"), hres);
return hres;
}
//
// fForce == TRUE indicates that we need to call _OnActivateChange even if we
// are already in OC_UIACITVE state.
//
HRESULT CShellEmbedding::_DoActivateChange(IOleClientSite* pActiveSite, UINT uState, BOOL fForce)
{
if (uState == _nActivate)
{
// in general, we have nothing to do if we're already in
// the correct state. HOWEVER, OLEIVERB_UIACTIVATE is supposed
// to set focus if we (or our children?) don't currently have it.
// Fall into _OnActivateChange so CWebBrowserOC can tell the
// base browser to go uiactive.
//
if ((uState != OC_UIACTIVE) || !fForce)
return S_OK;
}
#define STATETOSTRING(n) (n==OC_DEACTIVE ? TEXT("OC_DEACTIVE") : (n==OC_INPLACEACTIVE ? TEXT("OC_INPLACEACTIVE") : (n== OC_UIACTIVE ? TEXT("OC_UIACTIVE") : TEXT("ERROR"))))
TraceMsg(TF_SHDCONTROL, "she _DoActivateChange from %s to %s", STATETOSTRING(_nActivate), STATETOSTRING(uState));
return _OnActivateChange(pActiveSite, uState);
}
HRESULT CShellEmbedding::_OnActivateChange(IOleClientSite* pActiveSite, UINT uState)
{
if (uState != _nActivate)
{
// mark us in our new state immediately. this avoids recursion death with bad containers (ipstool)
UINT uOldState = _nActivate;
_nActivate = uState;
if (uOldState == OC_DEACTIVE) // going from deactive to IP or UI active
{
if (pActiveSite==NULL)
{
_nActivate = uOldState;
return E_INVALIDARG;
}
ASSERT(!_pipsite); // always true, so why check below?
if (!_pipsite)
{
HRESULT hres = pActiveSite->QueryInterface(IID_IOleInPlaceSite, (LPVOID*)&_pipsite);
if (FAILED(hres))
{
_nActivate = uOldState;
return hres;
}
hres = _pipsite->CanInPlaceActivate();
if (hres != S_OK) {
ATOMICRELEASE(_pipsite);
TraceMsg(TF_SHDCONTROL, "she - CanInPlaceActivate returned %x", hres);
_nActivate = uOldState;
return E_FAIL;
}
_OnInPlaceActivate(); // do it
}
}
else if (uOldState == OC_UIACTIVE) // going from UIActive to IPActive or deactive
{
_OnUIDeactivate();
}
if (uState == OC_UIACTIVE) // going to UIActive
{
_OnUIActivate();
}
else if (uState == OC_DEACTIVE) // going to Deactive
{
// We fail creation (OLEIVERB_PRIMARY, OLEIVERB_SHOW,
// OLEIVERB_UIACTIVATE, or OLEIVERB_INPLACEACTIVATE) if we don't
// get a pipsite, so we should never hit this case.
ASSERT(_pipsite);
// OLEIVERB_HIDE should ... return it to the visual state just after
// initial creation or reloading, before OLEIVERB_SHOW or OLEIVERB_OPEN
// is sent. Which is what _InPlaceDeactivate does. What's the point of this?
// htmlobj calls OLEIVERB_HIDE and then ::InPlaceDeactivate
_OnInPlaceDeactivate();
}
}
return S_OK;
}
// move from de-active to in-place-active
void CShellEmbedding::_OnInPlaceActivate()
{
//
// Set the appropriate parent window.
//
_CreateWindowOrSetParent(_pipsite);
_pipsite->OnInPlaceActivate();
ASSERT(_pipframe == NULL);
ASSERT(_pipui == NULL);
_finfo.cb = sizeof(OLEINPLACEFRAMEINFO);
_pipsite->GetWindowContext(&_pipframe, &_pipui,
&_rcPos, &_rcClip, &_finfo);
TraceMsg(TF_SHDCONTROL, "she::_OnInPlaceActivate x=%d y=%d cx=%d cy=%d (_cx=%d _cy=%d)", _rcPos.left, _rcPos.top, _rcPos.right-_rcPos.left, _rcPos.bottom-_rcPos.top, _size.cx, _size.cy);
SetWindowPos(_hwnd, 0,
_rcPos.left, _rcPos.top,
_rcPos.right-_rcPos.left,
_rcPos.bottom-_rcPos.top,
SWP_SHOWWINDOW | SWP_NOZORDER);
_SendAdvise(OBJECTCODE_SHOWOBJECT); // just like OLE 2nd ed (p.1074)
}
// Move from in-place-active to de-active
void CShellEmbedding::_OnInPlaceDeactivate(void)
{
if (_hwnd) {
ShowWindow(_hwnd, SW_HIDE);
// re-parent our _hwnd... when we're not active we can't rely on
// what our parent window is doing. The container can even destroy it!
//
// FEATURE: the standard thing to do here is DESTROY our HWND and
// recreate it if/when we are reactivated. This may break our hosted
// IShellView and draw code. Investigate this.
//
// APPCOMPAT: this has been taken out by CDturner, MikeSH assures me we don't need it, and
// this is causing our app to lose activation and regain it which causes the
// palette to flash on 256 colour machines...y
// SetParentHwnd(_hwnd, NULL);
}
if (_pipsite) {
_pipsite->OnInPlaceDeactivate();
ATOMICRELEASE(_pipsite);
}
ATOMICRELEASE(_pipframe);
ATOMICRELEASE(_pipui);
//
// We need to tell the container to update the cached metafile, if any.
//
_SendAdvise(OBJECTCODE_DATACHANGED);
}
// move from in-place-active to ui-active
void CShellEmbedding::_OnUIActivate(void)
{
if (_pipsite) {
_pipsite->OnUIActivate();
}
//
// HACK: When we are in Excel, _pipui->SetActiveObject sets the focus
// to us (for some unknown reason -- trying to be nice?). Since _hwnd
// simply forward the focus to the _hwndChild, setting focus to _hwnd
// twice causes this:
//
// 1. SetFocus(_hwnd) by us (if we call SetFocus(_hwnd))
// 2. SetFocus(_hwndChild) in _hwnd's wndproc
// 3. SetFocus(_hwnd) by Excel
// 4. SetFocus(_hwndChild) in _hwnd's wndproc
//
// If _hwndChild is a control, it notifies to the parent that it
// lost the focus. Then, we think "oh, we lost the focus. We should
// deactivate this object". To avoid it, we don't call SetFocus before
// we call _pipui->SetActiveObject and do some tricky thing below.
//
// SetFocus(_hwnd);
//
// RDuke suggest us to change the second parameter to NULL (instead of
// "FOO" in IE3, but we don't know the side effect of it. I'm changing
// it to "item" for IE4. (SatoNa)
//
if (_pipframe) {
_pipframe->SetActiveObject(SAFECAST(this, IOleInPlaceActiveObject*), L"item");
}
if (_pipui) {
_pipui->SetActiveObject(SAFECAST(this, IOleInPlaceActiveObject*), L"item");
}
//
// We don't have any menu, so tell the container to use its own menu.
//
if (_pipframe) {
_pipframe->SetMenu(NULL, NULL, _hwnd);
}
// Find-out if one of our child window has the input focus.
for (HWND hwndFocus = GetFocus();
hwndFocus && hwndFocus!=_hwnd;
hwndFocus = GetParent(hwndFocus))
{}
// If not, set it.
if (hwndFocus==NULL) {
SetFocus(_hwnd);
}
// If this UIActivate came from below (i.e., our hosted DocObject), then we need to inform
// our container. We do this by calling IOleControlSite::OnFocus. VB5 and Visual FoxPro
// (at least) rely on this call being made for proper focus handling.
//
IUnknown_OnFocusOCS(_pcli, TRUE);
}
void CShellEmbedding::_OnUIDeactivate(void)
{
//
// We don't have any shared menu or tools to clean up.
//
if (_pipframe) {
_pipframe->SetActiveObject(NULL, NULL);
}
if (_pipui) {
_pipui->SetActiveObject(NULL, NULL);
}
if (_pipsite) {
_pipsite->OnUIDeactivate(FALSE);
}
// If this UIDeactivate came from below (i.e., our hosted DocObject), then we need to inform
// our container. We do this by calling IOleControlSite::OnFocus. VB5 and Visual FoxPro
// (at least) rely on this call being made for proper focus handling.
//
IUnknown_OnFocusOCS(_pcli, FALSE);
}
HRESULT CShellEmbedding::EnumVerbs(
IEnumOLEVERB **ppEnumOleVerb)
{
IOOMSG(TEXT("EnumVerbs"));
*ppEnumOleVerb = new CSVVerb(_pverbs);
return *ppEnumOleVerb ? S_OK : E_OUTOFMEMORY;
}
HRESULT CShellEmbedding::Update( void)
{
IOOMSG(TEXT("Update"));
// Always up-to-date
return S_OK;
}
HRESULT CShellEmbedding::IsUpToDate( void)
{
IOOMSG(TEXT("IsUpToDate"));
// Always up-to-date
return S_OK;
}
HRESULT CShellEmbedding::GetUserClassID(CLSID *pClsid)
{
IOOMSG(TEXT("GetUserClassID"));
return GetClassID(pClsid);
}
HRESULT CShellEmbedding::GetUserType(DWORD dwFormOfType, LPOLESTR *pszUserType)
{
return OleRegGetUserType(CLSIDOFOBJECT(this), dwFormOfType, pszUserType);
}
HRESULT CShellEmbedding::SetExtent(DWORD dwDrawAspect, SIZEL *psizel)
{
// SetExtent sets the LOGICAL size of an object. SetObjectRects determins
// the size of the object on the screen. If we cared about zooming, we'd
// keep track of this and do some sort of scaling. But we don't.
// We still need to remember this value so we return it on GetExtent.
//
_sizeHIM = *psizel;
// HOWEVER, IE3 shipped a SetExtent that changed the physical size of the
// object. For compat (AOL uses SetExtent to change the size), if we're the
// old WebBrowser, continue to resize.
//
if (_pObjectInfo->pclsid == &CLSID_WebBrowser_V1)
{
RECT rc;
HDC hdc;
int mmOld;
POINT pt;
// Make sure a container doesn't do anything strange like
// make us negative size
//
// APPCOMPAT: this breaks Trident because it sizes us negative
// and we fail that sizing and they get confused...
//
//ASSERT(psizel->cx >= 0 && psizel->cy <= 0);
//if (psizel->cx < 0 || psizel->cy > 0)
// return E_FAIL;
// We only support DVASPECT_CONTENT
if (dwDrawAspect != DVASPECT_CONTENT)
return E_NOTIMPL;
// Map this to a SetObjectRects call -- that way superclasses
// only have to watch one function for size changes
//
int nScaleFactorX = 1, nScaleFactorY = 1;
pt.x = psizel->cx;
pt.y = psizel->cy;
hdc = GetDC(NULL);
if (hdc)
{
mmOld = SetMapMode(hdc, MM_HIMETRIC);
if (!g_fRunningOnNT) // if running on Win95
{
// Win95 doesn't like coordinates over 32K
// SHRT_MIN and SHRT_MAX defined in $NT/public/sdk/inc/crt/limits.h
while (pt.x > SHRT_MAX || pt.x < SHRT_MIN)
{
pt.x >>= 1;
nScaleFactorX <<= 1;
}
while (pt.y > SHRT_MAX || pt.y < SHRT_MIN)
{
pt.y >>= 1;
nScaleFactorY <<= 1;
}
}
LPtoDP(hdc, &pt, 1);
if (!g_fRunningOnNT)
{
pt.x *= nScaleFactorX;
pt.y *= nScaleFactorY;
}
pt.y = -pt.y;
SetMapMode(hdc, mmOld);
ReleaseDC(NULL, hdc);
}
rc.left = _rcPos.left;
rc.right = rc.left + pt.x;
rc.top = _rcPos.top;
rc.bottom = rc.top + pt.y;
// Assume that using SetExtent adjusts both the pos and clip rects
return SetObjectRects(&rc, NULL);
}
else
{
return S_OK;
}
}
HRESULT CShellEmbedding::GetExtent(DWORD dwDrawAspect, SIZEL *psizel)
{
*psizel = _sizeHIM;
return S_OK;
}
HRESULT CShellEmbedding::Advise(IAdviseSink *pAdvSink, DWORD *pdwConnection)
{
IOOMSG2(TEXT("Advise"), pAdvSink);
HRESULT hr = E_INVALIDARG;
if (!pdwConnection)
return hr;
*pdwConnection = NULL; // set out params to NULL
if (!_poah)
hr = ::CreateOleAdviseHolder(&_poah);
else
hr = NOERROR;
if( SUCCEEDED(hr) )
hr = _poah->Advise(pAdvSink, pdwConnection);
return(hr);
}
HRESULT CShellEmbedding::Unadvise(DWORD dwConnection)
{
IOOMSG(TEXT("Unadvise"));
HRESULT hr;
if (!_poah)
return(OLE_E_NOCONNECTION);
hr = _poah->Unadvise(dwConnection);
return(hr);
}
HRESULT CShellEmbedding::EnumAdvise(IEnumSTATDATA **ppenumAdvise)
{
IOOMSG(TEXT("EnumAdvise"));
HRESULT hr;
if (!ppenumAdvise)
return(E_INVALIDARG);
if (!_poah)
{
*ppenumAdvise = NULL;
hr = S_OK;
}
else
{
hr = _poah->EnumAdvise(ppenumAdvise);
}
return(hr);
}
HRESULT CShellEmbedding::GetMiscStatus(DWORD dwAspect, DWORD *pdwStatus)
{
IOOMSG(TEXT("GetMiscStatus"));
*pdwStatus = OLEMISCFLAGSOFCONTROL(this);
return S_OK;
}
HRESULT CShellEmbedding::SetColorScheme(LOGPALETTE *pLogpal)
{
IOOMSG(TEXT("GetColorScheme"));
return S_OK;
}
//
// Helper function to create an HDC from an OLE DVTARGETDEVICE structure.
// Very useful for metafile drawing, where the Metafile DC will be the
// actual "draw to" dc, and the TargetDC, if present, will describe the ultimate output device.
//
HDC CShellEmbedding::_OleStdCreateDC(DVTARGETDEVICE *ptd)
{
HDC hdc = NULL;
LPDEVNAMES lpDevNames = NULL;
LPDEVMODEA lpDevMode = NULL;
LPSTR lpszDriverName = NULL;
LPSTR lpszDeviceName = NULL;
LPSTR lpszPortName = NULL;
if (ptd)
{
lpDevNames = (LPDEVNAMES) ptd;
if (ptd->tdExtDevmodeOffset)
{
lpDevMode = (LPDEVMODEA) ( (LPSTR) ptd + ptd->tdExtDevmodeOffset);
}
lpszDriverName = (LPSTR) lpDevNames + ptd->tdDriverNameOffset;
lpszDeviceName = (LPSTR) lpDevNames + ptd->tdDeviceNameOffset;
lpszPortName = (LPSTR) lpDevNames + ptd->tdPortNameOffset;
hdc = CreateDCA(lpszDriverName, lpszDeviceName, lpszPortName, lpDevMode);
}
return hdc;
}
// *** IDataObject ***
//
// WARNING:
// It is well-known fact that Word and Excel (in Office95) does not call
// IViewObject::Draw to draw embedding. Instead, they GetData(CF_METAFILEPICT).
// If we don't offer it, Word will fail to embed it and Excel will draw
// white rectangle when our object is deactivated. To be embedded correctly
// on those apps, we must support CF_METAFILEPICT. (SatoNa)
//
HRESULT CShellEmbedding::GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
{
IDTMSG4(TEXT("GetData"), pformatetcIn->cfFormat, pformatetcIn->tymed);
HRESULT hres = DV_E_FORMATETC;
HDC hdcTargetDevice = NULL;
HENHMETAFILE hemf = NULL;
// If a Target device is specified in the FORMATETC structure, create a DC for it.
// This gets passed to CreateEnhMetaFile and IViewObject::Draw.
//
if (pformatetcIn->ptd)
{
hdcTargetDevice = _OleStdCreateDC(pformatetcIn->ptd);
if (!hdcTargetDevice)
{
return E_FAIL;
}
}
// Enhanced metafiles need special processing.
//
if (pformatetcIn->cfFormat == CF_ENHMETAFILE
&& (pformatetcIn->tymed & TYMED_ENHMF))
{
if (_hwnd)
{
RECTL rectBounds = { 0, 0, _sizeHIM.cx, _sizeHIM.cy };
//
// Call the "A" version since we're not passing in strings and
// this needs to work on W95.
HDC hdc = CreateEnhMetaFileA(hdcTargetDevice, NULL, (RECT*)&rectBounds, NULL);
IDTMSG3(TEXT("_EnhMetafileFromWindow CreateEnhMetaFile returned"), hdc);
if (hdc)
{
SetMapMode(hdc, MM_HIMETRIC);
rectBounds.bottom = -rectBounds.bottom;
Draw(DVASPECT_CONTENT, LINDEX_INTERNAL, NULL, pformatetcIn->ptd,
hdcTargetDevice, hdc, &rectBounds, NULL, NULL, 0);
hemf = CloseEnhMetaFile(hdc);
IDTMSG3(TEXT("_EnhMetafileFromWindow CloseEnhMetaFile returned"), hemf);
}
}
pmedium->hEnhMetaFile = hemf;
if (pmedium->hEnhMetaFile)
{
pmedium->tymed = TYMED_ENHMF;
pmedium->pUnkForRelease = NULL;
hres = S_OK;
}
else
{
hres = E_FAIL;
}
}
// Create a standard metafile
//
else if (pformatetcIn->cfFormat == CF_METAFILEPICT
&& (pformatetcIn->tymed & TYMED_MFPICT))
{
hres = E_OUTOFMEMORY;
HGLOBAL hmem = GlobalAlloc(GPTR, sizeof(METAFILEPICT));
if (hmem)
{
LPMETAFILEPICT pmf = (LPMETAFILEPICT) hmem;
RECTL rectBounds = { 0, 0, _sizeHIM.cx, _sizeHIM.cy };
HDC hdc = CreateMetaFile(NULL);
if (hdc)
{
SetMapMode(hdc, MM_HIMETRIC);
rectBounds.bottom = -rectBounds.bottom;
SetWindowOrgEx(hdc, 0, 0, NULL);
SetWindowExtEx(hdc, _sizeHIM.cx, _sizeHIM.cy, NULL);
Draw(DVASPECT_CONTENT, LINDEX_INTERNAL, NULL,
pformatetcIn->ptd, hdcTargetDevice,
hdc, &rectBounds, &rectBounds, NULL, 0);
pmf->hMF = CloseMetaFile(hdc);
if (pmf->hMF)
{
pmf->mm = MM_ANISOTROPIC;
pmf->xExt = _sizeHIM.cx;
pmf->yExt = _sizeHIM.cy;
TraceMsg(TF_SHDCONTROL, "sdv TR ::GetData (%d,%d)-(%d,%d)",
_size.cx, _size.cy, _sizeHIM.cx, _sizeHIM.cy);
pmedium->tymed = TYMED_MFPICT;
pmedium->hMetaFilePict = hmem;
pmedium->pUnkForRelease = NULL;
hres = S_OK;
}
}
if (FAILED(hres))
{
GlobalFree(hmem);
hmem = NULL;
}
}
}
if (hdcTargetDevice)
DeleteDC(hdcTargetDevice);
return hres;
}
HRESULT CShellEmbedding::GetDataHere(FORMATETC *pformatetc, STGMEDIUM *pmedium)
{
IDTMSG2(TEXT("GetDataHere"), pformatetc->cfFormat);
return E_NOTIMPL;
}
HRESULT CShellEmbedding::QueryGetData(FORMATETC *pformatetc)
{
IDTMSG2(TEXT("QueryGetData"), pformatetc->cfFormat);
HRESULT hres = S_FALSE;
if (pformatetc->cfFormat == CF_ENHMETAFILE
&& (pformatetc->tymed & TYMED_ENHMF))
{
hres = S_OK;
}
else if (pformatetc->cfFormat == CF_METAFILEPICT
&& (pformatetc->tymed & TYMED_MFPICT))
{
hres = S_OK;
}
return hres;
}
HRESULT CShellEmbedding::GetCanonicalFormatEtc(FORMATETC *pformatetcIn, FORMATETC *pformatetcOut)
{
IDTMSG2(TEXT("GetCanonicalFormatEtc"), pformatetcIn->cfFormat);
*pformatetcOut = *pformatetcIn;
return DATA_S_SAMEFORMATETC;
}
HRESULT CShellEmbedding::SetData(FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
{
IDTMSG(TEXT("SetData"));
return E_NOTIMPL;
}
HRESULT CShellEmbedding::EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppenumFormatEtc)
{
IDTMSG(TEXT("EnumFormatEtc"));
return E_NOTIMPL;
}
HRESULT CShellEmbedding::DAdvise(FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection)
{
IDTMSG(TEXT("DAdvise"));
HRESULT hr = E_INVALIDARG;
if (!pdwConnection)
return hr;
*pdwConnection = NULL; // set out params to NULL
if (!_pdah)
hr = ::CreateDataAdviseHolder(&_pdah);
else
hr = NOERROR;
if( SUCCEEDED(hr) )
hr = _pdah->Advise(this, pformatetc, advf, pAdvSink, pdwConnection);
return(hr);
}
HRESULT CShellEmbedding::DUnadvise(DWORD dwConnection)
{
IDTMSG(TEXT("DUnadvise"));
HRESULT hr;
if (!_pdah)
return(OLE_E_NOCONNECTION);
hr = _pdah->Unadvise(dwConnection);
return(hr);
}
HRESULT CShellEmbedding::EnumDAdvise(IEnumSTATDATA **ppenumAdvise)
{
IDTMSG(TEXT("EnumDAdvise"));
HRESULT hr;
if (!ppenumAdvise)
return(E_INVALIDARG);
if (!_pdah)
{
*ppenumAdvise = NULL;
hr = S_OK;
}
else
{
hr = _pdah->EnumAdvise(ppenumAdvise);
}
return(hr);
}
// *** IOleWindow ***
HRESULT CShellEmbedding::GetWindow(HWND * lphwnd)
{
*lphwnd = _hwnd;
return S_OK;
}
HRESULT CShellEmbedding::ContextSensitiveHelp(BOOL fEnterMode)
{
return S_OK;
}
// *** IOleInPlaceObject ***
HRESULT CShellEmbedding::InPlaceDeactivate(void)
{
IIPMSG(TEXT("InPlaceDeactivate"));
return _DoActivateChange(NULL, OC_DEACTIVE, FALSE);
}
HRESULT CShellEmbedding::UIDeactivate(void)
{
IIPMSG(TEXT("UIDeactivate"));
return _DoActivateChange(NULL, OC_INPLACEACTIVE, FALSE);
}
HRESULT CShellEmbedding::SetObjectRects(LPCRECT lprcPosRect, LPCRECT lprcClipRect)
{
RECT rcVisible;
_rcPos = *lprcPosRect;
if (lprcClipRect)
{
_rcClip = *lprcClipRect;
}
else
{
_rcClip = _rcPos;
}
IntersectRect(&rcVisible, &_rcPos, &_rcClip);
if (EqualRect(&rcVisible, &_rcPos))
{
if (_fUsingWindowRgn)
{
SetWindowRgn(_hwnd, NULL, TRUE);
_fUsingWindowRgn = FALSE;
}
}
else
{
_fUsingWindowRgn = TRUE;
OffsetRect(&rcVisible, -_rcPos.left, -_rcPos.top);
SetWindowRgn(_hwnd,
CreateRectRgnIndirect(&rcVisible),
TRUE);
}
// We should consider this equivalent to a SetExtent as well...
// But only for valid sizes (html viewer gives us invalid
// sizes during it's reformat routine). Note: we still need
// the SetWindowPos because we may move off the window.
int cx = _rcPos.right - _rcPos.left;
int cy = _rcPos.bottom - _rcPos.top;
TraceMsg(TF_SHDCONTROL, "she SetObjectRects to x=%d y=%d cx=%d cy=%d (from cx=%d cy=%d)", _rcPos.left, _rcPos.top, cx, cy, _size.cx, _size.cy);
if (cx >= 0 && cy >= 0)
{
_size.cx = cx;
_size.cy = cy;
}
if (_hwnd)
{
SetWindowPos(_hwnd, NULL,
_rcPos.left, _rcPos.top,
_size.cx,
_size.cy,
SWP_NOZORDER | SWP_NOACTIVATE);
}
return S_OK;
}
HRESULT CShellEmbedding::ReactivateAndUndo(void)
{
IIPMSG(TEXT("ReactivateAndUndo"));
return INPLACE_E_NOTUNDOABLE;
}
// *** IOleInPlaceActiveObject ***
HRESULT CShellEmbedding::TranslateAccelerator(LPMSG lpmsg)
{
extern BOOL IsVK_TABCycler(MSG * pMsg);
HRESULT hr = S_FALSE;
// IIAMSG(TEXT("TranslateAccelerator"));
// We have no accelerators (other than TAB, which we must pass up
// to IOCS::TA to move on to the next control if any)
if (IsVK_TABCycler(lpmsg)) {
// NOTE: grfMods?
hr = IUnknown_TranslateAcceleratorOCS(_pcli, lpmsg, /*grfMods*/ 0);
}
return hr;
}
HRESULT CShellEmbedding::OnFrameWindowActivate(BOOL fActivate)
{
IIAMSG(TEXT("OnFrameWindowActivate"));
if (fActivate)
{
// our frame has been activated and we are the active object
// make sure we have focus
SetFocus(_hwnd);
}
return S_OK;
}
HRESULT CShellEmbedding::OnDocWindowActivate(BOOL fActivate)
{
IIAMSG(TEXT("OnDocWindowActivate"));
// We don't care
return S_OK;
}
HRESULT CShellEmbedding::ResizeBorder(LPCRECT prcBorder,
IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow)
{
IIAMSG(TEXT("ResizeBorder"));
// We have no toolbars.
return S_OK;
}
HRESULT CShellEmbedding::EnableModeless(BOOL fEnable)
{
IIAMSG(TEXT("EnableModeless"));
// We have no dialogs.
return S_OK;
}
void CShellEmbedding::_RegisterWindowClass(void)
{
WNDCLASS wc = {0};
wc.style = CS_DBLCLKS;
wc.lpfnWndProc = s_WndProc ;
//wc.cbClsExtra = 0;
wc.cbWndExtra = SIZEOF(CShellEmbedding*) * 2;
wc.hInstance = g_hinst ;
//wc.hIcon = NULL ;
wc.hCursor = LoadCursor(NULL, IDC_ARROW) ;
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
//wc.lpszMenuName = NULL ;
wc.lpszClassName = c_szShellEmbedding;
SHRegisterClass(&wc);
}
LRESULT CShellEmbedding::v_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_NCCREATE:
DWORD dwExStyles;
if ((dwExStyles = GetWindowLong(hwnd, GWL_EXSTYLE)) & RTL_MIRRORED_WINDOW)
{
SetWindowLong(hwnd, GWL_EXSTYLE, dwExStyles &~ RTL_MIRRORED_WINDOW);
}
goto DoDefault;
case WM_SETFOCUS:
if (_hwndChild)
SetFocus(_hwndChild);
// If this SETFOCUS came from TABbing onto the control, VB5 expects us to call its
// IOleControlSite::OnFocus. Then it will UIActivate us.
//
IUnknown_OnFocusOCS(_pcli, TRUE);
break;
case WM_KILLFOCUS:
// If this KILLFOCUS came from TABbing off the control, VB5 expects us to call its
// IOleControlSite::OnFocus. Then it will UIDeactivate us.
//
IUnknown_OnFocusOCS(_pcli, FALSE);
break;
case WM_WINDOWPOSCHANGED:
if (_hwndChild)
{
LPWINDOWPOS lpwp = (LPWINDOWPOS)lParam;
if (!(lpwp->flags & SWP_NOSIZE))
{
SetWindowPos(_hwndChild, NULL,
0, 0, lpwp->cx, lpwp->cy,
SWP_NOZORDER|SWP_NOMOVE|SWP_NOACTIVATE|
(lpwp->flags&(SWP_NOREDRAW|SWP_NOCOPYBITS)));
}
}
goto DoDefault;
#ifdef DEBUG
// FEATURE: we'll never get this with ShellExplorer OC, but if we did,
// we'd need to call _DoActivateChange(OC_UIACTIVE, FALSE);
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
TraceMsg(TF_SHDCONTROL, "she ::v_WndProc(WM_xBUTTONDOWN) - we need to UIActivate");
goto DoDefault;
#endif
default:
DoDefault:
return DefWindowProc(_hwnd, uMsg, wParam, lParam);
}
return 0L;
}
void CShellEmbedding::_ViewChange(DWORD dwAspect, LONG lindex)
{
dwAspect &= _asp;
if (dwAspect && _padv)
{
IAdviseSink *padv = _padv;
IUnknown *punkRelease;
if (_advf & ADVF_ONLYONCE)
{
_padv = NULL;
punkRelease = padv;
}
else
punkRelease = NULL;
padv->OnViewChange(dwAspect, lindex);
if (punkRelease)
punkRelease->Release();
}
}
void CShellEmbedding::_SendAdvise(UINT uCode)
{
DWORD dwAspect=DVASPECT_CONTENT | DVASPECT_THUMBNAIL;
switch (uCode)
{
case OBJECTCODE_SAVED:
if (NULL!=_poah)
_poah->SendOnSave();
break;
case OBJECTCODE_CLOSED:
if (NULL!=_poah)
_poah->SendOnClose();
break;
case OBJECTCODE_RENAMED:
//Call IOleAdviseHolder::SendOnRename (later)
break;
case OBJECTCODE_SAVEOBJECT:
if (_fDirty && NULL!=_pcli)
_pcli->SaveObject();
_fDirty=FALSE;
break;
case OBJECTCODE_DATACHANGED:
// _fDirty=TRUE;
//No flags are necessary here.
if (NULL!=_pdah)
_pdah->SendOnDataChange(this, 0, 0);
//
// fall through
//
case OBJECTCODE_VIEWCHANGED:
_ViewChange(dwAspect, -1);
break;
case OBJECTCODE_SHOWOBJECT:
if (NULL!=_pcli)
_pcli->ShowObject();
break;
}
}
HRESULT CSVVerb::QueryInterface(REFIID riid, LPVOID * ppvObj)
{
if (IsEqualIID(riid, IID_IEnumOLEVERB) || IsEqualIID(riid, IID_IUnknown))
{
*ppvObj = SAFECAST(this, IEnumOLEVERB*);
}
else
{
*ppvObj = NULL;
return E_NOINTERFACE;
}
_cRef++;
return S_OK;
}
ULONG CSVVerb::AddRef()
{
return ++_cRef;
}
ULONG CSVVerb::Release()
{
if (--_cRef > 0) {
return _cRef;
}
delete this;
return 0;
}
HRESULT CSVVerb::Next(
/* [in] */ ULONG celt,
/* [out] */ LPOLEVERB rgelt,
/* [out] */ ULONG *pceltFetched)
{
HRESULT hres = S_FALSE;
ULONG celtFetched = 0;
// We need to enumerate the predefined verbs we support,
// or some containers will never call them. This list
// of verbs comes from our ::DoVerb function
//
static const OLEVERB rgVerbs[5] =
{
{OLEIVERB_PRIMARY, NULL, 0, 0},
{OLEIVERB_INPLACEACTIVATE, NULL, 0, 0},
{OLEIVERB_UIACTIVATE, NULL, 0, 0},
{OLEIVERB_SHOW, NULL, 0, 0},
{OLEIVERB_HIDE, NULL, 0, 0}
};
if (_iCur < ARRAYSIZE(rgVerbs))
{
IEVMSG(TEXT("Next"), celt, _iCur, TEXT("OLEIVERB_..."));
*rgelt = rgVerbs[_iCur++];
hres = S_OK;
}
else if (_pverbs)
{
int iCur = _iCur - ARRAYSIZE(rgVerbs);
IEVMSG(TEXT("Next"), celt, _iCur, _pverbs[iCur].lpszVerbName);
//
// FEATURE: Should we do while(celt--)?
//
if (_pverbs[iCur].lpszVerbName)
{
*rgelt = _pverbs[_iCur++];
WCHAR* pwszVerb = (WCHAR *)CoTaskMemAlloc(128 * sizeof(WCHAR));
if (pwszVerb)
{
MLLoadStringW(PtrToUint(_pverbs[iCur].lpszVerbName), pwszVerb, 128);
rgelt->lpszVerbName = pwszVerb;
celtFetched++;
hres = S_OK;
}
else
{
hres = E_OUTOFMEMORY;
}
}
}
if (pceltFetched) {
*pceltFetched = celtFetched;
}
return hres;
}
HRESULT CSVVerb::Skip(ULONG celt)
{
return S_OK;
}
HRESULT CSVVerb::Reset( void)
{
_iCur = 0;
return S_OK;
}
HRESULT CSVVerb::Clone(IEnumOLEVERB **ppenum)
{
*ppenum = new CSVVerb(_pverbs);
return *ppenum ? S_OK : E_OUTOFMEMORY;
}
Reference in a new issue Copy permalink