windows-nt/Source/XPSP1/NT/public/sdk/inc/atl21/atlctl.cpp

1172 lines
33 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
// This is a part of the Active Template Library.
// Copyright (C) 1996-1997 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Active Template Library Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Active Template Library product.
#ifndef ATL_NO_NAMESPACE
namespace ATL
{
#endif
/////////////////////////////////////////////////////////////////////////////
// CComDispatchDriver support
HRESULT CComDispatchDriver::GetProperty(IDispatch* pDisp, DISPID dwDispID,
VARIANT* pVar)
{
ATLTRACE(_T("CPropertyHelper::GetProperty\n"));
DISPPARAMS dispparamsNoArgs = {NULL, NULL, 0, 0};
return pDisp->Invoke(dwDispID, IID_NULL,
LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET,
&dispparamsNoArgs, pVar, NULL, NULL);
}
HRESULT CComDispatchDriver::PutProperty(IDispatch* pDisp, DISPID dwDispID,
VARIANT* pVar)
{
ATLTRACE(_T("CPropertyHelper::PutProperty\n"));
DISPPARAMS dispparams = {NULL, NULL, 1, 1};
dispparams.rgvarg = pVar;
DISPID dispidPut = DISPID_PROPERTYPUT;
dispparams.rgdispidNamedArgs = &dispidPut;
if (pVar->vt == VT_UNKNOWN || pVar->vt == VT_DISPATCH ||
(pVar->vt & VT_ARRAY) || (pVar->vt & VT_BYREF))
{
HRESULT hr = pDisp->Invoke(dwDispID, IID_NULL,
LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUTREF,
&dispparams, NULL, NULL, NULL);
if (SUCCEEDED(hr))
return hr;
}
return pDisp->Invoke(dwDispID, IID_NULL,
LOCALE_USER_DEFAULT, DISPATCH_PROPERTYPUT,
&dispparams, NULL, NULL, NULL);
}
//////////////////////////////////////////////////////////////////////////////
// CFirePropNotifyEvent
HRESULT CFirePropNotifyEvent::FireOnRequestEdit(IUnknown* pUnk, DISPID dispID)
{
CComQIPtr<IConnectionPointContainer, &IID_IConnectionPointContainer> pCPC(pUnk);
if (!pCPC)
return S_OK;
CComPtr<IConnectionPoint> pCP;
pCPC->FindConnectionPoint(IID_IPropertyNotifySink, &pCP);
if (!pCP)
return S_OK;
CComPtr<IEnumConnections> pEnum;
if (FAILED(pCP->EnumConnections(&pEnum)))
return S_OK;
CONNECTDATA cd;
while (pEnum->Next(1, &cd, NULL) == S_OK)
{
if (cd.pUnk)
{
HRESULT hr = S_OK;
CComQIPtr<IPropertyNotifySink, &IID_IPropertyNotifySink> pSink(cd.pUnk);
if (pSink)
hr = pSink->OnRequestEdit(dispID);
cd.pUnk->Release();
if (hr == S_FALSE)
return S_FALSE;
}
}
return S_OK;
}
HRESULT CFirePropNotifyEvent::FireOnChanged(IUnknown* pUnk, DISPID dispID)
{
CComQIPtr<IConnectionPointContainer, &IID_IConnectionPointContainer> pCPC(pUnk);
if (!pCPC)
return S_OK;
CComPtr<IConnectionPoint> pCP;
pCPC->FindConnectionPoint(IID_IPropertyNotifySink, &pCP);
if (!pCP)
return S_OK;
CComPtr<IEnumConnections> pEnum;
if (FAILED(pCP->EnumConnections(&pEnum)))
return S_OK;
CONNECTDATA cd;
while (pEnum->Next(1, &cd, NULL) == S_OK)
{
if (cd.pUnk)
{
CComQIPtr<IPropertyNotifySink, &IID_IPropertyNotifySink> pSink(cd.pUnk);
if (pSink)
pSink->OnChanged(dispID);
cd.pUnk->Release();
}
}
return S_OK;
}
/////////////////////////////////////////////////////////////////////////////
// Control support
HRESULT CComControlBase::IQuickActivate_QuickActivate(QACONTAINER *pQACont,
QACONTROL *pQACtrl)
{
_ASSERTE(pQACont != NULL);
_ASSERTE(pQACtrl != NULL);
// _ASSERTE(pQACont->cbSize >= sizeof(QACONTAINER));
_ASSERTE(pQACtrl->cbSize >= sizeof(QACONTROL));
if (!pQACont || !pQACtrl)
return E_POINTER;
HRESULT hRes;
memset(pQACtrl, 0, sizeof(QACONTROL));
pQACtrl->cbSize = sizeof(QACONTROL);
// get all interfaces we are going to need
CComPtr<IOleObject> pOO;
ControlQueryInterface(IID_IOleObject, (void**)&pOO);
CComPtr<IViewObjectEx> pVOEX;
ControlQueryInterface(IID_IViewObjectEx, (void**)&pVOEX);
CComPtr<IPointerInactive> pPI;
ControlQueryInterface(IID_IPointerInactive, (void**)&pPI);
CComPtr<IProvideClassInfo2> pPCI;
ControlQueryInterface(IID_IProvideClassInfo2, (void**)&pPCI);
if (pOO == NULL || pVOEX == NULL)
return E_FAIL;
pOO->SetClientSite(pQACont->pClientSite);
if (pQACont->pAdviseSink != NULL)
{
ATLTRACE(_T("Setting up IOleObject Advise\n"));
pVOEX->SetAdvise(DVASPECT_CONTENT, 0, pQACont->pAdviseSink);
}
CComPtr<IConnectionPointContainer> pCPC;
ControlQueryInterface(IID_IConnectionPointContainer, (void**)&pCPC);
if (pQACont->pPropertyNotifySink)
{
ATLTRACE(_T("Setting up PropNotify CP\n"));
CComPtr<IConnectionPoint> pCP;
if (pCPC != NULL)
{
hRes = pCPC->FindConnectionPoint(IID_IPropertyNotifySink, &pCP);
if (SUCCEEDED(hRes))
pCP->Advise(pQACont->pPropertyNotifySink, &pQACtrl->dwPropNotifyCookie);
}
}
if (pPCI)
{
GUID iidDefaultSrc;
if (SUCCEEDED(pPCI->GetGUID(GUIDKIND_DEFAULT_SOURCE_DISP_IID,
&iidDefaultSrc)))
{
if (pQACont->pUnkEventSink)
{
ATLTRACE(_T("Setting up Default Out Going Interface\n"));
CComPtr<IConnectionPoint> pCP;
if (pCPC != NULL)
{
hRes = pCPC->FindConnectionPoint(iidDefaultSrc, &pCP);
if (SUCCEEDED(hRes))
pCP->Advise(pQACont->pUnkEventSink, &pQACtrl->dwEventCookie);
}
}
}
}
// give information to container
if (pOO != NULL)
pOO->GetMiscStatus(DVASPECT_CONTENT, &pQACtrl->dwMiscStatus);
if (pVOEX != NULL)
pVOEX->GetViewStatus(&pQACtrl->dwViewStatus);
if (pPI != NULL)
pPI->GetActivationPolicy(&pQACtrl->dwPointerActivationPolicy);
return S_OK;
}
HRESULT CComControlBase::IPersistPropertyBag_Load(LPPROPERTYBAG pPropBag,
LPERRORLOG pErrorLog, ATL_PROPMAP_ENTRY* pMap)
{
USES_CONVERSION;
CComPtr<IDispatch> pDispatch;
const IID* piidOld = NULL;
for(int i = 0; pMap[i].pclsidPropPage != NULL; i++)
{
if (pMap[i].szDesc == NULL)
continue;
CComVariant var;
if(pMap[i].piidDispatch != piidOld)
{
pDispatch.Release();
if(FAILED(ControlQueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch)))
{
ATLTRACE(_T("Failed to get a dispatch pointer for property #%i\n"), i);
return E_FAIL;
}
piidOld = pMap[i].piidDispatch;
}
if (FAILED(CComDispatchDriver::GetProperty(pDispatch, pMap[i].dispid, &var)))
{
ATLTRACE(_T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
return E_FAIL;
}
HRESULT hr = pPropBag->Read(pMap[i].szDesc, &var, pErrorLog);
if (FAILED(hr))
{
if (hr == E_INVALIDARG)
{
ATLTRACE(_T("Property %s not in Bag\n"), OLE2CT(pMap[i].szDesc));
}
else
{
// Many containers return different ERROR values for Member not found
ATLTRACE(_T("Error attempting to read Property %s from PropertyBag \n"), OLE2CT(pMap[i].szDesc));
}
continue;
}
if (FAILED(CComDispatchDriver::PutProperty(pDispatch, pMap[i].dispid, &var)))
{
ATLTRACE(_T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
return E_FAIL;
}
}
return S_OK;
}
HRESULT CComControlBase::IPersistPropertyBag_Save(LPPROPERTYBAG pPropBag,
BOOL fClearDirty, BOOL /*fSaveAllProperties*/, ATL_PROPMAP_ENTRY* pMap)
{
if (pPropBag == NULL)
{
ATLTRACE(_T("PropBag pointer passed in was invalid\n"));
return E_POINTER;
}
CComPtr<IDispatch> pDispatch;
const IID* piidOld = NULL;
for(int i = 0; pMap[i].pclsidPropPage != NULL; i++)
{
if (pMap[i].szDesc == NULL)
continue;
CComVariant var;
if(pMap[i].piidDispatch != piidOld)
{
pDispatch.Release();
if(FAILED(ControlQueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch)))
{
ATLTRACE(_T("Failed to get a dispatch pointer for property #%i\n"), i);
return E_FAIL;
}
piidOld = pMap[i].piidDispatch;
}
if (FAILED(CComDispatchDriver::GetProperty(pDispatch, pMap[i].dispid, &var)))
{
ATLTRACE(_T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
return E_FAIL;
}
if (var.vt == VT_UNKNOWN || var.vt == VT_DISPATCH)
{
if (var.punkVal == NULL)
{
ATLTRACE(_T("Warning skipping empty IUnknown in Save\n"));
continue;
}
}
HRESULT hr = pPropBag->Write(pMap[i].szDesc, &var);
if (FAILED(hr))
return hr;
}
m_bRequiresSave = FALSE;
return S_OK;
}
HRESULT CComControlBase::ISpecifyPropertyPages_GetPages(CAUUID* pPages,
ATL_PROPMAP_ENTRY* pMap)
{
_ASSERTE(pMap != NULL);
int nCnt = 0;
// Get count of unique pages
for(int i = 0; pMap[i].pclsidPropPage != NULL; i++)
{
if (!InlineIsEqualGUID(*pMap[i].pclsidPropPage, CLSID_NULL))
nCnt++;
}
pPages->pElems = NULL;
pPages->pElems = (GUID*) CoTaskMemAlloc(sizeof(CLSID)*nCnt);
if (pPages->pElems == NULL)
return E_OUTOFMEMORY;
nCnt = 0;
for(i = 0; pMap[i].pclsidPropPage != NULL; i++)
{
if (!InlineIsEqualGUID(*pMap[i].pclsidPropPage, CLSID_NULL))
{
BOOL bMatch = FALSE;
for (int j=0;j<nCnt;j++)
{
if (InlineIsEqualGUID(*(pMap[i].pclsidPropPage), pPages->pElems[j]))
{
bMatch = TRUE;
break;
}
}
if (!bMatch)
pPages->pElems[nCnt++] = *pMap[i].pclsidPropPage;
}
}
pPages->cElems = nCnt;
return S_OK;
}
BOOL CComControlBase::SetControlFocus(BOOL bGrab)
{
if (m_bWndLess)
{
if (!m_bUIActive && bGrab)
if (FAILED(InPlaceActivate(OLEIVERB_UIACTIVATE)))
return FALSE;
return (m_spInPlaceSite->SetFocus(bGrab) == S_OK);
}
else
{
// we've got a window.
//
if (m_bInPlaceActive)
{
HWND hwnd = (bGrab) ? m_hWndCD : ::GetParent(m_hWndCD);
if (!m_bUIActive && bGrab)
return SUCCEEDED(InPlaceActivate(OLEIVERB_UIACTIVATE));
else
return (::SetFocus(hwnd) != NULL);
}
}
return FALSE;
}
HRESULT CComControlBase::DoVerbProperties(LPCRECT /* prcPosRect */, HWND hwndParent)
{
HRESULT hr = S_OK;
CComQIPtr <ISpecifyPropertyPages, &IID_ISpecifyPropertyPages> spPages;
CComQIPtr <IOleObject, &IID_IOleObject> spObj;
CComQIPtr <IOleControlSite, &IID_IOleControlSite> spSite(m_spClientSite);
if (spSite)
{
hr = spSite->ShowPropertyFrame();
if (SUCCEEDED(hr))
return hr;
}
CComPtr<IUnknown> pUnk;
ControlQueryInterface(IID_IUnknown, (void**)&pUnk);
_ASSERTE(pUnk != NULL);
CAUUID pages;
spPages = pUnk;
if (spPages)
{
spPages->GetPages(&pages);
spObj = pUnk;
if (spObj)
{
LPOLESTR szTitle = NULL;
spObj->GetUserType(USERCLASSTYPE_SHORT, &szTitle);
hr = OleCreatePropertyFrame(hwndParent, m_rcPos.top, m_rcPos.left, szTitle,
1, &pUnk.p, pages.cElems, pages.pElems, LOCALE_USER_DEFAULT, 0, 0);
CoTaskMemFree(szTitle);
}
else
{
hr = OLEOBJ_S_CANNOT_DOVERB_NOW;
}
}
else
{
hr = OLEOBJ_S_CANNOT_DOVERB_NOW;
}
return hr;
}
HRESULT CComControlBase::InPlaceActivate(LONG iVerb, const RECT* prcPosRect)
{
HRESULT hr;
if (m_spClientSite == NULL)
return S_OK;
CComPtr<IOleInPlaceObject> pIPO;
ControlQueryInterface(IID_IOleInPlaceObject, (void**)&pIPO);
_ASSERTE(pIPO != NULL);
if (prcPosRect != NULL)
pIPO->SetObjectRects(prcPosRect, prcPosRect);
if (!m_bNegotiatedWnd)
{
if (!m_bWindowOnly)
// Try for windowless site
hr = m_spClientSite->QueryInterface(IID_IOleInPlaceSiteWindowless, (void **)&m_spInPlaceSite);
if (m_spInPlaceSite)
{
m_bInPlaceSiteEx = TRUE;
m_bWndLess = SUCCEEDED(m_spInPlaceSite->CanWindowlessActivate());
m_bWasOnceWindowless = TRUE;
}
else
{
m_spClientSite->QueryInterface(IID_IOleInPlaceSiteEx, (void **)&m_spInPlaceSite);
if (m_spInPlaceSite)
m_bInPlaceSiteEx = TRUE;
else
hr = m_spClientSite->QueryInterface(IID_IOleInPlaceSite, (void **)&m_spInPlaceSite);
}
}
_ASSERTE(m_spInPlaceSite);
if (!m_spInPlaceSite)
return E_FAIL;
m_bNegotiatedWnd = TRUE;
if (!m_bInPlaceActive)
{
BOOL bNoRedraw = FALSE;
if (m_bWndLess)
m_spInPlaceSite->OnInPlaceActivateEx(&bNoRedraw, ACTIVATE_WINDOWLESS);
else
{
if (m_bInPlaceSiteEx)
m_spInPlaceSite->OnInPlaceActivateEx(&bNoRedraw, 0);
else
{
HRESULT hr = m_spInPlaceSite->CanInPlaceActivate();
if (FAILED(hr))
return hr;
m_spInPlaceSite->OnInPlaceActivate();
}
}
}
m_bInPlaceActive = TRUE;
// get location in the parent window,
// as well as some information about the parent
//
OLEINPLACEFRAMEINFO frameInfo;
RECT rcPos, rcClip;
CComPtr<IOleInPlaceFrame> spInPlaceFrame;
CComPtr<IOleInPlaceUIWindow> spInPlaceUIWindow;
frameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
HWND hwndParent;
if (m_spInPlaceSite->GetWindow(&hwndParent) == S_OK)
{
m_spInPlaceSite->GetWindowContext(&spInPlaceFrame,
&spInPlaceUIWindow, &rcPos, &rcClip, &frameInfo);
if (!m_bWndLess)
{
if (m_hWndCD)
{
ShowWindow(m_hWndCD, SW_SHOW);
SetFocus(m_hWndCD);
}
else
{
HWND h = CreateControlWindow(hwndParent, rcPos);
_ASSERTE(h == m_hWndCD);
}
}
pIPO->SetObjectRects(&rcPos, &rcClip);
}
CComPtr<IOleInPlaceActiveObject> spActiveObject;
ControlQueryInterface(IID_IOleInPlaceActiveObject, (void**)&spActiveObject);
// Gone active by now, take care of UIACTIVATE
if (DoesVerbUIActivate(iVerb))
{
if (!m_bUIActive)
{
m_bUIActive = TRUE;
hr = m_spInPlaceSite->OnUIActivate();
if (FAILED(hr))
return hr;
SetControlFocus(TRUE);
// set ourselves up in the host.
//
if (spActiveObject)
{
if (spInPlaceFrame)
spInPlaceFrame->SetActiveObject(spActiveObject, NULL);
if (spInPlaceUIWindow)
spInPlaceUIWindow->SetActiveObject(spActiveObject, NULL);
}
if (spInPlaceFrame)
spInPlaceFrame->SetBorderSpace(NULL);
if (spInPlaceUIWindow)
spInPlaceUIWindow->SetBorderSpace(NULL);
}
}
m_spClientSite->ShowObject();
return S_OK;
}
HRESULT CComControlBase::IPersistStreamInit_Load(LPSTREAM pStm, ATL_PROPMAP_ENTRY* pMap)
{
_ASSERTE(pMap != NULL);
HRESULT hr = S_OK;
DWORD dwVer;
hr = pStm->Read(&dwVer, sizeof(DWORD), NULL);
if (SUCCEEDED(hr) && dwVer <= _ATL_VER)
hr = pStm->Read(&m_sizeExtent, sizeof(m_sizeExtent), NULL);
if (FAILED(hr))
return hr;
CComPtr<IDispatch> pDispatch;
const IID* piidOld = NULL;
for(int i = 0; pMap[i].pclsidPropPage != NULL; i++)
{
if (pMap[i].szDesc == NULL)
continue;
CComVariant var;
HRESULT hr = var.ReadFromStream(pStm);
if (FAILED(hr))
break;
if(pMap[i].piidDispatch != piidOld)
{
if(FAILED(ControlQueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch)))
{
ATLTRACE(_T("Failed to get a dispatch pointer for property #%i\n"), i);
hr = E_FAIL;
break;
}
piidOld = pMap[i].piidDispatch;
}
if (FAILED(CComDispatchDriver::PutProperty(pDispatch, pMap[i].dispid, &var)))
{
ATLTRACE(_T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
hr = E_FAIL;
break;
}
}
return hr;
}
HRESULT CComControlBase::IPersistStreamInit_Save(LPSTREAM pStm, BOOL /* fClearDirty */, ATL_PROPMAP_ENTRY* pMap)
{
_ASSERTE(pMap != NULL);
DWORD dw = _ATL_VER;
HRESULT hr = pStm->Write(&dw, sizeof(DWORD), NULL);
if (FAILED(hr))
return hr;
hr = pStm->Write(&m_sizeExtent, sizeof(m_sizeExtent), NULL);
if (FAILED(hr))
return hr;
CComPtr<IDispatch> pDispatch;
const IID* piidOld = NULL;
for(int i = 0; pMap[i].pclsidPropPage != NULL; i++)
{
if (pMap[i].szDesc == NULL)
continue;
CComVariant var;
if(pMap[i].piidDispatch != piidOld)
{
if(FAILED(ControlQueryInterface(*pMap[i].piidDispatch, (void**)&pDispatch)))
{
ATLTRACE(_T("Failed to get a dispatch pointer for property #%i\n"), i);
hr = E_FAIL;
break;
}
piidOld = pMap[i].piidDispatch;
}
if (FAILED(CComDispatchDriver::GetProperty(pDispatch, pMap[i].dispid, &var)))
{
ATLTRACE(_T("Invoked failed on DISPID %x\n"), pMap[i].dispid);
hr = E_FAIL;
break;
}
HRESULT hr = var.WriteToStream(pStm);
if (FAILED(hr))
break;
}
if (SUCCEEDED(hr))
m_bRequiresSave = FALSE;
return hr;
}
HRESULT CComControlBase::SendOnDataChange(DWORD advf)
{
HRESULT hRes = S_OK;
if (m_spDataAdviseHolder)
{
CComPtr<IDataObject> pdo;
if (SUCCEEDED(ControlQueryInterface(IID_IDataObject, (void**)&pdo)))
hRes = m_spDataAdviseHolder->SendOnDataChange(pdo, 0, advf);
}
return hRes;
}
HRESULT CComControlBase::IOleObject_SetClientSite(IOleClientSite *pClientSite)
{
_ASSERTE(pClientSite == NULL || m_spClientSite == NULL);
m_spClientSite = pClientSite;
m_spAmbientDispatch.Release();
if (m_spClientSite != NULL)
{
m_spClientSite->QueryInterface(IID_IDispatch,
(void**) &m_spAmbientDispatch.p);
}
return S_OK;
}
HRESULT CComControlBase::IOleObject_GetClientSite(IOleClientSite **ppClientSite)
{
_ASSERTE(ppClientSite);
HRESULT hRes = E_POINTER;
if (ppClientSite != NULL)
{
*ppClientSite = m_spClientSite;
if (m_spClientSite)
m_spClientSite->AddRef();
hRes = S_OK;
}
return hRes;
}
HRESULT CComControlBase::IOleObject_Advise(IAdviseSink *pAdvSink,
DWORD *pdwConnection)
{
HRESULT hr = S_OK;
if (m_spOleAdviseHolder == NULL)
hr = CreateOleAdviseHolder(&m_spOleAdviseHolder);
if (SUCCEEDED(hr))
hr = m_spOleAdviseHolder->Advise(pAdvSink, pdwConnection);
return hr;
}
HRESULT CComControlBase::IOleObject_Close(DWORD dwSaveOption)
{
CComPtr<IOleInPlaceObject> pIPO;
ControlQueryInterface(IID_IOleInPlaceObject, (void**)&pIPO);
_ASSERTE(pIPO != NULL);
if (m_hWndCD)
{
if (m_spClientSite)
m_spClientSite->OnShowWindow(FALSE);
}
if (m_bInPlaceActive)
{
HRESULT hr = pIPO->InPlaceDeactivate();
if (FAILED(hr))
return hr;
_ASSERTE(!m_bInPlaceActive);
}
if (m_hWndCD)
{
ATLTRACE(_T("Destroying Window\n"));
if (::IsWindow(m_hWndCD))
DestroyWindow(m_hWndCD);
m_hWndCD = NULL;
}
// handle the save flag.
//
if ((dwSaveOption == OLECLOSE_SAVEIFDIRTY ||
dwSaveOption == OLECLOSE_PROMPTSAVE) && m_bRequiresSave)
{
if (m_spClientSite)
m_spClientSite->SaveObject();
SendOnSave();
}
m_spInPlaceSite.Release();
m_bNegotiatedWnd = FALSE;
m_bWndLess = FALSE;
m_bInPlaceSiteEx = FALSE;
m_spAdviseSink.Release();
return S_OK;
}
HRESULT CComControlBase::IOleInPlaceObject_InPlaceDeactivate(void)
{
CComPtr<IOleInPlaceObject> pIPO;
ControlQueryInterface(IID_IOleInPlaceObject, (void**)&pIPO);
_ASSERTE(pIPO != NULL);
if (!m_bInPlaceActive)
return S_OK;
pIPO->UIDeactivate();
m_bInPlaceActive = FALSE;
// if we have a window, tell it to go away.
//
if (m_hWndCD)
{
ATLTRACE(_T("Destroying Window\n"));
if (::IsWindow(m_hWndCD))
DestroyWindow(m_hWndCD);
m_hWndCD = NULL;
}
if (m_spInPlaceSite)
m_spInPlaceSite->OnInPlaceDeactivate();
return S_OK;
}
HRESULT CComControlBase::IOleInPlaceObject_UIDeactivate(void)
{
// if we're not UIActive, not much to do.
//
if (!m_bUIActive)
return S_OK;
m_bUIActive = FALSE;
// notify frame windows, if appropriate, that we're no longer ui-active.
//
CComPtr<IOleInPlaceFrame> spInPlaceFrame;
CComPtr<IOleInPlaceUIWindow> spInPlaceUIWindow;
OLEINPLACEFRAMEINFO frameInfo;
frameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
RECT rcPos, rcClip;
HWND hwndParent;
// This call to GetWindow is a fix for Delphi
if (m_spInPlaceSite->GetWindow(&hwndParent) == S_OK)
{
m_spInPlaceSite->GetWindowContext(&spInPlaceFrame,
&spInPlaceUIWindow, &rcPos, &rcClip, &frameInfo);
if (spInPlaceUIWindow)
spInPlaceUIWindow->SetActiveObject(NULL, NULL);
if (spInPlaceFrame)
spInPlaceFrame->SetActiveObject(NULL, NULL);
}
// we don't need to explicitly release the focus here since somebody
// else grabbing the focus is what is likely to cause us to get lose it
//
m_spInPlaceSite->OnUIDeactivate(FALSE);
return S_OK;
}
HRESULT CComControlBase::IOleInPlaceObject_SetObjectRects(LPCRECT prcPos,LPCRECT prcClip)
{
if (prcPos == NULL || prcClip == NULL)
return E_POINTER;
m_rcPos = *prcPos;
if (m_hWndCD)
{
// the container wants us to clip, so figure out if we really
// need to
//
RECT rcIXect;
BOOL b = IntersectRect(&rcIXect, prcPos, prcClip);
HRGN tempRgn = NULL;
if (b && !EqualRect(&rcIXect, prcPos))
{
OffsetRect(&rcIXect, -(prcPos->left), -(prcPos->top));
tempRgn = CreateRectRgnIndirect(&rcIXect);
}
SetWindowRgn(m_hWndCD, tempRgn, TRUE);
// set our control's location, but don't change it's size at all
// [people for whom zooming is important should set that up here]
//
SIZEL size = {prcPos->right - prcPos->left, prcPos->bottom - prcPos->top};
SetWindowPos(m_hWndCD, NULL, prcPos->left,
prcPos->top, size.cx, size.cy, SWP_NOZORDER | SWP_NOACTIVATE);
}
return S_OK;
}
HRESULT CComControlBase::IOleObject_SetExtent(DWORD dwDrawAspect, SIZEL *psizel)
{
if (dwDrawAspect != DVASPECT_CONTENT)
return DV_E_DVASPECT;
if (psizel == NULL)
return E_POINTER;
BOOL bSizeMatchesNatural =
memcmp(psizel, &m_sizeNatural, sizeof(SIZE)) == 0;
if (m_bAutoSize) //object can't do any other size
return (bSizeMatchesNatural) ? S_OK : E_FAIL;
BOOL bResized = FALSE;
if (memcmp(psizel, &m_sizeExtent, sizeof(SIZE)) != 0)
{
m_sizeExtent = *psizel;
bResized = TRUE;
}
if (m_bResizeNatural && !bSizeMatchesNatural)
{
m_sizeNatural = *psizel;
bResized = TRUE;
}
if (m_bRecomposeOnResize && bResized)
{
SendOnDataChange();
FireViewChange();
}
return S_OK;
}
HRESULT CComControlBase::IViewObject_Draw(DWORD dwDrawAspect, LONG lindex,
void *pvAspect, DVTARGETDEVICE *ptd, HDC hicTargetDev, HDC hdcDraw,
LPCRECTL prcBounds, LPCRECTL prcWBounds)
{
ATLTRACE(_T("Draw dwDrawAspect=%x lindex=%d ptd=%x hic=%x hdc=%x\n"),
dwDrawAspect, lindex, ptd, hicTargetDev, hdcDraw);
#ifdef _DEBUG
if (prcBounds == NULL)
ATLTRACE(_T("\tprcBounds=NULL\n"));
else
ATLTRACE(_T("\tprcBounds=%d,%d,%d,%d\n"), prcBounds->left,
prcBounds->top, prcBounds->right, prcBounds->bottom);
if (prcWBounds == NULL)
ATLTRACE(_T("\tprcWBounds=NULL\n"));
else
ATLTRACE(_T("\tprcWBounds=%d,%d,%d,%d\n"), prcWBounds->left,
prcWBounds->top, prcWBounds->right, prcWBounds->bottom);
#endif
_ASSERTE(prcBounds != NULL || m_bWndLess);
if (prcBounds == NULL)
{
if (!m_bWndLess)
return E_INVALIDARG;
prcBounds = (RECTL*)&m_rcPos;
}
// support the aspects required for multi-pass drawing
switch (dwDrawAspect)
{
case DVASPECT_CONTENT:
case DVASPECT_OPAQUE:
case DVASPECT_TRANSPARENT:
break;
default:
_ASSERTE(FALSE);
return DV_E_DVASPECT;
break;
}
// make sure nobody forgets to do this
if (ptd == NULL)
hicTargetDev = NULL;
BOOL bOptimize = FALSE;
if (pvAspect && ((DVASPECTINFO *)pvAspect)->cb >= sizeof(DVASPECTINFO))
bOptimize = (((DVASPECTINFO *)pvAspect)->dwFlags & DVASPECTINFOFLAG_CANOPTIMIZE);
ATL_DRAWINFO di;
memset(&di, 0, sizeof(di));
di.cbSize = sizeof(di);
di.dwDrawAspect = dwDrawAspect;
di.lindex = lindex;
di.ptd = ptd;
di.hicTargetDev = hicTargetDev;
di.hdcDraw = hdcDraw;
di.prcBounds = prcBounds;
di.prcWBounds = prcWBounds;
di.bOptimize = bOptimize;
return OnDrawAdvanced(di);
}
HRESULT CComControlBase::IDataObject_GetData(FORMATETC *pformatetcIn,
STGMEDIUM *pmedium)
{
if (pmedium == NULL)
return E_POINTER;
memset(pmedium, 0, sizeof(STGMEDIUM));
ATLTRACE(_T("Format = %x\n"), pformatetcIn->cfFormat);
ATLTRACE(_T("TYMED = %x\n"), pformatetcIn->tymed);
if ((pformatetcIn->tymed & TYMED_MFPICT) == 0)
return DATA_E_FORMATETC;
SIZEL sizeMetric, size;
if (m_bDrawFromNatural)
sizeMetric = m_sizeNatural;
else
sizeMetric = m_sizeExtent;
if (!m_bDrawGetDataInHimetric)
AtlHiMetricToPixel(&sizeMetric, &size);
else
size = sizeMetric;
RECTL rectl = {0 ,0, size.cx, size.cy};
ATL_DRAWINFO di;
memset(&di, 0, sizeof(di));
di.cbSize = sizeof(di);
di.dwDrawAspect = DVASPECT_CONTENT;
di.lindex = -1;
di.ptd = NULL;
di.hicTargetDev = NULL;
di.prcBounds = &rectl;
di.prcWBounds = &rectl;
di.bOptimize = TRUE; //we do a SaveDC/RestoreDC
di.bRectInHimetric = m_bDrawGetDataInHimetric;
// create appropriate memory metafile DC
di.hdcDraw = CreateMetaFile(NULL);
// create attribute DC according to pformatetcIn->ptd
SaveDC(di.hdcDraw);
SetWindowOrgEx(di.hdcDraw, 0, 0, NULL);
SetWindowExtEx(di.hdcDraw, rectl.right, rectl.bottom, NULL);
OnDrawAdvanced(di);
RestoreDC(di.hdcDraw, -1);
HMETAFILE hMF = CloseMetaFile(di.hdcDraw);
if (hMF == NULL)
return E_UNEXPECTED;
HGLOBAL hMem=GlobalAlloc(GMEM_SHARE | GMEM_MOVEABLE, sizeof(METAFILEPICT));
if (NULL==hMem)
{
DeleteMetaFile(hMF);
return ResultFromScode(STG_E_MEDIUMFULL);
}
LPMETAFILEPICT pMF=(LPMETAFILEPICT)GlobalLock(hMem);
pMF->hMF=hMF;
pMF->mm=MM_ANISOTROPIC;
pMF->xExt=sizeMetric.cx;
pMF->yExt=sizeMetric.cy;
GlobalUnlock(hMem);
pmedium->tymed = TYMED_MFPICT;
pmedium->hGlobal = hMem;
pmedium->pUnkForRelease = NULL;
return S_OK;
}
HRESULT CComControlBase::FireViewChange()
{
if (m_bInPlaceActive)
{
// Active
if (m_hWndCD != NULL)
return (::InvalidateRect(m_hWndCD, NULL, TRUE)) ? S_OK : E_FAIL; // Window based
if (m_spInPlaceSite != NULL)
return m_spInPlaceSite->InvalidateRect(NULL, TRUE); // Windowless
}
// Inactive
SendOnViewChange(DVASPECT_CONTENT);
return S_OK;
}
void CComControlBase::GetZoomInfo(ATL_DRAWINFO& di)
{
const RECTL& rcPos = *di.prcBounds;
SIZEL sizeDen;
if (m_bDrawFromNatural)
sizeDen = m_sizeNatural;
else
sizeDen = m_sizeExtent;
if (!di.bRectInHimetric)
AtlHiMetricToPixel(&sizeDen, &sizeDen);
SIZEL sizeNum = {rcPos.right-rcPos.left, rcPos.bottom-rcPos.top};
di.ZoomNum.cx = sizeNum.cx;
di.ZoomNum.cy = sizeNum.cy;
di.ZoomDen.cx = sizeDen.cx;
di.ZoomDen.cy = sizeDen.cy;
if (sizeDen.cx == 0 || sizeDen.cy == 0 ||
sizeNum.cx == 0 || sizeNum.cy == 0)
{
di.ZoomNum.cx = di.ZoomNum.cy = di.ZoomDen.cx = di.ZoomDen.cy = 1;
di.bZoomed = FALSE;
}
else if (sizeNum.cx != sizeDen.cx || sizeNum.cy != sizeDen.cy)
di.bZoomed = TRUE;
else
di.bZoomed = FALSE;
}
HRESULT CComControlBase::OnDrawAdvanced(ATL_DRAWINFO& di)
{
BOOL bDeleteDC = FALSE;
if (di.hicTargetDev == NULL)
{
di.hicTargetDev = AtlCreateTargetDC(di.hdcDraw, di.ptd);
bDeleteDC = (di.hicTargetDev != di.hdcDraw);
}
RECTL rectBoundsDP = *di.prcBounds;
BOOL bMetafile = GetDeviceCaps(di.hdcDraw, TECHNOLOGY) == DT_METAFILE;
if (!bMetafile)
{
::LPtoDP(di.hicTargetDev, (LPPOINT)&rectBoundsDP, 2);
SaveDC(di.hdcDraw);
SetMapMode(di.hdcDraw, MM_TEXT);
SetWindowOrgEx(di.hdcDraw, 0, 0, NULL);
SetViewportOrgEx(di.hdcDraw, 0, 0, NULL);
di.bOptimize = TRUE; //since we save the DC we can do this
}
di.prcBounds = &rectBoundsDP;
GetZoomInfo(di);
HRESULT hRes = OnDraw(di);
if (bDeleteDC)
::DeleteDC(di.hicTargetDev);
if (!bMetafile)
RestoreDC(di.hdcDraw, -1);
return hRes;
}
LRESULT CComControlBase::OnPaint(UINT /* nMsg */, WPARAM /* wParam */,
LPARAM /* lParam */, BOOL& /* lResult */)
{
RECT rc;
PAINTSTRUCT ps;
HDC hdc = ::BeginPaint(m_hWndCD, &ps);
if (hdc == NULL)
return 0;
::GetClientRect(m_hWndCD, &rc);
ATL_DRAWINFO di;
memset(&di, 0, sizeof(di));
di.cbSize = sizeof(di);
di.dwDrawAspect = DVASPECT_CONTENT;
di.lindex = -1;
di.hdcDraw = hdc;
di.prcBounds = (LPCRECTL)&rc;
OnDrawAdvanced(di);
::EndPaint(m_hWndCD, &ps);
return 0;
}
#ifndef ATL_NO_NAMESPACE
}; //namespace ATL
#endif
///////////////////////////////////////////////////////////////////////////////
//All Global stuff goes below this line
///////////////////////////////////////////////////////////////////////////////
#ifndef _ATL_DLL
ATLAPI_(HDC) AtlCreateTargetDC(HDC hdc, DVTARGETDEVICE* ptd)
{
USES_CONVERSION;
// cases hdc, ptd, hdc is metafile, hic
// NULL, NULL, n/a, Display
// NULL, !NULL, n/a, ptd
// !NULL, NULL, FALSE, hdc
// !NULL, NULL, TRUE, display
// !NULL, !NULL, FALSE, ptd
// !NULL, !NULL, TRUE, ptd
if (ptd != NULL)
{
LPDEVMODEOLE lpDevMode;
LPOLESTR lpszDriverName;
LPOLESTR lpszDeviceName;
LPOLESTR lpszPortName;
if (ptd->tdExtDevmodeOffset == 0)
lpDevMode = NULL;
else
lpDevMode = (LPDEVMODEOLE) ((LPSTR)ptd + ptd->tdExtDevmodeOffset);
lpszDriverName = (LPOLESTR)((BYTE*)ptd + ptd->tdDriverNameOffset);
lpszDeviceName = (LPOLESTR)((BYTE*)ptd + ptd->tdDeviceNameOffset);
lpszPortName = (LPOLESTR)((BYTE*)ptd + ptd->tdPortNameOffset);
return ::CreateDC(OLE2CT(lpszDriverName), OLE2CT(lpszDeviceName),
OLE2CT(lpszPortName), DEVMODEOLE2T(lpDevMode));
}
else if (hdc == NULL || GetDeviceCaps(hdc, TECHNOLOGY) == DT_METAFILE)
return ::CreateDC(_T("DISPLAY"), NULL, NULL, NULL);
else
return hdc;
}
#define HIMETRIC_PER_INCH 2540
#define MAP_PIX_TO_LOGHIM(x,ppli) ( (HIMETRIC_PER_INCH*(x) + ((ppli)>>1)) / (ppli) )
#define MAP_LOGHIM_TO_PIX(x,ppli) ( ((ppli)*(x) + HIMETRIC_PER_INCH/2) / HIMETRIC_PER_INCH )
ATLAPI_(void) AtlHiMetricToPixel(const SIZEL * lpSizeInHiMetric, LPSIZEL lpSizeInPix)
{
int nPixelsPerInchX; // Pixels per logical inch along width
int nPixelsPerInchY; // Pixels per logical inch along height
HDC hDCScreen = GetDC(NULL);
if (hDCScreen) {
nPixelsPerInchX = GetDeviceCaps(hDCScreen, LOGPIXELSX);
nPixelsPerInchY = GetDeviceCaps(hDCScreen, LOGPIXELSY);
ReleaseDC(NULL, hDCScreen);
} else {
nPixelsPerInchX = nPixelsPerInchY = 1;
}
lpSizeInPix->cx = MAP_LOGHIM_TO_PIX(lpSizeInHiMetric->cx, nPixelsPerInchX);
lpSizeInPix->cy = MAP_LOGHIM_TO_PIX(lpSizeInHiMetric->cy, nPixelsPerInchY);
}
ATLAPI_(void) AtlPixelToHiMetric(const SIZEL * lpSizeInPix, LPSIZEL lpSizeInHiMetric)
{
int nPixelsPerInchX; // Pixels per logical inch along width
int nPixelsPerInchY; // Pixels per logical inch along height
HDC hDCScreen = GetDC(NULL);
if (hDCScreen) {
nPixelsPerInchX = GetDeviceCaps(hDCScreen, LOGPIXELSX);
nPixelsPerInchY = GetDeviceCaps(hDCScreen, LOGPIXELSY);
ReleaseDC(NULL, hDCScreen);
} else {
nPixelsPerInchX = nPixelsPerInchY = 1;
}
lpSizeInHiMetric->cx = MAP_PIX_TO_LOGHIM(lpSizeInPix->cx, nPixelsPerInchX);
lpSizeInHiMetric->cy = MAP_PIX_TO_LOGHIM(lpSizeInPix->cy, nPixelsPerInchY);
}
#endif