1481 lines
46 KiB
C++
1481 lines
46 KiB
C++
// Copyright (C) 1996-1997 Microsoft Corporation. All rights reserved.
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
//
|
|
// implementation of the interfaces required for inplace activation for
|
|
// COleControl
|
|
|
|
#include "header.h"
|
|
|
|
#include "CtlHelp.H"
|
|
#include "StdEnum.H"
|
|
#include "ctrlobj.h"
|
|
|
|
#ifndef _DEBUG
|
|
#undef THIS_FILE
|
|
static const char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
// External Functions
|
|
BOOL IsBusy() ; // See wwheel.cpp - TRUE if we are merging.
|
|
|
|
// all controls support the following in-place verbs at an absolute minimum.
|
|
|
|
#define CINPLACEVERBS 4
|
|
|
|
const VERBINFO rgInPlaceVerbs [] = {
|
|
{ OLEIVERB_SHOW, 0, 0, 0},
|
|
{ OLEIVERB_HIDE, 0, 0, 0},
|
|
{ OLEIVERB_INPLACEACTIVATE, 0, 0, 0},
|
|
{ OLEIVERB_PRIMARY, 0, 0, 0}
|
|
};
|
|
|
|
// NOTE: Resource ID for Properties string must be 1000
|
|
|
|
const VERBINFO ovProperties =
|
|
{ CTLIVERB_PROPERTIES, 1000, 0, OLEVERBATTRIB_ONCONTAINERMENU };
|
|
|
|
const VERBINFO ovUIActivate =
|
|
{ OLEIVERB_UIACTIVATE, 0, 0, 0};
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetControlInfo (IOleControl)
|
|
//=--------------------------------------------------------------------------=
|
|
// returns some information on a control, such as an accelerator table, and
|
|
// flags. really used for keyboard handling and mnemonics
|
|
//
|
|
// Parameters:
|
|
// CONTROLINFO * - [in] where to put said information
|
|
|
|
STDMETHODIMP COleControl::GetControlInfo(CONTROLINFO *pControlInfo)
|
|
{
|
|
DBWIN("COleControl::GetControlInfo()\n");
|
|
|
|
CHECK_POINTER(pControlInfo);
|
|
|
|
// certain hosts have a bug in which it doesn't initialize the cb in the
|
|
// CONTROLINFO structure, so we can only assert on that here.
|
|
|
|
ASSERT_COMMENT(pControlInfo->cb == sizeof(CONTROLINFO), "Host doesn't initialize CONTROLINFO structure");
|
|
|
|
// NOTE: control writers should override this routine if they want to
|
|
// return accelerator information in their control.
|
|
|
|
pControlInfo->hAccel = NULL;
|
|
pControlInfo->cAccel = NULL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::OnMnemonic [IOleControl]
|
|
//=--------------------------------------------------------------------------=
|
|
// the container has decided to pass on a key that the end-user has pressed to
|
|
// us. default implementation will be to just activate the control. people
|
|
// looking for more functionality should override this method.
|
|
//
|
|
// Parameters:
|
|
// LPMSG - [in] message for this mnemonic
|
|
|
|
STDMETHODIMP COleControl::OnMnemonic(LPMSG pMsg)
|
|
{
|
|
// OVERRIDE: default implementation is to just activate our control.
|
|
// user can override if they want more interesting behaviour.
|
|
DBWIN("COleControl::OnMnemonic()\n");
|
|
return InPlaceActivate(OLEIVERB_UIACTIVATE);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl:OnAmbientPropertyChange [IOleControl]
|
|
//=--------------------------------------------------------------------------=
|
|
// a container calls this whenever it changes an ambient property.
|
|
//
|
|
// Parameters:
|
|
// DISPID - [in] dispid of the property that changed.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK
|
|
|
|
STDMETHODIMP COleControl::OnAmbientPropertyChange(DISPID dispid)
|
|
{
|
|
// if we're being told about a change in mode [design/run] then
|
|
// remember that so our stashing of mode will update itself
|
|
// correctly
|
|
DBWIN("COleControl::OnAmbientPropertyChange()\n");
|
|
|
|
if (dispid == DISPID_AMBIENT_USERMODE || dispid == DISPID_UNKNOWN)
|
|
m_fModeFlagValid = FALSE;
|
|
|
|
// just pass this on to the derived control and see if they want
|
|
// to do anything with it.
|
|
//
|
|
AmbientPropertyChanged(dispid);
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControL::FreezeEvents [IOleControl]
|
|
//=--------------------------------------------------------------------------=
|
|
// allows a container to freeze all of a controls events. when events are
|
|
// frozen, a control will not fire any of them.
|
|
//
|
|
// Parameters:
|
|
// BOOL - [in] TRUE means FREEZE, FALSE means THAW
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK
|
|
//
|
|
// Notes:
|
|
// - we maintain an internal count of freezes versus thaws.
|
|
|
|
STDMETHODIMP COleControl::FreezeEvents(BOOL fFreeze)
|
|
{
|
|
// OVERRIDE: by default, we don't care. user can override if they want to.
|
|
DBWIN("COleControl::FreezeEvents()\n");
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::SetClientSite [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// informs the embedded object [control] of it's client site [display
|
|
// location] within it's container
|
|
//
|
|
// Parameters:
|
|
// IOleClientSite * - [in] pointer to client site.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_UNEXPECTED
|
|
|
|
STDMETHODIMP COleControl::SetClientSite(IOleClientSite *pClientSite)
|
|
{
|
|
RELEASE_OBJECT(m_pClientSite);
|
|
RELEASE_OBJECT(m_pControlSite);
|
|
// RELEASE_OBJECT(m_pSimpleFrameSite);
|
|
|
|
// store away the new client site
|
|
|
|
m_pClientSite = pClientSite;
|
|
|
|
// if we've actually got one, then get some other interfaces we want to keep
|
|
// around, and keep a handle on it
|
|
|
|
if (m_pClientSite) {
|
|
m_pClientSite->AddRef();
|
|
m_pClientSite->QueryInterface(IID_IOleControlSite, (void **)&m_pControlSite);
|
|
|
|
#ifdef _DEBUG
|
|
if (OLEMISCFLAGSOFCONTROL(m_ObjectType) & OLEMISC_SIMPLEFRAME)
|
|
ASSERT_COMMENT(FALSE, "We took out simple frame support...");
|
|
// m_pClientSite->QueryInterface(IID_ISimpleFrameSite, (void **)&m_pSimpleFrameSite);
|
|
#endif
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetClientSite [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// obtains a pointer to the controls client site.
|
|
//
|
|
// Parameters:
|
|
// IOleClientSite ** - [out]
|
|
|
|
STDMETHODIMP COleControl::GetClientSite(IOleClientSite **ppClientSite)
|
|
{
|
|
CHECK_POINTER(ppClientSite);
|
|
|
|
*ppClientSite = m_pClientSite;
|
|
ADDREF_OBJECT(*ppClientSite);
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::SetHostNames [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Provides the control with the name of its container application and the
|
|
// compound document in which it is embedded
|
|
//
|
|
// Parameters:
|
|
// LPCOLESTR - [in] name of container application
|
|
// LPCOLESTR - [in] name of container document
|
|
|
|
STDMETHODIMP COleControl::SetHostNames(LPCOLESTR szContainerApp,
|
|
LPCOLESTR szContainerObject)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::Close [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Changes the control from the running to the loaded state
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] indicates whether to save the object before closing
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, OLE_E_PROMPTSAVECANCELLED
|
|
|
|
STDMETHODIMP COleControl::Close(DWORD dwSaveOption)
|
|
{
|
|
HRESULT hr;
|
|
|
|
if (m_fInPlaceActive) {
|
|
hr = InPlaceDeactivate();
|
|
RETURN_ON_FAILURE(hr);
|
|
}
|
|
|
|
#if 0
|
|
// handle the save flag.
|
|
|
|
14-Aug-1997 [ralphw] We don't support any form of saving
|
|
|
|
if ((dwSaveOption == OLECLOSE_SAVEIFDIRTY || dwSaveOption == OLECLOSE_PROMPTSAVE) && m_fDirty) {
|
|
if (m_pClientSite) m_pClientSite->SaveObject();
|
|
if (m_pOleAdviseHolder) m_pOleAdviseHolder->SendOnSave();
|
|
}
|
|
#endif
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::SetMoniker [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Notifies an object of its container's moniker, the object's own moniker
|
|
// relative to the container, or the object's full moniker
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] which moniker is being set
|
|
// IMoniker * - [in] the moniker
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_FAIL
|
|
//
|
|
// Notes:
|
|
// - we don't support monikers.
|
|
|
|
STDMETHODIMP COleControl::SetMoniker(DWORD dwWhichMoniker, IMoniker *pMoniker)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetMoniker [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Returns a embedded object's moniker, which the caller can use to link to
|
|
// the object
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] how it's assigned
|
|
// DWORD - [in] which moniker
|
|
// IMoniker ** - [out] duh.
|
|
//
|
|
// Output:
|
|
// HRESULT - E_NOTIMPL
|
|
//
|
|
// Notes:
|
|
// - we don't support monikers
|
|
|
|
STDMETHODIMP COleControl::GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker,
|
|
IMoniker **ppMonikerOut)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::InitFromData [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Initializes a newly created object with data from a specified data object,
|
|
// which can reside either in the same container or on the Clipboard
|
|
//
|
|
// Parameters:
|
|
// IDataObject* - [in] data object with the data
|
|
// BOOL - [in] how object is created
|
|
// DWORD - reserved
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, S_FALSE, E_NOTIMPL, OLE_E_NOTRUNNING
|
|
//
|
|
// Notes:
|
|
// - we don't have data object support
|
|
|
|
STDMETHODIMP COleControl::InitFromData(IDataObject *pDataObject,
|
|
BOOL fCreation, DWORD dwReserved)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetClipboardData [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Retrieves a data object containing the current contents of the control.
|
|
// Using the pointer to this data object, it is possible to create a new control
|
|
// with the same data as the original
|
|
//
|
|
// Parameters:
|
|
// DWORD - reserved
|
|
// IDataObject ** - [out] data object for this control
|
|
//
|
|
// Output:
|
|
// HREUSLT - S_OK, E_NOTIMPL, OLE_E_NOTRUNNING
|
|
//
|
|
// Notes:
|
|
//
|
|
|
|
STDMETHODIMP COleControl::GetClipboardData(DWORD dwReserved,
|
|
IDataObject **ppDataObject)
|
|
{
|
|
*ppDataObject = NULL; // be a good neighbour
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::DoVerb [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Requests an object to perform an action in response to an end-user's
|
|
// action.
|
|
//
|
|
// Parameters:
|
|
// LONG - [in] verb to be performed
|
|
// LPMSG - [in] event that invoked the verb
|
|
// IOleClientSite * - [in] the controls active client site
|
|
// LONG - [in] reserved
|
|
// HWND - [in] handle of window containing the object.
|
|
// LPCRECT - [in] pointer to objects's display rectangle
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, OLE_E_NOTINPLACEACTIVE, OLE_E_CANT_BINDTOSOURCE,
|
|
// DV_E_LINK, OLEOBJ_S_CANNOT_DOVERB_NOW, OLEOBJ_S_INVALIDHWND,
|
|
// OLEOBJ_E_NOVERBS, OLEOBJ_S_INVALIDVERB, MK_E_CONNECT,
|
|
// OLE_CLASSDIFF, E_NOTIMPL
|
|
|
|
STDMETHODIMP COleControl::DoVerb(LONG lVerb, LPMSG pMsg,
|
|
IOleClientSite *pActiveSite, LONG lIndex, HWND hwndParent,
|
|
LPCRECT prcPosRect)
|
|
{
|
|
HRESULT hr;
|
|
|
|
switch (lVerb) {
|
|
case OLEIVERB_SHOW:
|
|
case OLEIVERB_INPLACEACTIVATE:
|
|
case OLEIVERB_UIACTIVATE:
|
|
// Check to see if we are merging?
|
|
if (IsBusy())
|
|
{
|
|
// We cannot precess these if we are merging.
|
|
return OLEOBJ_S_CANNOT_DOVERB_NOW ;
|
|
}
|
|
else
|
|
{
|
|
return InPlaceActivate(lVerb);
|
|
}
|
|
|
|
case OLEIVERB_HIDE:
|
|
UIDeactivate();
|
|
if (m_fInPlaceVisible)
|
|
SetInPlaceVisible(FALSE);
|
|
return S_OK;
|
|
|
|
// we used to have OLEIVERB_PRIMARY InPlaceActivate Ourselves, but it
|
|
// turns out that the CDK and certain hosts expect this to show the
|
|
// properties instead. Users can change what this verb does at will.
|
|
|
|
case OLEIVERB_PRIMARY:
|
|
case CTLIVERB_PROPERTIES:
|
|
case OLEIVERB_PROPERTIES:
|
|
{
|
|
// show the frame ourselves if the hose can't.
|
|
|
|
if (m_pControlSite) {
|
|
hr = m_pControlSite->ShowPropertyFrame();
|
|
if (hr != E_NOTIMPL)
|
|
return hr;
|
|
}
|
|
IUnknown *pUnk = (IUnknown *)(IOleObject *)this;
|
|
MAKE_WIDEPTR_FROMANSI(pwsz, NAMEOFOBJECT(m_ObjectType));
|
|
|
|
#if 0
|
|
ModalDialog(TRUE);
|
|
hr = OleCreatePropertyFrame(GetActiveWindow(),
|
|
GetSystemMetrics(SM_CXSCREEN) / 2,
|
|
GetSystemMetrics(SM_CYSCREEN) / 2,
|
|
pwsz,
|
|
1,
|
|
&pUnk,
|
|
CPROPPAGESOFCONTROL(m_ObjectType),
|
|
(LPCLSID)*(PPROPPAGESOFCONTROL(m_ObjectType)),
|
|
g_lcidLocale,
|
|
NULL, NULL);
|
|
ModalDialog(FALSE);
|
|
#endif
|
|
return hr;
|
|
}
|
|
|
|
default:
|
|
// if it's a derived-control defined verb, pass it on to them
|
|
//
|
|
if (lVerb > 0) {
|
|
hr = DoCustomVerb(lVerb);
|
|
|
|
if (hr == OLEOBJ_S_INVALIDVERB) {
|
|
// unrecognised verb -- just do the primary verb and
|
|
// activate the sucker.
|
|
//
|
|
hr = InPlaceActivate(OLEIVERB_PRIMARY);
|
|
return (FAILED(hr)) ? hr : OLEOBJ_S_INVALIDVERB;
|
|
} else
|
|
return hr;
|
|
}
|
|
else {
|
|
FAIL("Unrecognized Negative verb in DoVerb().");
|
|
return E_NOTIMPL;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// dead code
|
|
FAIL("this should be dead code!");
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::EnumVerbs [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// create an enumerator object for the verbs this object supports.
|
|
//
|
|
// Parameters:
|
|
// IEnumOleVERB ** - [out] new enumerator.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_OUTOFMEMORY
|
|
|
|
STDMETHODIMP COleControl::EnumVerbs(IEnumOLEVERB **ppEnumVerbs)
|
|
{
|
|
int cVerbs;
|
|
OLEVERB *rgVerbs, *pVerb;
|
|
|
|
DWORD dw = OLEMISCFLAGSOFCONTROL(m_ObjectType);
|
|
BOOL fCanInPlace = !(dw & OLEMISC_INVISIBLEATRUNTIME) || (dw & OLEMISC_ACTIVATEWHENVISIBLE);
|
|
BOOL fCanUIActivate = !(dw & OLEMISC_NOUIACTIVATE);
|
|
BOOL fHasProperties = (CPROPPAGESOFCONTROL(m_ObjectType) != 0);
|
|
|
|
int cVerbExtra = CCUSTOMVERBSOFCONTROL(m_ObjectType);
|
|
|
|
// count up all the verbs
|
|
|
|
cVerbs = (fCanInPlace ? CINPLACEVERBS : 0) + (fCanUIActivate ? 1 : 0)
|
|
+ (fHasProperties ? 1 : 0) + cVerbExtra;
|
|
|
|
// if there aren't any, this suddenly gets really easy !
|
|
|
|
if (cVerbs == 0)
|
|
return OLEOBJ_E_NOVERBS;
|
|
|
|
if (! (rgVerbs = (OLEVERB *) lcCalloc(cVerbs * sizeof(OLEVERB))))
|
|
return E_OUTOFMEMORY;
|
|
|
|
// start copying over verbs. first, the in-place guys
|
|
|
|
pVerb = rgVerbs;
|
|
if (fCanInPlace) {
|
|
memcpy(pVerb, rgInPlaceVerbs, CINPLACEVERBS * sizeof(OLEVERB));
|
|
pVerb += CINPLACEVERBS;
|
|
}
|
|
|
|
if (fCanUIActivate)
|
|
memcpy(pVerb++, &ovUIActivate, sizeof(OLEVERB));
|
|
|
|
// if their control has properties, copy that over now.
|
|
//
|
|
if (fHasProperties) {
|
|
memcpy(pVerb, &ovProperties, sizeof(OLEVERB));
|
|
pVerb++;
|
|
}
|
|
|
|
// finally, any custom verbs!
|
|
//
|
|
if (cVerbExtra) {
|
|
memcpy(pVerb, CUSTOMVERBSOFCONTROL(m_ObjectType), sizeof(OLEVERB) * cVerbExtra);
|
|
}
|
|
|
|
*ppEnumVerbs = (IEnumOLEVERB *) (IEnumGeneric *) new CStandardEnum(IID_IEnumOLEVERB,
|
|
cVerbs, sizeof(OLEVERB), rgVerbs, CopyOleVerb);
|
|
if (!*ppEnumVerbs)
|
|
return E_OUTOFMEMORY;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::Update [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Updates an object handler's or link object's data or view caches.
|
|
|
|
STDMETHODIMP COleControl::Update(void)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::IsUpToDate [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Checks recursively whether or not an object is up to date.
|
|
|
|
STDMETHODIMP COleControl::IsUpToDate(void)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetUserClassID [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Returns the controls class identifier, the CLSID corresponding to the
|
|
// string identifying the object to an end user.
|
|
//
|
|
// Parameters:
|
|
// CLSID * - [in] where to put the CLSID
|
|
|
|
STDMETHODIMP COleControl::GetUserClassID(CLSID *pclsid)
|
|
{
|
|
// this is the same as IPersist::GetClassID
|
|
|
|
return GetClassID(pclsid);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetUserType [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Retrieves the user-type name of the control for display in user-interface
|
|
// elements such as menus, list boxes, and dialog boxes.
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] specifies the form of the type name.
|
|
// LPOLESTR * - [out] where to put user type
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, OLE_S_USEREG, E_OUTOFMEMORY
|
|
|
|
STDMETHODIMP COleControl::GetUserType(DWORD dwFormOfType,
|
|
LPOLESTR *ppszUserType)
|
|
{
|
|
*ppszUserType = OLESTRFROMANSI(NAMEOFOBJECT(m_ObjectType));
|
|
return (*ppszUserType) ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::SetExtent [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Informs the control of how much display space its container has assigned it.
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] which form or 'aspect' is to be displayed.
|
|
// SIZEL * - [in] size limit for the control.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_FAIL, OLE_E_NOTRUNNING
|
|
|
|
STDMETHODIMP COleControl::SetExtent(DWORD dwDrawAspect, SIZEL *psizel)
|
|
{
|
|
SIZE sl;
|
|
RECT rect;
|
|
BOOL f;
|
|
|
|
if (dwDrawAspect & DVASPECT_CONTENT) {
|
|
|
|
// change the units to pixels, and resize the control.
|
|
|
|
HiMetricToPixel(psizel, &sl);
|
|
|
|
// first call the user version. if they return FALSE, they want
|
|
// to keep their current size
|
|
|
|
f = OnSetExtent(&sl);
|
|
if (f)
|
|
HiMetricToPixel(psizel, &m_Size);
|
|
|
|
// set things up with our HWND if we've got one.
|
|
|
|
if (!m_pInPlaceSiteWndless) {
|
|
if (m_fInPlaceActive) {
|
|
|
|
// theoretically, one should not need to call OnPosRectChange
|
|
// here, but there appear to be a few host related issues that
|
|
// will make us keep it here. we won't, however, bother with
|
|
// windowless ole controls, since they are all new hosts who
|
|
// should know better
|
|
|
|
GetWindowRect(m_hwnd, &rect);
|
|
MapWindowPoints(NULL, m_hwndParent, (LPPOINT)&rect, 2);
|
|
rect.right = rect.left + m_Size.cx;
|
|
rect.bottom = rect.top + m_Size.cy;
|
|
m_pInPlaceSite->OnPosRectChange(&rect);
|
|
|
|
if (m_hwnd) {
|
|
// just go and resize
|
|
|
|
SetWindowPos(m_hwnd, 0, 0, 0, m_Size.cx, m_Size.cy,
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
} else if (m_hwnd) {
|
|
SetWindowPos(m_hwnd, NULL, 0, 0, m_Size.cx, m_Size.cy, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
} else {
|
|
ViewChanged();
|
|
}
|
|
} else
|
|
if (m_pInPlaceSite) m_pInPlaceSite->OnPosRectChange(&rect);
|
|
|
|
// return code depending on whether or not user accepted given
|
|
// size
|
|
|
|
return (f) ? S_OK : E_FAIL;
|
|
|
|
} else {
|
|
// we don't support any other aspects.
|
|
|
|
return DV_E_DVASPECT;
|
|
}
|
|
|
|
// dead code
|
|
FAIL("This should be dead code");
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetExtent [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Retrieves the control's current display size.
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] aspect
|
|
// SIZEL * - [in] where to put results
|
|
//
|
|
// Output:
|
|
// S_OK, E_INVALIDARG
|
|
//
|
|
// Notes:
|
|
//
|
|
|
|
STDMETHODIMP COleControl::GetExtent(DWORD dwDrawAspect, SIZEL *pSizeLOut)
|
|
{
|
|
|
|
if (dwDrawAspect & DVASPECT_CONTENT) {
|
|
PixelToHiMetric((const SIZEL *)&m_Size, pSizeLOut);
|
|
return S_OK;
|
|
} else {
|
|
return DV_E_DVASPECT;
|
|
}
|
|
|
|
// dead code
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::Advise [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// establishes and advisory connection between the control and the container,
|
|
// in which the control will notify the container of certain events.
|
|
//
|
|
// Parameters:
|
|
// IAdviseSink * - [in] advise sink of calling object
|
|
// DWORD - [out] cookie
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_OUTOFMEMORY
|
|
|
|
STDMETHODIMP COleControl::Advise(IAdviseSink *pAdviseSink,
|
|
DWORD *pdwConnection)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// if we haven't yet created a standard advise holder object, do so
|
|
// now
|
|
|
|
if (!m_pOleAdviseHolder) {
|
|
hr = CreateOleAdviseHolder(&m_pOleAdviseHolder);
|
|
RETURN_ON_FAILURE(hr);
|
|
}
|
|
|
|
// just get it to do the work for us!
|
|
|
|
return m_pOleAdviseHolder->Advise(pAdviseSink, pdwConnection);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::Unadvise [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Deletes a previously established advisory connection.
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] connection cookie
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_FAIL, OLE_E_NOCONNECTION
|
|
|
|
STDMETHODIMP COleControl::Unadvise(DWORD dwConnection)
|
|
{
|
|
if (!m_pOleAdviseHolder) {
|
|
FAIL("Somebody called Unadvise on IOleObject without calling Advise!");
|
|
CONNECT_E_NOCONNECTION;
|
|
}
|
|
|
|
return m_pOleAdviseHolder->Unadvise(dwConnection);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::EnumAdvise [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Enumerates the advisory connections registered for an object, so a container
|
|
// can know what to release prior to closing down.
|
|
//
|
|
// Parameters:
|
|
// IEnumSTATDATA ** - [out] where to put enumerator
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_FAIL, E_NOTIMPL
|
|
|
|
STDMETHODIMP COleControl::EnumAdvise ( IEnumSTATDATA **ppEnumOut )
|
|
{
|
|
if (!m_pOleAdviseHolder) {
|
|
FAIL("Somebody Called EnumAdvise without setting up any connections");
|
|
*ppEnumOut = NULL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
return m_pOleAdviseHolder->EnumAdvise(ppEnumOut);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetMiscStatus [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Returns a value indicating the status of an object at creation and loading.
|
|
//
|
|
// Parameters:
|
|
// DWORD - [in] aspect desired
|
|
// DWORD * - [out] where to put the bits.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, OLE_S_USEREG, CO_E_CLASSNOTREG, CO_E_READREGDB
|
|
//
|
|
// Notes:
|
|
//
|
|
|
|
STDMETHODIMP COleControl::GetMiscStatus(DWORD dwAspect, DWORD *pdwStatus)
|
|
{
|
|
CHECK_POINTER(pdwStatus);
|
|
|
|
if (dwAspect == DVASPECT_CONTENT) {
|
|
*pdwStatus = OLEMISCFLAGSOFCONTROL(m_ObjectType);
|
|
return S_OK;
|
|
}
|
|
else
|
|
return DV_E_DVASPECT;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::SetColorScheme [IOleObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Specifies the color palette that the object application should use when it
|
|
// edits the specified object.
|
|
//
|
|
// Parameters:
|
|
// LOGPALETTE * - [in] new palette
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_NOTIMPL, OLE_E_PALETTE, OLE_E_NOTRUNNING
|
|
//
|
|
// Notes:
|
|
// - we don't care.
|
|
|
|
STDMETHODIMP COleControl::SetColorScheme(LOGPALETTE *pLogpal)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetWindow [IOleWindow/IOleInPlaceObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Returns the window handle to one of the windows participating in in-place
|
|
// activation (frame, document, parent, or in-place object window).
|
|
//
|
|
// Parameters:
|
|
// HWND * - [out] where to return window handle.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_INVALIDARG, E_OUTOFMEMORY, E_UNEXPECTED, E_FAIL
|
|
//
|
|
// Notes:
|
|
// - this routine has slightly different semantics for windowless controls
|
|
|
|
STDMETHODIMP COleControl::GetWindow(HWND *phwnd)
|
|
{
|
|
// if we're windowles, then we want to return E_FAIL for this so hosts
|
|
// know we're windowless
|
|
|
|
if (m_pInPlaceSiteWndless)
|
|
return E_FAIL;
|
|
|
|
// otherwise, just return our outer window.
|
|
//
|
|
*phwnd = m_hwnd;
|
|
|
|
return (*phwnd) ? S_OK : E_UNEXPECTED;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::ContextSensitiveHelp [IOleWindow/IOleInPlaceObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Determines whether context-sensitive help mode should be entered during an
|
|
// in-place activation session.
|
|
//
|
|
// Parameters:
|
|
// BOOL - [in] whether or not to enter help mode.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_INVALIDARG, E_OUTOFMEMORY, E_UNEXPECTED
|
|
|
|
STDMETHODIMP COleControl::ContextSensitiveHelp(BOOL fEnterMode)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::InPlaceActivate
|
|
//=--------------------------------------------------------------------------=
|
|
// activates the control, and depending on the verb, optionally ui activates
|
|
// it as well.
|
|
//
|
|
// Parameters:
|
|
// LONG - [in] the verb that caused us to activate
|
|
//
|
|
// Output:
|
|
// HRESULT
|
|
//
|
|
// Notes:
|
|
// - this is spaghetti code at it's worst. effectively, we have to
|
|
// be able to handle three types of site pointers -- IOleInPlaceSIte,
|
|
// IOleInPlaceSiteEx, and IOleInPlaceSiteWindowless. not terribly
|
|
// pretty.
|
|
//
|
|
|
|
HRESULT COleControl::InPlaceActivate(LONG lVerb)
|
|
{
|
|
BOOL f;
|
|
SIZEL sizel;
|
|
IOleInPlaceSiteEx *pIPSEx = NULL;
|
|
HRESULT hr;
|
|
BOOL fNoRedraw = FALSE;
|
|
|
|
// if we don't have a client site, then there's not much to do.
|
|
|
|
if (!m_pClientSite)
|
|
return S_OK;
|
|
//
|
|
// <mc>
|
|
// This code attempts to insure that we don't give UI activation to a control that is not
|
|
// enabled.
|
|
// </mc>
|
|
if ( m_hwnd )
|
|
{
|
|
HWND hWndButton;
|
|
if ( !(hWndButton = ::GetWindow(m_hwnd, GW_CHILD)) || !IsWindowEnabled(hWndButton) )
|
|
return OLEOBJ_S_CANNOT_DOVERB_NOW;
|
|
}
|
|
//
|
|
// <mc>
|
|
// This code catches the control creation entry to this function and calls a new virtual to insure that we
|
|
// do indeed need a control window. If we don't need a control window we MUST return E_NOTIMPL from the
|
|
// doverb() call which is the caller of this function. See ShouldCreateWindow() for more details.
|
|
// </mc>
|
|
if ( !m_hwnd )
|
|
{
|
|
if (! ShouldCreateWindow() )
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
// get an InPlace site pointer.
|
|
|
|
if (!GetInPlaceSite()) {
|
|
|
|
// if they want windowless support, then we want IOleInPlaceSiteWindowless
|
|
|
|
if (FCONTROLISWINDOWLESS(m_ObjectType))
|
|
m_pClientSite->QueryInterface(IID_IOleInPlaceSiteWindowless, (void **)&m_pInPlaceSiteWndless);
|
|
|
|
// if we're not able to do windowless siting, then we'll just get an
|
|
// IOleInPlaceSite pointer.
|
|
|
|
if (!m_pInPlaceSiteWndless) {
|
|
hr = m_pClientSite->QueryInterface(IID_IOleInPlaceSite, (void **)&m_pInPlaceSite);
|
|
RETURN_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
// now, we want an IOleInPlaceSiteEx pointer for windowless and flicker free
|
|
// activation. if we're windowless, we've already got it, else we need to
|
|
// try and get it
|
|
|
|
if (m_pInPlaceSiteWndless) {
|
|
pIPSEx = (IOleInPlaceSiteEx *)m_pInPlaceSiteWndless;
|
|
pIPSEx->AddRef();
|
|
} else
|
|
m_pClientSite->QueryInterface(IID_IOleInPlaceSiteEx, (void **)&pIPSEx);
|
|
|
|
// if we're not already active, go and do it.
|
|
//
|
|
if (!m_fInPlaceActive) {
|
|
OLEINPLACEFRAMEINFO InPlaceFrameInfo;
|
|
RECT rcPos, rcClip;
|
|
|
|
// if we have a windowless site, see if we can go in-place windowless
|
|
// active
|
|
//
|
|
hr = S_FALSE;
|
|
if (m_pInPlaceSiteWndless) {
|
|
hr = m_pInPlaceSiteWndless->CanWindowlessActivate();
|
|
CLEANUP_ON_FAILURE(hr);
|
|
|
|
// if they refused windowless, we'll try windowed
|
|
//
|
|
if (S_OK != hr) {
|
|
RELEASE_OBJECT(m_pInPlaceSiteWndless);
|
|
hr = m_pClientSite->QueryInterface(IID_IOleInPlaceSite, (void **)&m_pInPlaceSite);
|
|
CLEANUP_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
// just try regular windowed in-place activation
|
|
//
|
|
if (hr != S_OK) {
|
|
hr = m_pInPlaceSite->CanInPlaceActivate();
|
|
if (hr != S_OK) {
|
|
hr = (FAILED(hr)) ? E_FAIL : hr;
|
|
goto CleanUp;
|
|
}
|
|
}
|
|
|
|
// if we are here, then we have permission to go in-place active.
|
|
// now, announce our intentions to actually go ahead and do this.
|
|
//
|
|
hr = (pIPSEx) ? pIPSEx->OnInPlaceActivateEx(&fNoRedraw, (m_pInPlaceSiteWndless) ? ACTIVATE_WINDOWLESS : 0)
|
|
: m_pInPlaceSite->OnInPlaceActivate();
|
|
CLEANUP_ON_FAILURE(hr);
|
|
|
|
// if we're here, we're ready to go in-place active. we just need
|
|
// to set up some flags, and then create the window [if we have
|
|
// one]
|
|
//
|
|
m_fInPlaceActive = TRUE;
|
|
|
|
// we need to get some information about our location in the parent
|
|
// window, as well as some information about the parent
|
|
//
|
|
InPlaceFrameInfo.cb = sizeof(OLEINPLACEFRAMEINFO);
|
|
hr = GetInPlaceSite()->GetWindow(&m_hwndParent);
|
|
if (SUCCEEDED(hr))
|
|
hr = GetInPlaceSite()->GetWindowContext(&m_pInPlaceFrame, &m_pInPlaceUIWindow, &rcPos, &rcClip, &InPlaceFrameInfo);
|
|
CLEANUP_ON_FAILURE(hr);
|
|
|
|
// make sure we'll display ourselves in the correct location with the correct size
|
|
//
|
|
sizel.cx = rcPos.right - rcPos.left;
|
|
sizel.cy = rcPos.bottom - rcPos.top;
|
|
f = OnSetExtent(&sizel);
|
|
if (f)
|
|
m_Size = sizel;
|
|
SetObjectRects(&rcPos, &rcClip);
|
|
|
|
// finally, create our window if we have to!
|
|
|
|
if (!m_pInPlaceSiteWndless) {
|
|
|
|
SetInPlaceParent(m_hwndParent);
|
|
|
|
// create the window, and display it. die horribly if we couldnt'
|
|
//
|
|
if (!CreateInPlaceWindow(rcPos.left, rcPos.top, fNoRedraw)) {
|
|
hr = E_FAIL;
|
|
goto CleanUp;
|
|
}
|
|
}
|
|
}
|
|
|
|
// don't need this any more
|
|
//
|
|
RELEASE_OBJECT(pIPSEx);
|
|
|
|
// if we're not inplace visible yet, do so now.
|
|
//
|
|
if (!m_fInPlaceVisible)
|
|
SetInPlaceVisible(TRUE);
|
|
|
|
// if we weren't asked to UIActivate, then we're done.
|
|
//
|
|
if (lVerb != OLEIVERB_PRIMARY && lVerb != OLEIVERB_UIACTIVATE)
|
|
return S_OK;
|
|
|
|
// if we're not already UI active, do sow now.
|
|
//
|
|
if (!m_fUIActive) {
|
|
m_fUIActive = TRUE;
|
|
|
|
// inform the container of our intent
|
|
|
|
GetInPlaceSite()->OnUIActivate();
|
|
|
|
// take the focus [which is what UI Activation is all about !]
|
|
|
|
DBWIN("Activate focus");
|
|
SetFocus(TRUE);
|
|
|
|
// set ourselves up in the host.
|
|
|
|
m_pInPlaceFrame->SetActiveObject((IOleInPlaceActiveObject *)this, NULL);
|
|
if (m_pInPlaceUIWindow)
|
|
m_pInPlaceUIWindow->SetActiveObject((IOleInPlaceActiveObject *)this, NULL);
|
|
|
|
// we have to explicitly say we don't wany any border space.
|
|
//
|
|
m_pInPlaceFrame->SetBorderSpace(NULL);
|
|
if (m_pInPlaceUIWindow)
|
|
m_pInPlaceUIWindow->SetBorderSpace(NULL);
|
|
}
|
|
|
|
// be-de-be-de-be-de that's all folks!
|
|
//
|
|
return S_OK;
|
|
|
|
CleanUp:
|
|
// something catastrophic happened [or, at least something bad].
|
|
// die a horrible fiery mangled painful death.
|
|
//
|
|
QUICK_RELEASE(pIPSEx);
|
|
m_fInPlaceActive = FALSE;
|
|
return hr;
|
|
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::InPlaceDeactivate [IOleInPlaceObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Deactivates an active in-place object and discards the object's undo state.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_UNEXPECTED
|
|
|
|
STDMETHODIMP COleControl::InPlaceDeactivate(void)
|
|
{
|
|
// if we're not in-place active yet, then this is easy.
|
|
|
|
if (!m_fInPlaceActive)
|
|
return S_OK;
|
|
|
|
// transition from UIActive back to active
|
|
//
|
|
if (m_fUIActive)
|
|
UIDeactivate();
|
|
|
|
m_fInPlaceActive = FALSE;
|
|
m_fInPlaceVisible = FALSE;
|
|
|
|
// if we have a window, tell it to go away.
|
|
//
|
|
if (m_hwnd) {
|
|
ASSERT_COMMENT(!m_pInPlaceSiteWndless, "internal state really messed up");
|
|
|
|
// so our window proc doesn't crash.
|
|
//
|
|
BeforeDestroyWindow();
|
|
SetWindowLong(m_hwnd, GWLP_USERDATA, 0xFFFFFFFF);
|
|
DestroyWindow(m_hwnd);
|
|
m_hwnd = NULL;
|
|
}
|
|
|
|
RELEASE_OBJECT(m_pInPlaceFrame);
|
|
RELEASE_OBJECT(m_pInPlaceUIWindow);
|
|
GetInPlaceSite()->OnInPlaceDeactivate();
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::UIDeactivate [IOleInPlaceObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// transitions us from UI Active to merely being active [visible] for
|
|
// a control, this doesn't mean all that much.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_UNEXPECTED
|
|
|
|
STDMETHODIMP COleControl::UIDeactivate(void)
|
|
{
|
|
// if we're not UIActive, not much to do.
|
|
//
|
|
if (!m_fUIActive)
|
|
return S_OK;
|
|
|
|
m_fUIActive = FALSE;
|
|
|
|
// notify frame windows, if appropriate, that we're no longer ui-active.
|
|
//
|
|
if (m_pInPlaceUIWindow) m_pInPlaceUIWindow->SetActiveObject(NULL, NULL);
|
|
m_pInPlaceFrame->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
|
|
//
|
|
GetInPlaceSite()->OnUIDeactivate(FALSE);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::SetObjectRects [IOleInPlaceObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Indicates how much of the control is visible.
|
|
//
|
|
// Parameters:
|
|
// LPCRECT - [in] position of the control.
|
|
// LPCRECT - [in] clipping rectangle for the control.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_INVALIDARG, E_OUTOFMEMORY, E_UNEXPECTED
|
|
//
|
|
// Notes:
|
|
//
|
|
|
|
#if 0
|
|
STDMETHODIMP COleControl::SetObjectRects(LPCRECT prcPos, LPCRECT prcClip)
|
|
{
|
|
BOOL fRemoveWindowRgn;
|
|
|
|
// verify our information
|
|
|
|
// This assertion doesn't seem valid because the container (IE 3) never
|
|
// calls SetExtent().
|
|
// ASSERT_COMMENT(m_Size.cx == (prcPos->right - prcPos->left) && m_Size.cy == (prcPos->bottom - prcPos->top), "Somebody called SetObjectRects without first setting the extent");
|
|
|
|
/*
|
|
* Move our window to the new location and handle clipping. Not
|
|
* applicable for windowless controls, since the container will be
|
|
* responsible for all clipping.
|
|
*/
|
|
|
|
if (m_hwnd) {
|
|
fRemoveWindowRgn = m_fUsingWindowRgn;
|
|
if (prcClip) {
|
|
// the container wants us to clip, so figure out if we really
|
|
// need to
|
|
|
|
RECT rcIXect;
|
|
if (IntersectRect(&rcIXect, prcPos, prcClip)) {
|
|
if (!EqualRect(&rcIXect, prcPos)) {
|
|
OffsetRect(&rcIXect, -(prcPos->left), -(prcPos->top));
|
|
SetWindowRgn(m_hwnd, CreateRectRgnIndirect(&rcIXect), TRUE);
|
|
m_fUsingWindowRgn = TRUE;
|
|
fRemoveWindowRgn = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fRemoveWindowRgn) {
|
|
SetWindowRgn(m_hwnd, NULL, TRUE);
|
|
m_fUsingWindowRgn = FALSE;
|
|
}
|
|
|
|
// set our control's location and size
|
|
// [people for whom zooming is important should set that up here]
|
|
|
|
if (!EqualRect(prcPos, &m_rcLocation)) {
|
|
m_Size.cx = (prcPos->right - prcPos->left);
|
|
m_Size.cy = (prcPos->bottom - prcPos->top);
|
|
SetWindowPos(m_hwnd, NULL, prcPos->left, prcPos->top, m_Size.cx, m_Size.cy, SWP_NOZORDER | SWP_NOACTIVATE);
|
|
CopyRect(&m_rcLocation, prcPos);
|
|
return S_OK;
|
|
}
|
|
}
|
|
|
|
// save out our current location. windowless controls want this more
|
|
// then windowed ones do, but everybody can have it just in case
|
|
|
|
// BUGBUG: 20-Apr-1997 [ralphw] why do we care about this for
|
|
// windowless controls
|
|
|
|
CopyRect(&m_rcLocation, prcPos);
|
|
|
|
return S_OK;
|
|
}
|
|
#endif
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::ReactivateAndUndo [IOleInPlaceObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Reactivates a previously deactivated object, undoing the last state of the object.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_NOTUNDOABLE
|
|
|
|
STDMETHODIMP COleControl::ReactivateAndUndo(void)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::OnWindowMessage [IOleInPlaceObjectWindowless]
|
|
//=--------------------------------------------------------------------------=
|
|
// this method lets the container dispatch a message to a windowless OLE
|
|
// object.
|
|
//
|
|
// Parameters:
|
|
// UINT - [in] the message
|
|
// WPARAM - [in] the messages wparam
|
|
// LPARAM - [in] duh.
|
|
// LRESULT * - [out] the output value
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK
|
|
//
|
|
// Notes:
|
|
// - people should call m_pInPlaceSiteWndless->OnDefWindowMessage [control
|
|
// writers should just call OcxDefWindowProc(msg, wparam, lparam)];
|
|
//
|
|
|
|
// REVIEW: if we don't have a windowless command, this should get nuked
|
|
|
|
STDMETHODIMP COleControl::OnWindowMessage(UINT msg, WPARAM wParam, LPARAM lParam, LRESULT *plResult)
|
|
{
|
|
// little bit of pre-processing -- we need to handle some cases here
|
|
// before passing the messages on
|
|
|
|
switch (msg) {
|
|
// make sure our UI Activation correctly matches the focus
|
|
//
|
|
case WM_KILLFOCUS:
|
|
case WM_SETFOCUS:
|
|
// give the control site focus notification
|
|
//
|
|
DBWIN("windowless focus");
|
|
if (m_fInPlaceActive && m_pControlSite)
|
|
m_pControlSite->OnFocus(msg == WM_SETFOCUS);
|
|
break;
|
|
}
|
|
|
|
// just pass it to the control's window proc.
|
|
|
|
*plResult = WindowProc(msg, wParam, lParam);
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetDropTarget [IOleInPlaceObjectWindowless]
|
|
//=--------------------------------------------------------------------------=
|
|
// this method returns a pointer to the objects IDropTarget interface. since
|
|
// they do not have a window, windowless objects cannot register an IDropTarget
|
|
// interface.
|
|
//
|
|
// Parameters:
|
|
// IDropTarget ** - [out]
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, E_NOTIMPL
|
|
|
|
STDMETHODIMP COleControl::GetDropTarget(IDropTarget **ppDropTarget)
|
|
{
|
|
// OVERRIDE: if you want to do drag and drop and you're windowless,
|
|
// override me.
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::TranslateAccelerator [IOleInPlaceActiveObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Processes menu accelerator-key messages from the container's message queue.
|
|
//
|
|
// Parameters:
|
|
// LPMSG - [in] the message that has the special key in it.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK, S_FALSE, E_UNEXPECTED
|
|
|
|
STDMETHODIMP COleControl::TranslateAccelerator(LPMSG pmsg)
|
|
{
|
|
DBWIN("TranslateAccelerator");
|
|
|
|
// see if we want it or not.
|
|
|
|
if (OnSpecialKey(pmsg))
|
|
return S_OK;
|
|
|
|
// 30-Jul-1997 [ralphw] The docs don't talk about this, and I can't
|
|
// find anyone else who calls into controlsite.
|
|
|
|
// if not, then we want to forward it back to the site for further processing
|
|
|
|
if (m_pControlSite)
|
|
return m_pControlSite->TranslateAccelerator(pmsg, _SpecialKeyState());
|
|
|
|
// we didn't want it.
|
|
|
|
return S_FALSE;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::OnFrameWindowActivate [IOleInPlaceActiveObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Notifies the control when the container's top-level frame window is
|
|
// activated or deactivated.
|
|
//
|
|
// Parameters:
|
|
// BOOL - [in] state of containers top level window.
|
|
//
|
|
// Output:
|
|
// HRESULT - S_OK
|
|
|
|
STDMETHODIMP COleControl::OnFrameWindowActivate(BOOL fActivate)
|
|
{
|
|
// we're supposed to go UI active in this case
|
|
|
|
return InPlaceActivate(OLEIVERB_UIACTIVATE);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::OnDocWindowActivate [IOleInPlaceActiveObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Notifies the active control when the container's document window is
|
|
// activated or deactivated.
|
|
//
|
|
// Parameters:
|
|
// BOOL - state of mdi child window.
|
|
|
|
STDMETHODIMP COleControl::OnDocWindowActivate(BOOL fActivate)
|
|
{
|
|
// we're supposed to go UI active in this case
|
|
|
|
return InPlaceActivate(OLEIVERB_UIACTIVATE);
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::ResizeBorder [IOleInPlaceActiveObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Alerts the control that it needs to resize its border space.
|
|
//
|
|
// Parameters:
|
|
// LPCRECT - [in] new outer rectangle for border space
|
|
// IOleInPlaceUIWindow * - [in] the document or frame who's border has changed
|
|
// BOOL - [in] true if it was the fram window taht called.
|
|
|
|
STDMETHODIMP COleControl::ResizeBorder(LPCRECT prcBorder,
|
|
IOleInPlaceUIWindow *pInPlaceUIWindow, BOOL fFrame)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::EnableModeless [IOleInPlaceActiveObject]
|
|
//=--------------------------------------------------------------------------=
|
|
// Enables or disables modeless dialog boxes when the container creates or
|
|
// destroys a modal dialog box.
|
|
//
|
|
// Parameters:
|
|
// BOOL - [in] enable or disable modeless dialogs.
|
|
|
|
STDMETHODIMP COleControl::EnableModeless(BOOL fEnable)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::GetClassInfo [IProvideClassInfo]
|
|
//=--------------------------------------------------------------------------=
|
|
// returns the TypeInfo for the control's coclass.
|
|
//
|
|
// Parameters:
|
|
// ITypeInfo ** - [out]
|
|
//
|
|
|
|
STDMETHODIMP COleControl::GetClassInfo(ITypeInfo **ppTypeInfo)
|
|
{
|
|
ITypeLib *pTypeLib;
|
|
HRESULT hr;
|
|
|
|
CHECK_POINTER(ppTypeInfo);
|
|
*ppTypeInfo = NULL;
|
|
|
|
// go and get our type library.
|
|
// CONSIDER: - go to the same sorta scheme that we use for TypeInfo caching.
|
|
|
|
hr = LoadRegTypeLib(*g_pLibid, (USHORT)VERSIONOFOBJECT(m_ObjectType), 0,
|
|
LANGIDFROMLCID(g_lcidLocale), &pTypeLib);
|
|
if (FAILED(hr))
|
|
{
|
|
// Load and register our type library.
|
|
|
|
if (g_fServerHasTypeLibrary) {
|
|
char szTmp[MAX_PATH];
|
|
DWORD dwPathLen = GetModuleFileName(_Module.GetModuleInstance(), szTmp, MAX_PATH);
|
|
MAKE_WIDEPTR_FROMANSI(pwsz, szTmp);
|
|
|
|
hr = LoadTypeLib(pwsz, &pTypeLib);
|
|
RETURN_ON_FAILURE(hr);
|
|
hr = RegisterTypeLib(pTypeLib, pwsz, NULL);
|
|
if (FAILED(hr))
|
|
{
|
|
pTypeLib->Release();
|
|
return hr;
|
|
}
|
|
}
|
|
}
|
|
|
|
// got the typelib. get typeinfo for our coclass.
|
|
|
|
hr = pTypeLib->GetTypeInfoOfGuid((REFIID)CLSIDOFOBJECT(m_ObjectType), ppTypeInfo);
|
|
pTypeLib->Release();
|
|
RETURN_ON_FAILURE(hr);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::ViewChange [callable]
|
|
//=--------------------------------------------------------------------------=
|
|
// called whenever the view of the object has changed.
|
|
|
|
void COleControl::ViewChanged(void)
|
|
{
|
|
// send the view change notification to anybody listening.
|
|
|
|
if (m_pViewAdviseSink) {
|
|
m_pViewAdviseSink->OnViewChange(DVASPECT_CONTENT, -1);
|
|
|
|
// if they only asked to be advised once, kill the connection
|
|
|
|
if (m_fViewAdviseOnlyOnce)
|
|
SetAdvise(DVASPECT_CONTENT, 0, NULL);
|
|
}
|
|
}
|
|
|
|
//=--------------------------------------------------------------------------=
|
|
// COleControl::SetInPlaceVisible [helper]
|
|
//=--------------------------------------------------------------------------=
|
|
// controls the visibility of the control window.
|
|
//
|
|
// Parameters:
|
|
// BOOL - TRUE shows FALSE hides.
|
|
|
|
void COleControl::SetInPlaceVisible(BOOL fShow)
|
|
{
|
|
BOOL fVisible;
|
|
|
|
m_fInPlaceVisible = fShow;
|
|
|
|
// don't do anything if we don't have a window. otherwise, set it
|
|
|
|
if (m_hwnd) {
|
|
fVisible = ((GetWindowLong(m_hwnd, GWL_STYLE) & WS_VISIBLE) != 0);
|
|
|
|
if (fVisible && !fShow)
|
|
ShowWindow(m_hwnd, SW_HIDE);
|
|
else if (!fVisible && fShow)
|
|
ShowWindow(m_hwnd, SW_SHOWNA);
|
|
}
|
|
}
|