1326 lines
45 KiB
C++
1326 lines
45 KiB
C++
/*************************************************************************/
|
|
/* Copyright (C) 1999 Microsoft Corporation */
|
|
/* File: CCObj.cpp */
|
|
/* Description: Contains holder for container objects. */
|
|
/*************************************************************************/
|
|
#include "stdafx.h"
|
|
#include "ccobj.h"
|
|
#include "chobj.h"
|
|
|
|
#define GET_SITE CComPtr<IOleInPlaceSiteWindowless> pSite; \
|
|
HRESULT hr = GetWindowlessSite(pSite); \
|
|
if(FAILED(hr)) return(hr);
|
|
|
|
#define GET_CONTAINER CComPtr<IOleContainer> pContainer; \
|
|
HRESULT hr = GetContainer(pContainer); \
|
|
if(FAILED(hr)) return(hr);
|
|
|
|
#define GET_INPLACEUIWINDOW CComPtr<IOleContainer> pContainer; \
|
|
HRESULT hr = GetContainer(pContainer); \
|
|
if(FAILED(hr)) return(hr); \
|
|
CComPtr<IOleInPlaceUIWindow> pUIWindow; \
|
|
hr = pContainer->QueryInterface(IID_IOleInPlaceUIWindow, (void**) &pUIWindow); \
|
|
if(FAILED(hr)) return(hr);
|
|
|
|
/*************************************************************************/
|
|
/* Function: CContainerObject */
|
|
/* Description: Constructor that should set needed objects. */
|
|
/*************************************************************************/
|
|
CContainerObject::CContainerObject(IUnknown* pUnknown, CHostedObject* pObj){
|
|
|
|
Init();
|
|
SetObjects(pUnknown, pObj);
|
|
}/* end of function CContainerObject */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetObjects */
|
|
/* Description: Sets the internal objects. */
|
|
/*************************************************************************/
|
|
HRESULT CContainerObject::SetObjects(IUnknown* pUnknown, CHostedObject* pObj){
|
|
|
|
m_pUnkContainer = pUnknown;
|
|
m_pObj = pObj;
|
|
return(S_OK);
|
|
}/* end of function SetObjects */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Init */
|
|
/* Description: Initializes the member variables */
|
|
/*************************************************************************/
|
|
void CContainerObject::Init(){
|
|
|
|
//m_pUnkContainer = NULL; // using smart pointer
|
|
m_pObj = NULL;
|
|
m_lRefCount = 1;
|
|
m_bLocked = 0;
|
|
}/* end of function Init */
|
|
|
|
/*************************************************************************/
|
|
/* Function: QueryInterface */
|
|
/* Description: Gets the supported interface rest sends to the aggregated*/
|
|
/* object */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::QueryInterface(const IID& iid, void**ppv){
|
|
|
|
if(iid == IID_IUnknown){
|
|
|
|
*ppv = static_cast<CContainerObject*>(this);
|
|
}
|
|
else if(iid == IID_IOleInPlaceSiteWindowless){
|
|
|
|
*ppv = static_cast<IOleInPlaceSiteWindowless*>(this);
|
|
}
|
|
else if(iid == IID_IOleInPlaceSiteEx){
|
|
|
|
*ppv = static_cast<IOleInPlaceSiteEx*>(this);
|
|
}
|
|
else if(iid == IID_IOleClientSite){
|
|
|
|
*ppv = static_cast<IOleClientSite*>(this);
|
|
}
|
|
else if(iid == IID_IOleContainer){
|
|
|
|
*ppv = static_cast<IOleContainer*>(this);
|
|
}
|
|
else if(iid == IID_IOleInPlaceSite){
|
|
|
|
*ppv = static_cast<IOleInPlaceSite*>(this);
|
|
}
|
|
else if(iid == IID_IObjectWithSite){
|
|
|
|
*ppv = static_cast<IObjectWithSite*>(this);
|
|
}
|
|
else if(iid == IID_IPropertyBag){
|
|
|
|
*ppv = static_cast<IPropertyBag*>(this);
|
|
}
|
|
else if(iid == IID_IOleControlSite){
|
|
|
|
*ppv = static_cast<IOleControlSite*>(this);
|
|
}
|
|
else if(iid == IID_IOleInPlaceFrame){
|
|
|
|
*ppv = static_cast<IOleInPlaceFrame*>(this);
|
|
}
|
|
else if(iid == IID_IOleInPlaceUIWindow){
|
|
|
|
*ppv = static_cast<IOleInPlaceUIWindow*>(this);
|
|
}
|
|
else if(iid == IID_IOleWindow){
|
|
|
|
IOleInPlaceSiteWindowless* ppTmp = static_cast<IOleInPlaceSiteWindowless*>(this);
|
|
*ppv = static_cast<IOleWindow*>(ppTmp);
|
|
}
|
|
else {
|
|
ATLTRACE2(atlTraceHosting, 0, _T("QI Failed\n"));
|
|
*ppv = NULL;
|
|
return (E_NOINTERFACE);
|
|
}/* end of if statement */
|
|
|
|
reinterpret_cast<IUnknown*>(*ppv)->AddRef();
|
|
return(S_OK);
|
|
}/* end of function QueryInterface */
|
|
|
|
/*************************************************************************/
|
|
/* Function: AddRef */
|
|
/* Description: Adds the reference count. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP_(ULONG) CContainerObject::AddRef ( void){
|
|
|
|
return(InterlockedIncrement(&m_lRefCount));
|
|
}/* end of function AddRef */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Release */
|
|
/* Description: Decrements the reference count and the possibly releases */
|
|
/*************************************************************************/
|
|
STDMETHODIMP_(ULONG) CContainerObject::Release( void){
|
|
|
|
if(InterlockedIncrement(&m_lRefCount) <=0){
|
|
|
|
delete this;
|
|
return 0;
|
|
}/* end of if statement */
|
|
|
|
return (m_lRefCount);
|
|
}/* end of function Release */
|
|
|
|
/*************************************************************************/
|
|
/* Helper functions */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetWindowlessSite */
|
|
/* Description: Returns an interface for windowless site. */
|
|
/*************************************************************************/
|
|
inline HRESULT CContainerObject::GetWindowlessSite(CComPtr<IOleInPlaceSiteWindowless>& pSite){
|
|
|
|
if(!m_pUnkContainer){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
return(m_pUnkContainer->QueryInterface(&pSite));
|
|
}/* end of function GetWindowlessSite */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetContainer */
|
|
/* Description: Returns an interface for windowless site. */
|
|
/*************************************************************************/
|
|
inline HRESULT CContainerObject::GetContainer(CComPtr<IOleContainer>& pContainer){
|
|
|
|
if(!m_pUnkContainer){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
return(m_pUnkContainer->QueryInterface(&pContainer));
|
|
}/* end of function GetContainer */
|
|
|
|
/*************************************************************************/
|
|
/* IOleContainer Implementation */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: ParseDisplayName */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::ParseDisplayName(IBindCtx* /*pbc*/,
|
|
LPOLESTR /*pszDisplayName*/, ULONG* /*pchEaten*/, IMoniker** /*ppmkOut*/){
|
|
|
|
ATLTRACENOTIMPL(_T("IOleClientSite::ParseDisplayName"));
|
|
}/* end of function ParseDisplayName */
|
|
|
|
/*************************************************************************/
|
|
/* Function: EnumObjects */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::EnumObjects(DWORD grfFlags, IEnumUnknown** ppenum){
|
|
|
|
GET_CONTAINER
|
|
return(pContainer->EnumObjects(grfFlags, ppenum));
|
|
}/* end of function EnumObjects */
|
|
|
|
/*************************************************************************/
|
|
/* Function: LockContainer */
|
|
/* Description: Sets the container locked so it does not go away. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::LockContainer(BOOL fLock){
|
|
|
|
// TODO: Actually do use the m_bLocked flag
|
|
m_bLocked = fLock;
|
|
return S_OK;
|
|
}/* end of function LockContainer */
|
|
|
|
/*************************************************************************/
|
|
/* IOleClientSite Implementation */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetContainer */
|
|
/* Description: Basically returns our self */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetContainer(IOleContainer** ppContainer){
|
|
|
|
ATLTRACE2(atlTraceHosting, 0, _T("IOleClientSite::GetContainer\n"));
|
|
HRESULT hr = E_POINTER;
|
|
|
|
if (NULL == ppContainer){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if (m_pUnkContainer){
|
|
|
|
(*ppContainer) = NULL;
|
|
hr = QueryInterface(IID_IOleContainer, (void**)ppContainer); // return our selfs
|
|
}/* end of if statement */
|
|
|
|
return hr;
|
|
}/* end of function GetContainer */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ShowObject */
|
|
/* Description: Redraws the object. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::ShowObject(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
ATLTRACE2(atlTraceHosting, 0, _T("IOleClientSite::ShowObject\r\n"));
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = InvalidateObjectRect();
|
|
|
|
return (hr);
|
|
}/* end of function ShowObject */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnShowWindow */
|
|
/* Description: Shows or hides the window. If no window to show or hide */
|
|
/* we deactivate it. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnShowWindow(BOOL fShow){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = m_pObj->SetActive(fShow ? true: false);
|
|
|
|
return(hr);
|
|
}/* end of function OnShowWindow */
|
|
|
|
/*************************************************************************/
|
|
/* IOleInPlaceSiteEx Implementation */
|
|
/* Just pass throw in most cases, in some do some extra house keeping */
|
|
/* since we know which object we are containing. */
|
|
/*************************************************************************/
|
|
|
|
// IOleWindow
|
|
/*************************************************************************/
|
|
/* Function: GetWindow */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetWindow(HWND *phwnd){
|
|
|
|
GET_SITE
|
|
return(pSite->GetWindow(phwnd));
|
|
}/* end of function GetWindow */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ContextSensitiveHelp */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::ContextSensitiveHelp(BOOL fEnterMode){
|
|
|
|
GET_SITE
|
|
return(pSite->ContextSensitiveHelp(fEnterMode));
|
|
}/* end of function ContextSensitiveHelp */
|
|
|
|
//IOleInPlaceSite
|
|
/*************************************************************************/
|
|
/* Function: CanInPlaceActivate */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::CanInPlaceActivate(){
|
|
|
|
GET_SITE
|
|
return(pSite->CanInPlaceActivate());
|
|
}/* end of function CanInPlaceActivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnUIActivate */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnUIActivate(){
|
|
|
|
GET_SITE
|
|
return(pSite->OnUIActivate());
|
|
}/* end of function OnUIActivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnInPlaceActivate */
|
|
/* Description: Activates non windowless object. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnInPlaceActivate(){
|
|
|
|
ATLTRACE(TEXT("CContainerObject::OnInPlaceActivate \n"));
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CComPtr<IUnknown> pUnk = m_pObj->GetUnknown(); // get the control object that is being inserted
|
|
|
|
if(!pUnk){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
//OleLockRunning(pUnk, TRUE, FALSE); // not sure if needed here
|
|
|
|
m_pObj->SetWindowless(false);
|
|
//m_pObj->SetActive(true);
|
|
|
|
return(hr);
|
|
}/* end of function OnInPlaceActivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnUIDeactivate */
|
|
/* Description: Deactivates the object. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnUIDeactivate(BOOL fUndoable){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_pObj->SetActive(false);
|
|
|
|
return(hr);
|
|
}/* end of function OnUIDeactivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnInPlaceDeactivate */
|
|
/* Description: Deactivates the object. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnInPlaceDeactivate(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_pObj->SetActive(false);
|
|
|
|
return(hr);
|
|
}/* end of function OnInPlaceDeactivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: DiscardUndoState */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::DiscardUndoState(){
|
|
|
|
GET_SITE
|
|
return(pSite->DiscardUndoState());
|
|
}/* end of function DiscardUndoState */
|
|
|
|
/*************************************************************************/
|
|
/* Function: DeactivateAndUndo */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::DeactivateAndUndo(){
|
|
|
|
GET_SITE
|
|
return(pSite->DeactivateAndUndo());
|
|
// TODO: Handle specific container
|
|
}/* end of function DeactivateAndUndo */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnPosRectChange */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnPosRectChange(LPCRECT lprcPosRect){
|
|
|
|
GET_SITE
|
|
return(pSite->OnPosRectChange(lprcPosRect));
|
|
// TODO: Handle specific container
|
|
}/* end of function OnPosRectChange */
|
|
|
|
/*************************************************************************/
|
|
/* Function: Scroll */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::Scroll(SIZE scrollExtent){
|
|
|
|
GET_SITE
|
|
return(pSite->Scroll(scrollExtent));
|
|
// TODO: Handle specific container
|
|
}/* end of function OnPosRectChange */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetWindowContext */
|
|
/* Description: Finish this function to be container specific. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetWindowContext(IOleInPlaceFrame** ppFrame,
|
|
IOleInPlaceUIWindow** ppDoc, LPRECT lprcPosRect,
|
|
LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO pFrameInfo){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if (ppFrame == NULL || ppDoc == NULL || lprcPosRect == NULL || lprcClipRect == NULL){
|
|
|
|
hr = E_POINTER;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if (!m_spInPlaceFrame){
|
|
|
|
//CComObject<CAxFrameWindow>* pFrameWindow;
|
|
//CComObject<CAxFrameWindow>::CreateInstance(&pFrameWindow);
|
|
// ?? MODS DJ
|
|
QueryInterface(IID_IOleInPlaceFrame, (void**) &m_spInPlaceFrame);
|
|
ATLASSERT(m_spInPlaceFrame);
|
|
}/* end of if statement */
|
|
|
|
if (!m_spInPlaceUIWindow){
|
|
// ?? MODS DJ
|
|
//CComObject<CAxUIWindow>* pUIWindow;
|
|
//CComObject<CAxUIWindow>::CreateInstance(&pUIWindow);
|
|
QueryInterface(IID_IOleInPlaceUIWindow, (void**) &m_spInPlaceUIWindow);
|
|
ATLASSERT(m_spInPlaceUIWindow);
|
|
}/* end of if statement */
|
|
|
|
m_spInPlaceFrame.CopyTo(ppFrame);
|
|
m_spInPlaceUIWindow.CopyTo(ppDoc);
|
|
|
|
RECT rc;
|
|
hr = m_pObj->GetPos(&rc);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
*lprcPosRect = rc;
|
|
*lprcClipRect = rc;
|
|
|
|
HWND hwnd;
|
|
hr = GetWindow(&hwnd);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
hr = S_FALSE;
|
|
//return(hr);
|
|
}/* end of if statement */
|
|
|
|
HWND hParent = NULL;
|
|
|
|
if(NULL != hwnd){
|
|
|
|
hParent = ::GetParent(hwnd);
|
|
}/* end of function GetParent */
|
|
|
|
ACCEL ac = { 0,0,0 };
|
|
HACCEL hac = ::CreateAcceleratorTable(&ac, 1);
|
|
pFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
|
|
pFrameInfo->fMDIApp = 0;
|
|
pFrameInfo->hwndFrame = hParent;
|
|
pFrameInfo->haccel = hac;
|
|
pFrameInfo->cAccelEntries = 1;
|
|
|
|
return hr;
|
|
}/* end of function GetWindowContext */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetSite */
|
|
/* Description: Returns pretty much QI, client sets the site and then */
|
|
/* container is using it. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetSite(REFIID riid, void **ppvSite){
|
|
|
|
return(QueryInterface(riid, ppvSite));
|
|
}/* end of function GetSite */
|
|
|
|
//IOleInPlaceSiteEx
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnInPlaceActivateEx */
|
|
/* Description: Checks what way we shall instantiate the control. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnInPlaceActivateEx(BOOL* /*pfNoRedraw*/, DWORD dwFlags){
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
CComPtr<IUnknown> pUnk = m_pObj->GetUnknown(); // get the control object that is being inserted
|
|
|
|
if(!pUnk){
|
|
|
|
return(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
//OleLockRunning(pUnk, TRUE, FALSE);
|
|
|
|
CComPtr<IOleInPlaceObjectWindowless> spInPlaceObjectWindowless;
|
|
|
|
bool bWindowless = false;
|
|
|
|
if (dwFlags & ACTIVATE_WINDOWLESS){
|
|
|
|
m_pObj->SetWindowless(true);
|
|
hr = pUnk->QueryInterface(IID_IOleInPlaceObjectWindowless,(void**) &spInPlaceObjectWindowless);
|
|
}/* end of if statement */
|
|
|
|
if (FAILED(hr)){
|
|
|
|
m_pObj->SetWindowless(false);
|
|
hr = pUnk->QueryInterface(IID_IOleInPlaceObject, (void**) &spInPlaceObjectWindowless);
|
|
}/* end of if statement */
|
|
|
|
if (SUCCEEDED(hr)){
|
|
|
|
RECT rcPos;
|
|
hr = m_pObj->GetPos(&rcPos);
|
|
|
|
if (FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(m_pObj->IsWindowless()){
|
|
|
|
spInPlaceObjectWindowless->SetObjectRects(&rcPos, &rcPos);
|
|
ATLTRACE(TEXT("Windowless object is contained object with ID %ls Rect left = %d top %d right %d bottom %d\n"),
|
|
m_pObj->GetID(), rcPos.left, rcPos.top, rcPos.right, rcPos.bottom);
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
//m_pObj->SetActive(true);
|
|
|
|
return S_OK;
|
|
}/* end of function OnInPlaceActivateEx */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnInPlaceDeactivateEx */
|
|
/* Description: Deactivates the object. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnInPlaceDeactivateEx(BOOL fNoRedraw){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
m_pObj->SetActive(false);
|
|
|
|
return(hr);
|
|
}/* end of function OnInPlaceDeactivateEx */
|
|
|
|
/*************************************************************************/
|
|
/* Function: RequestUIActivate */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::RequestUIActivate(){
|
|
|
|
GET_SITE
|
|
return(pSite->RequestUIActivate());
|
|
}/* end of function RequestUIActivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: CanWindowlessActivate */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::CanWindowlessActivate(){
|
|
|
|
GET_SITE
|
|
return(pSite->CanWindowlessActivate());
|
|
}/* end of function CanWindowlessActivate */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetDC */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetDC(LPCRECT pRect, DWORD grfFlags, HDC* phDC){
|
|
|
|
GET_SITE
|
|
return(pSite->GetDC(pRect, grfFlags, phDC));
|
|
}/* end of function GetDC */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ReleaseDC */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::ReleaseDC(HDC hDC){
|
|
|
|
GET_SITE
|
|
return(pSite->ReleaseDC(hDC));
|
|
}/* end of function ReleaseDC */
|
|
|
|
/*************************************************************************/
|
|
/* Function: InvalidateRect */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::InvalidateRect(LPCRECT pRect, BOOL fErase){
|
|
|
|
GET_SITE
|
|
return(pSite->InvalidateRect(pRect, fErase));
|
|
}/* end of function InvalidateRect */
|
|
|
|
/*************************************************************************/
|
|
/* Function: InvalidateObjectRect */
|
|
/* Description: Invalidates the whole control. */
|
|
/*************************************************************************/
|
|
HRESULT CContainerObject::InvalidateObjectRect(){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
RECT rc;
|
|
hr = m_pObj->GetPos(&rc);
|
|
|
|
if(FAILED(hr)){
|
|
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = InvalidateRect(&rc, FALSE); // invalidate the region instead
|
|
// of drawing the object directly
|
|
return(hr);
|
|
}/* end of function InvalidateRect */
|
|
|
|
/*************************************************************************/
|
|
/* Function: InvalidateRgn */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::InvalidateRgn(HRGN hRGN, BOOL fErase){
|
|
|
|
GET_SITE
|
|
return(pSite->InvalidateRgn(hRGN, fErase));
|
|
}/* end of function InvalidateRgn */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ScrollRect */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::ScrollRect(INT dx, INT dy, LPCRECT pRectScroll, LPCRECT pRectClip){
|
|
|
|
GET_SITE
|
|
return(pSite->ScrollRect(dx, dy, pRectScroll, pRectClip));
|
|
}/* end of function ScrollRect */
|
|
|
|
/*************************************************************************/
|
|
/* Function: AdjustRect */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::AdjustRect(LPRECT prc){
|
|
|
|
GET_SITE
|
|
return(pSite->AdjustRect(prc));
|
|
}/* end of function AdjustRect */
|
|
|
|
/*************************************************************************/
|
|
/* Function: OnDefWindowMessage */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::OnDefWindowMessage(UINT msg, WPARAM wParam, LPARAM lParam, LRESULT* plResult){
|
|
|
|
GET_SITE
|
|
return(pSite->OnDefWindowMessage(msg, wParam, lParam, plResult));
|
|
}/* end of function OnDefWindowMessage */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetCapture */
|
|
/* Description: Used to determine if we have a cupature or not */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetCapture(){
|
|
|
|
GET_SITE
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = pSite->GetCapture();
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
// we checked with the container if we
|
|
// have a capture
|
|
|
|
if(m_pObj->HasCapture() == false){
|
|
|
|
hr = S_FALSE;
|
|
}
|
|
else {
|
|
|
|
if(hr == S_FALSE){
|
|
// case when the container say we do not have
|
|
// the capture any more
|
|
// but the object thinks it has a capture
|
|
// we better reset the flag
|
|
m_pObj->SetCapture(false);
|
|
// and say that we do not have capture
|
|
hr = S_FALSE;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function GetCapture */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetCapture */
|
|
/* Description: Used to set the capture for mouse events */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::SetCapture(BOOL fCapture){
|
|
|
|
GET_SITE
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(fCapture && !m_pObj->IsInputEnabled()){
|
|
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(m_pObj->HasCapture() == (fCapture ? true: false)){
|
|
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
// Call our "real" container object for count keeping
|
|
// and signaling to its window or another container
|
|
hr = pSite->SetCapture(fCapture);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
m_pObj->SetCapture(fCapture? true: false); // set the capture on the object
|
|
}/* end of if statement */
|
|
|
|
return (hr);
|
|
}/* end of function SetCapture */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetFocus */
|
|
/* Description: Determine if we have a focus or not. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetFocus(){
|
|
|
|
GET_SITE
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
hr = pSite->GetFocus();
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
if(m_pObj->HasFocus() == false){
|
|
|
|
hr = S_FALSE;
|
|
}
|
|
else {
|
|
|
|
if(S_FALSE == hr){
|
|
m_pObj->SetFocus(false);
|
|
hr = S_FALSE;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
return(hr);
|
|
}/* end of function GetFocus */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetFocus */
|
|
/* Description: Sets focus to the control */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::SetFocus(BOOL fFocus){
|
|
|
|
GET_SITE
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
hr = E_UNEXPECTED;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(fFocus && !m_pObj->IsInputEnabled()){
|
|
|
|
// can't set focus to not active objects
|
|
// but can take away focus from non active ones
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
if(m_pObj->HasFocus() == (fFocus ? true: false)){
|
|
|
|
// we are not chaning focus state so do not bother calling container
|
|
hr = S_FALSE;
|
|
return(hr);
|
|
}/* end of if statement */
|
|
|
|
// Call our "real" container object for count keeping
|
|
// and signaling to its window or another container
|
|
hr = pSite->SetFocus(fFocus);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
|
|
m_pObj->SetFocus(fFocus ? true: false); // set the capture on the object
|
|
}/* end of if statement */
|
|
|
|
InvalidateObjectRect();
|
|
|
|
return (hr);
|
|
}/* end of function SetFocus */
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
/* IPropertyBag */
|
|
/*************************************************************************/
|
|
|
|
/*************************************************************************/
|
|
/* Function: Read */
|
|
/* Description: Reads a specific control property from a bag. */
|
|
/* The bag looks like IE compatible <PARAM NAME="PropName" VALUE="value">*/
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::Read(LPCOLESTR pszPropName, VARIANT* pVar,
|
|
IErrorLog* pErrorLog){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
ATLTRACE2(atlTraceHosting, 0, _T("IPropertyBag::Read\r\n"));
|
|
|
|
if(NULL == m_pObj){
|
|
|
|
throw(E_UNEXPECTED);
|
|
}/* end of if statement */
|
|
|
|
if (NULL == pVar){
|
|
|
|
throw(E_POINTER);
|
|
}/* end of if statement */
|
|
|
|
hr = ParsePropertyBag(pszPropName, pVar, pErrorLog);
|
|
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function Read */
|
|
|
|
/*************************************************************************/
|
|
/* Function: MyIsWhiteSpace */
|
|
/* Local function implementation, since we do not have standart C lib */
|
|
/* support */
|
|
/*************************************************************************/
|
|
static bool MyIsWhiteSpace( WCHAR c ){
|
|
|
|
return c == L' ' ||
|
|
c == L'\t' ||
|
|
c == L'\r' ||
|
|
c == L'\n';
|
|
}/* end of function MyIsWhiteSpace */
|
|
|
|
/*************************************************************************/
|
|
/* Function: MyStrToDouble */
|
|
/* Description: Reads in string and converts it to double */
|
|
/* Returns E_INVALIDARG if there is alpah or some other undesired string*/
|
|
/* S_OK if we got some string, S_FALSE if no number string (empty or spac*/
|
|
/*************************************************************************/
|
|
static HRESULT MyStrToDouble(WCHAR* pstr, double &n)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
|
|
int Sign = 1;
|
|
n = 0; // result wil be n*Sign
|
|
bool bBeforeDecimalPoint = true;
|
|
double k = 10;
|
|
|
|
// eat whitespace at start
|
|
while( *pstr != L'\n' && MyIsWhiteSpace( *pstr ) ) {
|
|
pstr++;
|
|
}
|
|
|
|
while( pstr[lstrlenW(pstr)-1]!= L'\n' && MyIsWhiteSpace( *pstr ) ) {
|
|
pstr[lstrlenW(pstr)-1] = L'\0';
|
|
}
|
|
|
|
//lstrcmpiW is not implemented on 98 need to use STDLIB
|
|
// TODO: eventaully replace the below _wcsicmp with our own so we can remove support
|
|
// on standard C library
|
|
if (_wcsicmp(pstr, L"true") == 0) {
|
|
n = -1;
|
|
return S_OK;
|
|
}
|
|
|
|
if (_wcsicmp(pstr, L"false") == 0) {
|
|
n = 0;
|
|
return S_OK;
|
|
}
|
|
|
|
if (pstr[0]==L'-'){
|
|
Sign = -1;
|
|
++pstr;
|
|
}/* end of if statement */
|
|
|
|
for( ; ; ) {
|
|
if (pstr[0]>=L'0' && pstr[0]<=L'9') {
|
|
if(bBeforeDecimalPoint == true){
|
|
n = 10*n+(int)(pstr[0]-L'0');
|
|
} else {
|
|
n = n+ ((int)(pstr[0]-L'0'))/k;
|
|
k = k * 10; // decrease the decimal point
|
|
|
|
}/* end of if statement */
|
|
hr = S_OK;
|
|
} else if ( MyIsWhiteSpace( pstr[0] ) || pstr[0] == L'\0' ) {
|
|
break;
|
|
} else if( bBeforeDecimalPoint && pstr[0] == L'.') {
|
|
bBeforeDecimalPoint = false;
|
|
} else {
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}/* end of if statement */
|
|
++pstr;
|
|
}/* end of for loop */
|
|
|
|
n *= Sign; // adjust the sign
|
|
return(hr);
|
|
}/* end of function MyStrToDouble */
|
|
|
|
/*************************************************************************/
|
|
/* Function: CompSubstr */
|
|
/* Description: ComaparesSubstr, eats up whithe spaces. */
|
|
/*************************************************************************/
|
|
HRESULT CompSubstr(WCHAR*& strSource, const WCHAR* strKey){
|
|
|
|
bool bEatSpaces = true;
|
|
register WCHAR wcKey = *strKey;
|
|
register WCHAR wcSrc = *strSource;
|
|
|
|
for(INT i = 0; wcKey != NULL; wcSrc = *(++strSource)){
|
|
|
|
if(bEatSpaces){
|
|
// eat up the spaces and tabs and enters and cr
|
|
if(MyIsWhiteSpace(wcSrc)){
|
|
continue;
|
|
}
|
|
else {
|
|
bEatSpaces = false;
|
|
}/* end of if statement */
|
|
}/* end of if statement */
|
|
|
|
if(wcKey != wcSrc){
|
|
|
|
return(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
if(NULL == wcSrc){
|
|
|
|
return(E_FAIL); // ran out of space in the source string
|
|
}/* end of if statement */
|
|
|
|
wcKey = strKey[++i]; // advance the key
|
|
}/* end of for loop */
|
|
|
|
return(S_OK);
|
|
}/* end of function CompSubstr */
|
|
|
|
/*************************************************************************/
|
|
/* Function: ParsePropertyBag */
|
|
/* Description: Retrives a property from the bag and puts it into variant*/
|
|
/* if it fails returns E_FAIL. */
|
|
/*************************************************************************/
|
|
HRESULT CContainerObject::ParsePropertyBag(LPCOLESTR pszPropName, VARIANT* pVar,
|
|
IErrorLog* /* pErrorLog */){
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
CComBSTR strBag = m_pObj->GetPropBag();
|
|
|
|
if(!strBag){
|
|
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
WCHAR* strValue = NULL; // the place where we are going to stick the actuall value
|
|
// before putting it into variant
|
|
WCHAR* strTmpValue = L"";
|
|
WCHAR* strTmpBag = strBag;
|
|
|
|
if(NULL == *strTmpBag){
|
|
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
INT iState = 0; // 0 start
|
|
|
|
bool fFound = false;
|
|
bool fFinished = false;
|
|
INT iLength = 0; // noting the start and end of the value string
|
|
// now try to parse out the value for the appropriate string
|
|
for(INT i = 0; NULL != *strTmpBag && !fFinished; i++){
|
|
|
|
switch(iState){
|
|
case 0: // looking for start <
|
|
if(FAILED(CompSubstr(strTmpBag, L"<"))) return (E_FAIL);
|
|
iState = 1; break;
|
|
|
|
case 1: // PARAM
|
|
if(FAILED(CompSubstr(strTmpBag, L"PARAM"))) return (E_FAIL);
|
|
iState = 2; break;
|
|
|
|
case 2: // NAME
|
|
if(FAILED(CompSubstr(strTmpBag, L"NAME"))) return (E_FAIL);
|
|
iState = 3; break;
|
|
|
|
case 3: // =
|
|
if(FAILED(CompSubstr(strTmpBag, L"="))) return (E_FAIL);
|
|
iState = 4; break;
|
|
|
|
case 4: // "
|
|
if(FAILED(CompSubstr(strTmpBag, L"\""))) return (E_FAIL);
|
|
iState = 5; break;
|
|
|
|
case 5: // pszPropName (the actual name)
|
|
if(SUCCEEDED(CompSubstr(strTmpBag, pszPropName))){
|
|
|
|
fFound = true; // found the PropName
|
|
}/* end of if statement */
|
|
|
|
iState = 6; break;
|
|
|
|
case 6: // "
|
|
if(SUCCEEDED(CompSubstr(strTmpBag, L"\""))){
|
|
|
|
iState = 7;
|
|
}
|
|
else {
|
|
|
|
strTmpBag++;
|
|
}/* end of if statement */
|
|
break;
|
|
|
|
case 7: // VALUE
|
|
if(FAILED(CompSubstr(strTmpBag, L"VALUE"))) return (E_FAIL);
|
|
iState = 8; break;
|
|
|
|
case 8: // =
|
|
if(FAILED(CompSubstr(strTmpBag, L"="))) return (E_FAIL);
|
|
iState = 9; break;
|
|
|
|
case 9: // "
|
|
if(FAILED(CompSubstr(strTmpBag, L"\""))) return (E_FAIL);
|
|
iState = 10; break;
|
|
|
|
|
|
case 10: // VALUE
|
|
if(fFound){
|
|
|
|
// read up the string and exit the loop
|
|
strTmpValue = strTmpBag;
|
|
}/* end of if statement */
|
|
|
|
iState = 11; break;
|
|
|
|
case 11: // "
|
|
if(SUCCEEDED(CompSubstr(strTmpBag, L"\""))){
|
|
iState = 12;
|
|
|
|
if(fFound){
|
|
iLength = INT(strTmpBag - strTmpValue);
|
|
|
|
strValue = new WCHAR[iLength];
|
|
memcpy(strValue, strTmpValue, iLength * sizeof(WCHAR));
|
|
strValue[iLength - 1] = NULL;
|
|
// read up the string and exit the loop
|
|
|
|
fFinished = true; // exit the loop
|
|
}/* end of if statement */
|
|
}
|
|
else {
|
|
|
|
strTmpBag++;
|
|
}/* end of if statement */
|
|
break;
|
|
|
|
case 12: // closing brakcet >
|
|
if(FAILED(CompSubstr(strTmpBag, L">"))) return (E_FAIL);
|
|
iState = 0;
|
|
break;
|
|
}/* end of switch statement */
|
|
}/* end of for loop */
|
|
|
|
if(!fFinished){
|
|
|
|
return(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
// at this moment we have value parsed out
|
|
|
|
switch(pVar->vt){
|
|
|
|
case VT_BSTR:
|
|
pVar->bstrVal = ::SysAllocString(strValue);
|
|
break;
|
|
|
|
case VT_I4: {
|
|
double dbl;
|
|
if(MyStrToDouble(strValue, dbl) != S_OK){
|
|
|
|
// S_FALSE denotes empty string
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
// TODO: Create MyStrToInt and do not cast
|
|
pVar->lVal = (INT)dbl;
|
|
}
|
|
case VT_UI4:{
|
|
double dbl;
|
|
if(MyStrToDouble(strValue, dbl) != S_OK){
|
|
|
|
// S_FALSE denotes empty string
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
// TODO: Create MyStrToInt and do not cast
|
|
pVar->ulVal = (ULONG)dbl;
|
|
}
|
|
break;
|
|
|
|
case VT_R4: {
|
|
|
|
double dbl;
|
|
if(MyStrToDouble(strValue, dbl) != S_OK){
|
|
|
|
// S_FALSE denotes empty string
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
// TODO: Create MyStrToInt and do not cast
|
|
pVar->fltVal = (FLOAT) dbl;
|
|
|
|
}
|
|
break;
|
|
|
|
case VT_R8: {
|
|
|
|
double dbl;
|
|
if(MyStrToDouble(strValue, dbl) != S_OK){
|
|
|
|
// S_FALSE denotes empty string
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
// TODO: Create MyStrToInt and do not cast
|
|
pVar->dblVal = dbl;
|
|
|
|
}
|
|
break;
|
|
|
|
case VT_BOOL: {
|
|
double dbl;
|
|
if(MyStrToDouble(strValue, dbl) != S_OK){
|
|
|
|
// S_FALSE denotes empty string
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
|
|
// TODO: Create MyStrToInt and do not cast
|
|
if(0.0 == dbl){
|
|
|
|
pVar->boolVal = VARIANT_FALSE;
|
|
}
|
|
else if(1.0 == dbl || -1.0 == dbl){
|
|
|
|
pVar->boolVal = VARIANT_TRUE;
|
|
}
|
|
else {
|
|
|
|
throw(E_FAIL);
|
|
}/* end of if statement */
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ATLTRACE2(atlTraceHosting, 0, _T("This type is not implemented please add.\r\n"));
|
|
ATLASSERT(FALSE);
|
|
throw(E_FAIL);
|
|
}/* end of switch statement */
|
|
|
|
delete strValue; // cleanup our variable
|
|
}
|
|
catch(...){
|
|
|
|
hr = E_UNEXPECTED;
|
|
}/* end of catch statement */
|
|
|
|
return (hr);
|
|
}/* end of function ParsePropertyBag */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetExtendedControl */
|
|
/* Description: Used to get a DISPATCH of the wrapper for the control, */
|
|
/* that exposes container specific features. Implement this in order to */
|
|
/* speed up processing in the container. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetExtendedControl(IDispatch** ppDisp){
|
|
|
|
ATLTRACE2(atlTraceHosting, 2, TEXT("IOleControlSite::GetExtendedControl\n"));
|
|
ATLASSERT(FALSE); // TODO, this interface needs to be moved to the hosted object
|
|
|
|
#if 0
|
|
if (ppDisp == NULL)
|
|
return E_POINTER;
|
|
return m_spOleObject.QueryInterface(ppDisp);
|
|
#endif
|
|
|
|
*ppDisp = NULL;
|
|
return(E_FAIL);
|
|
}/* end of function GetExtendedControl */
|
|
|
|
/*************************************************************************/
|
|
/* Function: GetBorder */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::GetBorder(LPRECT lprectBorder){
|
|
|
|
GET_INPLACEUIWINDOW
|
|
return(pUIWindow->GetBorder(lprectBorder));
|
|
}/* end of function GetBorder */
|
|
|
|
/*************************************************************************/
|
|
/* Function: RequestBorderSpace */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::RequestBorderSpace(LPCBORDERWIDTHS pborderwidths){
|
|
|
|
GET_INPLACEUIWINDOW
|
|
return(pUIWindow->RequestBorderSpace(pborderwidths));
|
|
}/* end of function RequestBorderSpace */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetBorderSpace */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::SetBorderSpace(LPCBORDERWIDTHS pborderwidths){
|
|
|
|
GET_INPLACEUIWINDOW
|
|
return(pUIWindow->SetBorderSpace(pborderwidths));
|
|
}/* end of function SetBorderSpace */
|
|
|
|
/*************************************************************************/
|
|
/* Function: SetActiveObject */
|
|
/* Description: Sets the active object on the container to which we */
|
|
/* send messagess. */
|
|
/*************************************************************************/
|
|
STDMETHODIMP CContainerObject::SetActiveObject(IOleInPlaceActiveObject* pActiveObject, LPCOLESTR pszObjName){
|
|
|
|
GET_INPLACEUIWINDOW
|
|
return(pUIWindow->SetActiveObject(pActiveObject, pszObjName));
|
|
}/* end of function SetActiveObject */
|
|
|
|
/*************************************************************************/
|
|
/* End of file: CCObj.cpp */
|
|
/*************************************************************************/
|