// Copyright (C) 1996-1997 Microsoft Corporation. All rights reserved.

#include "header.h"
#include "CtlHelp.H"
#include "StdEnum.H"
#include "internet.h"
#include "hhctrl.h"
#include <stddef.h>

#include <stdarg.h>

#ifndef _DEBUG
#undef THIS_FILE
static const char THIS_FILE[] = __FILE__;
#endif

// this is used in our window proc so that we can find out who was last created

static COleControl *s_pLastControlCreated;

//=--------------------------------------------------------------------------=
// COleControl::COleControl
//=--------------------------------------------------------------------------=
// constructor
//
// Parameters:
//   IUnknown *        - [in] controlling Unknown
//   int            - [in] type of primary dispatch interface OBJECT_TYPE_*
//   void *         - [in] pointer to entire object
//
// Notes:
//
COleControl::COleControl
(
   IUnknown *pUnkOuter,
   int     iPrimaryDispatch,
   void   *pMainInterface
)
: CAutomationObject(pUnkOuter, iPrimaryDispatch, pMainInterface),
  m_cpEvents(SINK_TYPE_EVENT),
  m_cpPropNotify(SINK_TYPE_PROPNOTIFY)
{
   // initialize all our variables -- we decided against using a memory-zeroing
   // memory allocator, so we sort of have to do this work now ...
   //
   m_nFreezeEvents = 0;

   m_pClientSite = NULL;
   m_pControlSite = NULL;
   m_pInPlaceSite = NULL;
   m_pInPlaceFrame = NULL;
   m_pInPlaceUIWindow = NULL;


   m_pInPlaceSiteWndless = NULL;

   // certain hosts don't like 0,0 as your initial size, so we're going to set
   // our initial size to 100,50 [so it's at least sort of visible on the screen]

   m_Size.cx = 100;
   m_Size.cy = 50;
   SetRectEmpty(&m_rcLocation);

   m_hwnd = NULL;
   m_hwndParent = NULL;

   m_nFreezeEvents = 0;
   // m_pSimpleFrameSite = NULL;
   m_pOleAdviseHolder = NULL;
   m_pViewAdviseSink = NULL;
   m_pDispAmbient = NULL;

   m_fDirty = FALSE;
   m_fModeFlagValid = FALSE;
   m_fInPlaceActive = FALSE;
   m_fInPlaceVisible = FALSE;
   m_fUIActive = FALSE;
   m_fSaveSucceeded = FALSE;
   m_fViewAdvisePrimeFirst = FALSE;
   m_fViewAdviseOnlyOnce = FALSE;
   m_fRunMode = FALSE;
}

//=--------------------------------------------------------------------------=
// COleControl::~COleControl
//=--------------------------------------------------------------------------=
// "We are all of us resigned to death; it's life we aren't resigned to."
//   - Graham Greene (1904-91)
//
// Notes:
//
COleControl::~COleControl()
{
   // if we've still got a window, go and kill it now.
   //
   if (m_hwnd) {
      // so our window proc doesn't crash.
      //
      SetWindowLong(m_hwnd, GWLP_USERDATA, 0xFFFFFFFF);
      DestroyWindow(m_hwnd);
   }

   // clean up all the pointers we're holding around.

   QUICK_RELEASE(m_pClientSite);
   QUICK_RELEASE(m_pControlSite);
   QUICK_RELEASE(m_pInPlaceSite);
   QUICK_RELEASE(m_pInPlaceFrame);
   QUICK_RELEASE(m_pInPlaceUIWindow);
   // QUICK_RELEASE(m_pSimpleFrameSite);
   QUICK_RELEASE(m_pOleAdviseHolder);
   QUICK_RELEASE(m_pViewAdviseSink);
   QUICK_RELEASE(m_pDispAmbient);

   QUICK_RELEASE(m_pInPlaceSiteWndless);
}

//=--------------------------------------------------------------------------=
// COleControl::InternalQueryInterface
//=--------------------------------------------------------------------------=
// derived-controls should delegate back to this when they decide to support
// additional interfaces
//
// Parameters:
//   REFIID    - [in]   interface they want
//   void **      - [out] where they want to put the resulting object ptr.
//
// Output:
//   HRESULT      - S_OK, E_NOINTERFACE
//
// Notes:
//   - NOTE: this function is speed critical!!!!
// Using the typedef'd enum lets use see what the value of riid.Data1 is

typedef enum {
    tgIUnknown                = 0x00000000,
    tgIClassFactory           = 0x00000001,
    tgIMalloc                 = 0x00000002,
    tgIMarshal                = 0x00000003,
    tgIPSFactory              = 0x00000009,
    tgILockBytes              = 0x0000000a,
    tgIStorage                = 0x0000000b,
    tgIStream                 = 0x0000000c,
    tgIEnumSTATSTG            = 0x0000000d,
    tgIBindCtx                = 0x0000000e,
    tgIMoniker                = 0x0000000f,
    tgIRunningObjectTable        = 0x00000010,
    tgIInternalMoniker        = 0x00000011,
    tgIRootStorage            = 0x00000012,
    tgIMessageFilter          = 0x00000016,
    tgIStdMarshalInfo            = 0x00000018,
    tgIExternalConnection        = 0x00000019,
    tgIWeakRef                = 0x0000001a,
    tgIEnumUnknown            = 0x00000100,
    tgIEnumString             = 0x00000101,
    tgIEnumMoniker            = 0x00000102,
    tgIEnumFORMATETC          = 0x00000103,
    tgIEnumOLEVERB            = 0x00000104,
    tgIEnumSTATDATA           = 0x00000105,
    tgIEnumGeneric            = 0x00000106,
    tgIEnumHolder             = 0x00000107,
    tgIEnumCallback           = 0x00000108,
    tgIPersistStream          = 0x00000109,
    tgIPersistStorage            = 0x0000010a,
    tgIPersistFile            = 0x0000010b,
    tgIPersist                = 0x0000010c,
    tgIViewObject             = 0x0000010d,
    tgIDataObject             = 0x0000010e,
    tgIAdviseSink             = 0x0000010f,
    tgIDataAdviseHolder       = 0x00000110,
    tgIOleAdviseHolder        = 0x00000111,
    tgIOleObject              = 0x00000112,
    tgIOleInPlaceObject       = 0x00000113,
    tgIOleWindow              = 0x00000114,
    tgIOleInPlaceUIWindow        = 0x00000115,
    tgIOleInPlaceFrame        = 0x00000116,
    tgIOleInPlaceActiveObject    = 0x00000117,
    tgIOleClientSite          = 0x00000118,
    tgIOleInPlaceSite            = 0x00000119,
    tgIParseDisplayName       = 0x0000011a,
    tgIOleContainer           = 0x0000011b,
    tgIOleItemContainer       = 0x0000011c,
    tgIOleLink                = 0x0000011d,
    tgIOleCache               = 0x0000011e,
    tgIOleManager             = 0x0000011f,
    tgIOlePresObj             = 0x00000120,
    tgIDropSource             = 0x00000121,
    tgIDropTarget             = 0x00000122,
    tgIAdviseSink2            = 0x00000125,
    tgIRunnableObject            = 0x00000126,
    tgIViewObject2            = 0x00000127,
    tgIOleCache2              = 0x00000128,
    tgIOleCacheControl        = 0x00000129,
    tgIDispatch               = 0x00020400,
    tgITypeInfo               = 0x00020401,
    tgITypeLib                = 0x00020402,
    tgITypeComp               = 0x00020403,
    tgIEnumVARIANT            = 0x00020404,
    tgICreateTypeInfo            = 0x00020405,
    tgICreateTypeLib          = 0x00020406,
    tgIPropertyPage2          = 0x01e44665,
    tgIOleInPlaceObjectWindowless   = 0x1c2056cc,
    tgIErrorInfo              = 0x1cf2b120,
    tgICreateErrorInfo        = 0x22f03340,
    tgIPerPropertyBrowsing       = 0x376bd3aa,
    tgIPersistPropertyBag        = 0x37D84F60,
    tgIAdviseSinkEx           = 0x3af24290,
    tgIViewObjectEx           = 0x3af24292,
    tgICategorizeProperties      = 0x4d07fc10,
    tgIPointerInactive        = 0x55980ba0,
    tgIFormExpert             = 0x5aac7f70,
    tgIOleInPlaceComponent       = 0x5efc7970,
    tgIGangConnectWithDefault    = 0x6d5140c0,
    tgIServiceProvider        = 0x6d5140c1,
    tgISelectionContainer        = 0x6d5140c6,
    tgIRequireClasses            = 0x6d5140d0,
    tgIProvideDynamicClassInfo   = 0x6d5140d1,
    tgIDataFrameExpert        = 0x73687490,
    tgISimpleFrameSite        = 0x742b0e01,
    tgIPicture                = 0x7bf80980,
    tgIPictureDisp            = 0x7bf80981,
    tgIPersistStreamInit         = 0x7fd52380,
    tgIOleUndoAction          = 0x894ad3b0,
    tgIOleInPlaceSiteWindowless  = 0x922eada0,
    tgIDataFrame              = 0x97F254E0,
    tgIControl_95             = 0x9a4bbfb5,
    tgIPropertyNotifySink        = 0x9bfbbc02,
    tgIOleInPlaceSiteEx       = 0x9c2cad80,
    tgIOleCompoundUndoAction     = 0xa1faf330,
    tgIControl                = 0xa7fddba0,
    tgIProvideClassInfo       = 0xb196b283,
    tgIConnectionPointContainer  = 0xb196b284,
    tgIEnumConnectionPoints      = 0xb196b285,
    tgIConnectionPoint        = 0xb196b286,
    tgIEnumConnections        = 0xb196b287,
    tgIOleControl             = 0xb196b288,
    tgIOleControlSite            = 0xb196b289,
    tgISpecifyPropertyPages      = 0xb196b28b,
    tgIPropertyPageSite       = 0xb196b28c,
    tgIPropertyPage           = 0xb196b28d,
    tgIClassFactory2          = 0xb196b28f,
    tgIEnumOleUndoActions        = 0xb3e7c340,
    tgIMsoDocument            = 0xb722bcc5,
    tgIMsoView                = 0xb722bcc6,
    tgIMsoCommandTarget       = 0xb722bccb,
    tgIOlePropertyFrame       = 0xb83bb801,
    tgIPropertyPageInPlace       = 0xb83bb802,
    tgIPropertyPage3          = 0xb83bb803,
    tgIPropertyPageSite2         = 0xb83bb804,
    tgIFont                = 0xbef6e002,
    tgIFontDisp               = 0xbef6e003,
    tgIQuickActivate          = 0xcf51ed10,
    tgIOleUndoActionManager      = 0xd001f200,
    tgIPSFactoryBuffer        = 0xd5f569d0,
    tgIOleStandardTool        = 0xd97877c4,
    tgISupportErrorInfo       = 0xdf0b3d60,
    tgICDataDoc               = 0xF413E4C0,
} DATA1_GUIDS;


HRESULT COleControl::InternalQueryInterface(REFIID riid, void **ppvObjOut)
{
#ifdef _DEBUG
   DATA1_GUIDS gd = (DATA1_GUIDS) riid.Data1;
#endif
   switch (riid.Data1) {
      // private interface for prop page support
      case Data1_IControlPrv:
        if (DO_GUIDS_MATCH(riid, IID_IControlPrv)) {
         *ppvObjOut = (void *)this;
         ExternalAddRef();
         return S_OK;
        }
        goto NoInterface;

      case Data1_IOleControl:
         if (DO_GUIDS_MATCH(riid, IID_IOleControl))
            *ppvObjOut = (void *) (IOleControl*) this;
         break;

      case Data1_IPointerInactive:
         if (DO_GUIDS_MATCH(riid, IID_IPointerInactive))
            *ppvObjOut = (void *) (IPointerInactive*) this;
         break;

      case Data1_IQuickActivate:
         if (DO_GUIDS_MATCH(riid, IID_IQuickActivate))
            *ppvObjOut = (void *) (IQuickActivate*) this;
         break;

      case Data1_IOleObject:
         if (DO_GUIDS_MATCH(riid, IID_IOleObject))
            *ppvObjOut = (void *) (IOleObject*) this;
         break;

      QI_INHERITS((IPersistStorage *)this, IPersist);
      QI_INHERITS(this, IPersistStreamInit);
      QI_INHERITS(this, IOleInPlaceObject);
      QI_INHERITS(this, IOleInPlaceObjectWindowless);
      QI_INHERITS((IOleInPlaceActiveObject *)this, IOleWindow);
      QI_INHERITS(this, IOleInPlaceActiveObject);
      QI_INHERITS(this, IViewObject);
      QI_INHERITS(this, IViewObject2);
      QI_INHERITS(this, IViewObjectEx);
      QI_INHERITS(this, IConnectionPointContainer);
      // QI_INHERITS(this, ISpecifyPropertyPages);
      QI_INHERITS(this, IPersistStorage);
      QI_INHERITS(this, IPersistPropertyBag);
      QI_INHERITS(this, IProvideClassInfo);

      default:
         goto NoInterface;
   }

   // we like the interface, so addref and return

   ((IUnknown *)(*ppvObjOut))->AddRef();
   return S_OK;

NoInterface:
   // delegate to super-class for automation interfaces, etc ...

   return CAutomationObject::InternalQueryInterface(riid, ppvObjOut);
}

//=--------------------------------------------------------------------------=
// COleControl::FindConnectionPoint    [IConnectionPointContainer]
//=--------------------------------------------------------------------------=
// given an IID, find a connection point sink for it.
//
// Parameters:
//   REFIID         - [in]  interfaces they want
//   IConnectionPoint ** - [out] where the cp should go
//
// Output:
//   HRESULT

STDMETHODIMP COleControl::FindConnectionPoint(REFIID riid, IConnectionPoint **ppConnectionPoint)
{
   CHECK_POINTER(ppConnectionPoint);

   // we support the event interface, and IDispatch for it, and we also
   // support IPropertyNotifySink.
   //
   if (DO_GUIDS_MATCH(riid, EVENTIIDOFCONTROL(m_ObjectType)) || DO_GUIDS_MATCH(riid, IID_IDispatch))
      *ppConnectionPoint = &m_cpEvents;
   else if (DO_GUIDS_MATCH(riid, IID_IPropertyNotifySink))
      *ppConnectionPoint = &m_cpPropNotify;
   else
      return E_NOINTERFACE;

   // generic post-processing.
   //
   (*ppConnectionPoint)->AddRef();
   return S_OK;
}

//=--------------------------------------------------------------------------=
// COleControl::EnumConnectionPoints   [IConnectionPointContainer]
//=--------------------------------------------------------------------------=
// creates an enumerator for connection points.
//
// Parameters:
//   IEnumConnectionPoints **   - [out]
//
// Output:
//   HRESULT

STDMETHODIMP COleControl::EnumConnectionPoints(IEnumConnectionPoints **ppEnumConnectionPoints)
{
   IConnectionPoint **rgConnectionPoints;

   CHECK_POINTER(ppEnumConnectionPoints);

   // Alloc an array of connection points [since our standard enum
   // assumes this and free's it later ]

   rgConnectionPoints = (IConnectionPoint **) lcCalloc(sizeof(IConnectionPoint *) * 2);
   RETURN_ON_NULLALLOC(rgConnectionPoints);

   // we support the event interface for this dude as well as IPropertyNotifySink
   //
   rgConnectionPoints[0] = &m_cpEvents;
   rgConnectionPoints[1] = &m_cpPropNotify;

   *ppEnumConnectionPoints = (IEnumConnectionPoints *)(IEnumGeneric *) new CStandardEnum(IID_IEnumConnectionPoints,
                        2, sizeof(IConnectionPoint *), (void *)rgConnectionPoints,
                        CopyAndAddRefObject);
   if (!*ppEnumConnectionPoints) {
      lcFree(rgConnectionPoints);
      return E_OUTOFMEMORY;
   }

   return S_OK;
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::m_pOleControl
//=--------------------------------------------------------------------------=
// returns a pointer to the control in which we are nested.
//
// Output:
//   COleControl *
//
// Notes:
//
inline COleControl *COleControl::CConnectionPoint::m_pOleControl
(
   void
)
{
   return (COleControl *)((BYTE *)this - ((m_bType == SINK_TYPE_EVENT)
                                ? offsetof(COleControl, m_cpEvents)
                                : offsetof(COleControl, m_cpPropNotify)));
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::QueryInterface
//=--------------------------------------------------------------------------=
// standard qi
//
// Parameters:
//   REFIID    - [in]   interface they want
//   void **      - [out] where they want to put the resulting object ptr.
//
// Output:
//   HRESULT      - S_OK, E_NOINTERFACE

STDMETHODIMP COleControl::CConnectionPoint::QueryInterface
(
   REFIID riid,
   void **ppvObjOut
)
{
   if (DO_GUIDS_MATCH(riid, IID_IConnectionPoint) || DO_GUIDS_MATCH(riid, IID_IUnknown)) {
      *ppvObjOut = (IConnectionPoint *)this;
      AddRef();
      return S_OK;
   }

   return E_NOINTERFACE;
}

ULONG COleControl::CConnectionPoint::AddRef(void)
{
   return m_pOleControl()->ExternalAddRef();
}

ULONG COleControl::CConnectionPoint::Release(void)
{
   return m_pOleControl()->ExternalRelease();
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::GetConnectionInterface
//=--------------------------------------------------------------------------=
// returns the interface we support connections on.
//
// Parameters:
//   IID *     - [out] interface we support.
//
// Output:
//   HRESULT

STDMETHODIMP COleControl::CConnectionPoint::GetConnectionInterface(IID *piid)
{
   if (m_bType == SINK_TYPE_EVENT)
      *piid = EVENTIIDOFCONTROL(m_pOleControl()->m_ObjectType);
   else
      *piid = IID_IPropertyNotifySink;

   return S_OK;
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::GetConnectionPointContainer
//=--------------------------------------------------------------------------=
// returns the connection point container
//
// Parameters:
//   IConnectionPointContainer **ppCPC
//
// Output:
//   HRESULT

STDMETHODIMP COleControl::CConnectionPoint::GetConnectionPointContainer(IConnectionPointContainer **ppCPC)
{
   return m_pOleControl()->ExternalQueryInterface(IID_IConnectionPointContainer, (void **)ppCPC);
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectiontPoint::Advise
//=--------------------------------------------------------------------------=
// someboyd wants to be advised when something happens.
//
// Parameters:
//   IUnknown *      - [in]   guy who wants to be advised.
//   DWORD *         - [out] cookie
//
// Output:
//   HRESULT

STDMETHODIMP COleControl::CConnectionPoint::Advise(IUnknown *pUnk, DWORD *pdwCookie)
{
   HRESULT    hr;
   void    *pv;

   CHECK_POINTER(pdwCookie);

   // first, make sure everybody's got what they thinks they got

   if (m_bType == SINK_TYPE_EVENT) {

      /*
       * CONSIDER: 12.95 -- this theoretically is broken -- if they do
       * a find connection point on IDispatch, and they just happened to
       * also support the Event IID, we'd advise on that. this is not
       * awesome, but will prove entirely acceptable short term.
       */

      hr = pUnk->QueryInterface(EVENTIIDOFCONTROL(m_pOleControl()->m_ObjectType), &pv);
      if (FAILED(hr))
         hr = pUnk->QueryInterface(IID_IDispatch, &pv);
   }
   else
      hr = pUnk->QueryInterface(IID_IPropertyNotifySink, &pv);
   RETURN_ON_FAILURE(hr);

   // finally, add the sink. It's now been cast to the correct type and has
   // been AddRef'd.

   return AddSink(pv, pdwCookie);
}

#ifdef _WIN64
IUnknown* COleControl::CConnectionPoint::CookieToSink( DWORD dwCookie )
{
    for ( short i=0; i<m_cSinks; i++ )
	{
       if ( m_rgSinks64[i].dwCookie == dwCookie )
	      return m_rgSinks64[i].pUnk;
	}
	return NULL;
}

DWORD COleControl::CConnectionPoint::NextCookie()
{
   DWORD dw = m_dwNextCookie;
   if ( dw==0 )
   {
      // Try to find an available cookie
      // There must be an available cookie, since m_cSinks is a short, cookie is DWORD
	  dw = 1;
	  while ( CookieToSink(dw) != NULL )  // dw is used
         dw++;
   }
   else
      m_dwNextCookie++;
   return dw;
}
#endif

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::AddSink
//=--------------------------------------------------------------------------=
// in some cases, we'll already have done the QI, and won't need to do the
// work that is done in the Advise routine above.  thus, these people can
// just call this instead. [this stems really from IQuickActivate]
//
// Parameters:
//   void *    - [in]   the sink to add. it's already been addref'd
//   DWORD *      - [out] cookie
//
// Output:
//   HRESULT

HRESULT COleControl::CConnectionPoint::AddSink(void *pv, DWORD *pdwCookie)
{
#ifdef _WIN64
   CONNECTDATA*  rgUnkNew;

   if ( m_cSinks == 0 )
   {
      ASSERT_COMMENT(!m_rgSinks64, "this should be null when there are no sinks");
      m_rgSinks64 = (CONNECTDATA*)lcCalloc(8 * sizeof(CONNECTDATA));
      RETURN_ON_NULLALLOC(m_rgSinks64);
   }
   else if (!(m_cSinks & 0x7)) {
      rgUnkNew = (CONNECTDATA*)lcReAlloc(m_rgSinks64, (m_cSinks + 8) * sizeof(CONNECTDATA));
      RETURN_ON_NULLALLOC(rgUnkNew);
      m_rgSinks64 = rgUnkNew;
   }

   m_rgSinks64[m_cSinks].pUnk = (IUnknown *)pv;
   *pdwCookie = m_rgSinks64[m_cSinks].dwCookie = NextCookie();
   m_cSinks++;
   return S_OK;

#else
   IUnknown **rgUnkNew;
   int      i = 0;

   // we optimize the case where there is only one sink to not allocate
   // any storage.  turns out very rarely is there more than one.
   //
   switch (m_cSinks) {

      case 0:
         ASSERT_COMMENT(!m_rgSinks, "this should be null when there are no sinks");
         m_rgSinks = (IUnknown **)pv;
         break;

      case 1:
         // go ahead and do the initial allocation.   we'll get 8 at a time

         rgUnkNew = (IUnknown **)lcCalloc(8 * sizeof(IUnknown *));
         RETURN_ON_NULLALLOC(rgUnkNew);
         rgUnkNew[0] = (IUnknown *)m_rgSinks;
         rgUnkNew[1] = (IUnknown *)pv;
         m_rgSinks = rgUnkNew;
         break;

      default:
         // if we're out of sinks, then we have to increase the size
         // of the array

         if (!(m_cSinks & 0x7)) {
            rgUnkNew = (IUnknown **) lcReAlloc(m_rgSinks, (m_cSinks + 8) * sizeof(IUnknown *));
            RETURN_ON_NULLALLOC(rgUnkNew);
            m_rgSinks = rgUnkNew;
         } else
            rgUnkNew = m_rgSinks;

         rgUnkNew[m_cSinks] = (IUnknown *)pv;
         break;
   }

   *pdwCookie = (DWORD)pv;
   m_cSinks++;
   return S_OK;
#endif
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::Unadvise
//=--------------------------------------------------------------------------=
// they don't want to be told any more.
//
// Parameters:
//   DWORD     - [in]  the cookie we gave 'em.
//
// Output:
//   HRESULT

STDMETHODIMP COleControl::CConnectionPoint::Unadvise(DWORD dwCookie)
{
   IUnknown *pUnk;
   int     x;

   if (!dwCookie)
      return S_OK;

   // see how many sinks we've currently got, and deal with things based
   // on that.
#ifdef _WIN64
   pUnk = CookieToSink(dwCookie);

   if (pUnk == NULL)
      return CONNECT_E_NOCONNECTION;

   switch (m_cSinks) {
      case 1:
         lcFree(m_rgSinks64);
         m_rgSinks64 = NULL;
		 m_dwNextCookie = 1;
         break;

      default:
         // there are more than one sinks.  just clean up the hole we've
         // got in our array now.
         //
         for (x = 0; x < m_cSinks; x++) 
		 {
            if ((DWORD)m_rgSinks64[x].dwCookie == dwCookie)
               break;
         }
         if (x == m_cSinks) 
			 return CONNECT_E_NOCONNECTION;
         else  // (x < m_cSinks - 1)
            memcpy(&(m_rgSinks64[x]), &(m_rgSinks64[x + 1]), (m_cSinks -1 - x) * sizeof(CONNECTDATA));
         break;
   }

   // we're happy
   //
   m_cSinks--;
   pUnk->Release();
   return S_OK;

#else
   switch (m_cSinks) {
      case 1:
         // it's the only sink.  make sure the ptrs are the same, and
         // then free things up

         if ((DWORD)m_rgSinks != dwCookie)
            return CONNECT_E_NOCONNECTION;
         m_rgSinks = NULL;
         break;

      case 2:
         // there are two sinks.  go back down to one sink scenario
         //
         if ((DWORD)m_rgSinks[0] != dwCookie && (DWORD)m_rgSinks[1] != dwCookie)
            return CONNECT_E_NOCONNECTION;

         pUnk = ((DWORD)m_rgSinks[0] == dwCookie)
               ? m_rgSinks[1]
               : ((DWORD)m_rgSinks[1] == dwCookie) ? m_rgSinks[0] : NULL;

         if (!pUnk) return CONNECT_E_NOCONNECTION;

         lcFree(m_rgSinks);
         m_rgSinks = (IUnknown **)pUnk;
         break;

      default:
         // there are more than two sinks.  just clean up the hole we've
         // got in our array now.
         //
         for (x = 0; x < m_cSinks; x++) {
            if ((DWORD)m_rgSinks[x] == dwCookie)
               break;
         }
         if (x == m_cSinks) return CONNECT_E_NOCONNECTION;
         if (x < m_cSinks - 1)
            memcpy(&(m_rgSinks[x]), &(m_rgSinks[x + 1]), (m_cSinks -1 - x) * sizeof(IUnknown *));
         else
            m_rgSinks[x] = NULL;
         break;
   }


   // we're happy
   //
   m_cSinks--;
   ((IUnknown *)dwCookie)->Release();
   return S_OK;
#endif
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::EnumConnections
//=--------------------------------------------------------------------------=
// enumerates all current connections
//
// Paramters:
//   IEnumConnections ** - [out] new enumerator object
//
// Output:
//   HRESULT
//
// NOtes:
//
STDMETHODIMP COleControl::CConnectionPoint::EnumConnections
(
   IEnumConnections **ppEnumOut
)
{
   CONNECTDATA *rgConnectData = NULL;
   int i;

   if (m_cSinks) {
      // allocate some memory big enough to hold all of the sinks.

      rgConnectData = (CONNECTDATA *)lcCalloc(m_cSinks * sizeof(CONNECTDATA));
      RETURN_ON_NULLALLOC(rgConnectData);
#ifdef _WIN64
      for (i = 0; i < m_cSinks; i++) {
          rgConnectData[i].pUnk = m_rgSinks64[i].pUnk;
          rgConnectData[i].dwCookie = m_rgSinks64[i].dwCookie;
      }
#else

      // fill in the array
      //
      if (m_cSinks == 1) {
         rgConnectData[0].pUnk = (IUnknown *)m_rgSinks;
         rgConnectData[0].dwCookie = (DWORD)m_rgSinks;
      } else {
         // loop through all available sinks.
         //
         for (i = 0; i < m_cSinks; i++) {
            rgConnectData[i].pUnk = m_rgSinks[i];
            rgConnectData[i].dwCookie = (DWORD)m_rgSinks[i];
         }
      }
#endif
   }

   // create yon enumerator object.
   //
   *ppEnumOut = (IEnumConnections *)(IEnumGeneric *)new CStandardEnum(IID_IEnumConnections,
                  m_cSinks, sizeof(CONNECTDATA), rgConnectData, CopyAndAddRefObject);
   if (!*ppEnumOut) {
      lcFree(rgConnectData);
      return E_OUTOFMEMORY;
   }

   return S_OK;
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::~CConnectionPoint
//=--------------------------------------------------------------------------=
// cleans up
//
// Notes:
//
COleControl::CConnectionPoint::~CConnectionPoint ()
{
   int x;

#ifdef _WIN64
   if (!m_cSinks)
      return;
   else {
      for (x = 0; x < m_cSinks; x++)
         QUICK_RELEASE(m_rgSinks64[x].pUnk);
      lcFree(m_rgSinks64);
   }
#else
   // clean up some memory stuff
   //
   if (!m_cSinks)
      return;
   else if (m_cSinks == 1)
      ((IUnknown *)m_rgSinks)->Release();
   else {
      for (x = 0; x < m_cSinks; x++)
         QUICK_RELEASE(m_rgSinks[x]);
      lcFree(m_rgSinks);
   }
#endif
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPiont::DoInvoke
//=--------------------------------------------------------------------------=
// fires an event to all listening on our event interface.
//
// Parameters:
//   DISPID       - [in] event to fire.
//   DISPPARAMS      - [in]

void COleControl::CConnectionPoint::DoInvoke(DISPID dispid, DISPPARAMS *pdispparams)
{
   int iConnection;

   // if we don't have any sinks, then there's nothing to do.  we intentionally
   // ignore errors here.

#ifdef _WIN64
   if (m_cSinks == 0)
      return;
   else
      for (iConnection = 0; iConnection < m_cSinks; iConnection++)
         ((IDispatch *)m_rgSinks64[iConnection].pUnk)->Invoke(dispid, IID_NULL, 0, DISPATCH_METHOD, pdispparams, NULL, NULL, NULL);
#else
   if (m_cSinks == 0)
      return;
   else if (m_cSinks == 1)
      ((IDispatch *)m_rgSinks)->Invoke(dispid, IID_NULL, 0, DISPATCH_METHOD, pdispparams, NULL, NULL, NULL);
   else
      for (iConnection = 0; iConnection < m_cSinks; iConnection++)
         ((IDispatch *)m_rgSinks[iConnection])->Invoke(dispid, IID_NULL, 0, DISPATCH_METHOD, pdispparams, NULL, NULL, NULL);
#endif
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::DoOnChanged
//=--------------------------------------------------------------------------=
// fires the OnChanged event for IPropertyNotifySink listeners.
//
// Parameters:
//   DISPID       - [in] dude that changed.
//
// Output:
//   none

void COleControl::CConnectionPoint::DoOnChanged(DISPID dispid)
{
   ASSERT_COMMENT(FALSE, "DoOnChanged called, restore the code");
#if 0
   int iConnection;

   // if we don't have any sinks, then there's nothing to do.

   if (m_cSinks == 0)
      return;
   else if (m_cSinks == 1)
      ((IPropertyNotifySink *)m_rgSinks)->OnChanged(dispid);
   else
      for (iConnection = 0; iConnection < m_cSinks; iConnection++)
         ((IPropertyNotifySink *)m_rgSinks[iConnection])->OnChanged(dispid);
#endif
}

//=--------------------------------------------------------------------------=
// COleControl::CConnectionPoint::DoOnRequestEdit
//=--------------------------------------------------------------------------=
// fires the OnRequestEdit for IPropertyNotifySinkListeners
//
// Parameters:
//   DISPID        - [in] dispid user wants to change.
//
// Output:
//   BOOL             - false means you cant

BOOL COleControl::CConnectionPoint::DoOnRequestEdit(DISPID dispid)
{
   HRESULT hr;
   int   iConnection;

#ifdef _WIN64
   if (m_cSinks == 0)
      hr = S_OK;
   else {
      for (iConnection = 0; iConnection < m_cSinks; iConnection++) {
         hr = ((IPropertyNotifySink *)m_rgSinks64[iConnection].pUnk)->OnRequestEdit(dispid);
         if (hr != S_OK) break;
      }
   }
#else
   // if we don't have any sinks, then there's nothing to do.

   if (m_cSinks == 0)
      hr = S_OK;
   else if (m_cSinks == 1)
      hr =((IPropertyNotifySink *)m_rgSinks)->OnRequestEdit(dispid);
   else {
      for (iConnection = 0; iConnection < m_cSinks; iConnection++) {
         hr = ((IPropertyNotifySink *)m_rgSinks[iConnection])->OnRequestEdit(dispid);
         if (hr != S_OK) break;
      }
   }
#endif
   return (hr == S_OK) ? TRUE : FALSE;
}

//=--------------------------------------------------------------------------=
// COleControl::CreateInPlaceWindow
//=--------------------------------------------------------------------------=
// creates the window with which we will be working.
// yay.
//
// Parameters:
//   int        - [in] left
//   int        - [in] top
//   BOOL          - [in] can we skip redrawing?
//
// Output:
//   HWND
//
// Notes:
//   - DANGER! DANGER!  this function is protected so that anybody can call it
//    from their control.  however, people should be extremely careful of when
//    and why they do this.  preferably, this function would only need to be
//    called by an end-control writer in design mode to take care of some
//    hosting/painting issues.  otherwise, the framework should be left to
//    call it when it wants.

HWND COleControl::CreateInPlaceWindow(int x, int y, BOOL fNoRedraw)
{
   BOOL  fVisible;
   DWORD dwWindowStyle, dwExWindowStyle;
   char  szWindowTitle[128];

   // if we've already got a window, do nothing.

   if (m_hwnd)
      return m_hwnd;

   // get the user to register the class if it's not already
   // been done.  we have to critical section this since more than one thread
   // can be trying to create this control

   if (!CTLWNDCLASSREGISTERED(m_ObjectType)) {
      // EnterCriticalSection(&g_CriticalSection);
      if (!RegisterClassData()) {
         // LeaveCriticalSection(&g_CriticalSection);
         return NULL;
      }
      else
         CTLWNDCLASSREGISTERED(m_ObjectType) = TRUE;
      // LeaveCriticalSection(&g_CriticalSection);
   }

   dwWindowStyle = dwExWindowStyle = 0;
   szWindowTitle[0] = '\0';
   if (!BeforeCreateWindow(&dwWindowStyle, &dwExWindowStyle, szWindowTitle))
      return NULL;

   dwWindowStyle |= (WS_CHILD | WS_CLIPSIBLINGS);

   // create window visible if parent hidden (common case)
   // otherwise, create hidden, then shown.  this is a little subtle, but
   // it makes sense eventually.

   ASSERT(m_hwndParent);   // why would this ever occur? [rw]
   if (!m_hwndParent)
      m_hwndParent = GetParkingWindow();

   fVisible = IsWindowVisible(m_hwndParent);
   if (!fVisible)
      dwWindowStyle |= WS_VISIBLE;

   // we have to mutex the entire create window process since we need to use
   // the s_pLastControlCreated to pass in the object pointer.  nothing too
   // serious

   // EnterCriticalSection(&g_CriticalSection);
   s_pLastControlCreated = this;
   m_fCreatingWindow = TRUE;

   // finally, go create the window, parenting it as appropriate.

   m_hwnd = CreateWindowEx(dwExWindowStyle,
                     WNDCLASSNAMEOFCONTROL(m_ObjectType),
                     szWindowTitle,
                     dwWindowStyle,
                     x, y,
                     m_Size.cx, m_Size.cy,
                     m_hwndParent,
                     NULL, _Module.GetModuleInstance(), NULL);

   // clean up some variables, and leave the critical section

   m_fCreatingWindow = FALSE;
   s_pLastControlCreated = NULL;
   // LeaveCriticalSection(&g_CriticalSection);

   if (IsValidWindow(m_hwnd)) {
      // let the derived-control do something if they so desire

      if (!AfterCreateWindow()) {
         BeforeDestroyWindow();
         SetWindowLong(m_hwnd, GWLP_USERDATA, 0xFFFFFFFF);
         DestroyWindow(m_hwnd);
         m_hwnd = NULL;
         return m_hwnd;
      }

      // if we didn't create the window visible, show it now.

      if (fVisible)
         SetWindowPos(m_hwnd,
            // m_hwndParent,
            NULL, // RAID #30314
               0, 0, 0, 0,
               SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_SHOWWINDOW | (fNoRedraw) ? SWP_NOREDRAW : 0);
   }

   // finally, tell the host of this

   if (m_pClientSite)
      m_pClientSite->ShowObject();

   return m_hwnd;
}

//=--------------------------------------------------------------------------=
// COleControl::SetInPlaceParent [helper]
//=--------------------------------------------------------------------------=
// sets up the parent window for our control.
//
// Parameters:
//   HWND           - [in] new parent window

void COleControl::SetInPlaceParent(HWND hwndParent)
{
   ASSERT_COMMENT(!m_pInPlaceSiteWndless, "This routine should only get called for windowed OLE controls");

   if (m_hwndParent == hwndParent)
      return;

   m_hwndParent = hwndParent;
   if (m_hwnd)
      SetParent(m_hwnd, hwndParent);
}

//=--------------------------------------------------------------------------=
// COleControl::ControlWindowProc
//=--------------------------------------------------------------------------=
// default window proc for an OLE Control.    controls will have their own
// window proc called from this one, after some processing is done.
//
// Parameters:
//   - see win32sdk docs.
//
// Notes:
//

LRESULT CALLBACK COleControl::ControlWindowProc(HWND hwnd, UINT msg,
   WPARAM wParam, LPARAM lParam)
{
   COleControl *pCtl = ControlFromHwnd(hwnd);
   LRESULT lResult;

   // if the value isn't a positive value, then it's in some special
   // state [creation or destruction]  this is safe because under win32,
   // the upper 2GB of an address space aren't available.

   if (!pCtl) {
      pCtl = s_pLastControlCreated;
      SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR) pCtl);
      pCtl->m_hwnd = hwnd;
   }

   // 17-Sep-1997 [ralphw] Changed to 0xFFFFFFFF to avoid 32-bit dependencies

   else if ((DWORD_PTR) pCtl == (DWORD_PTR) 0xFFFFFFFF) {
      return DefWindowProc(hwnd, msg, wParam, lParam);
   }

   // message preprocessing

#if 0
   if (pCtl->m_pSimpleFrameSite) {
      hr = pCtl->m_pSimpleFrameSite->PreMessageFilter(hwnd, msg, wParam, lParam, &lResult, &dwCookie);
      if (hr == S_FALSE)
         return lResult;
   }
#endif

   // for certain messages, do not call the user window proc. instead,
   // we have something else we'd like to do.

   switch (msg) {
     case WM_MOUSEACTIVATE:
      {
			 pCtl->InPlaceActivate(OLEIVERB_UIACTIVATE);
			 break;
      }
     case WM_PAINT:
      {
         // call the user's OnDraw routine.

         PAINTSTRUCT ps;
         RECT     rc;
         HDC      hdc;

         // if we're given an HDC, then use it

         // REVIEW: 17-Sep-1997  [ralphw] who's handing us a dc in wParam?

         if (!wParam)
            hdc = BeginPaint(hwnd, &ps);
         else
            hdc = (HDC)wParam;

         GetClientRect(hwnd, &rc);
         pCtl->OnDraw(DVASPECT_CONTENT, hdc, (RECTL *)&rc, NULL, NULL, TRUE);

         if (!wParam)
            EndPaint(hwnd, &ps);
      }
      break;

     default:
      // call the derived-control's window proc

      lResult = pCtl->WindowProc(msg, wParam, lParam);
      break;
   }

   // message postprocessing

   switch (msg) {
     case WM_NCDESTROY:
      // after this point, the window doesn't exist any more

      pCtl->m_hwnd = NULL;
      break;

     // REVIEW: 14-Oct-1997 [ralphw] This message never arrives

     case WM_SETFOCUS:
     case WM_KILLFOCUS:
      // give the control site focus notification

      if (pCtl->m_fInPlaceActive && pCtl->m_pControlSite) {
         DBWIN("Focus change");
         pCtl->m_pControlSite->OnFocus(msg == WM_SETFOCUS);
      }
      break;

     case WM_SIZE:
      // a change in size is a change in view

      if (!pCtl->m_fCreatingWindow)
         pCtl->ViewChanged();
      break;
   }

   // lastly, simple frame postmessage processing

#if 0
   if (pCtl->m_pSimpleFrameSite)
      pCtl->m_pSimpleFrameSite->PostMessageFilter(hwnd, msg, wParam, lParam, &lResult, dwCookie);
#endif

   return lResult;
}

//=--------------------------------------------------------------------------=
// COleControl::SetFocus
//=--------------------------------------------------------------------------=
// we have to override this routine to get UI Activation correct.
//
// Parameters:
//   BOOL            - [in] true means take, false release
//
// Output:
//   BOOL
//
// Notes:
//   - CONSIDER: this is pretty messy, and it's still not entirely clear
//    what the ole control/focus story is.

// REVIEW: 14-Oct-1997 [ralphw] Doesn't look like it is ever called

BOOL COleControl::SetFocus(BOOL fGrab)
{
   DBWIN("COleControl::SetFocus");

   HRESULT hr;
   HWND  hwnd;

   // first thing to do is check out UI Activation state, and then set
   // focus [either with windows api, or via the host for windowless
   // controls]

   if (m_pInPlaceSiteWndless) {
      if (!m_fUIActive && fGrab)
         if (FAILED(InPlaceActivate(OLEIVERB_UIACTIVATE))) return FALSE;

      hr = m_pInPlaceSiteWndless->SetFocus(fGrab);
      return (hr == S_OK) ? TRUE : FALSE;
   }
   else {

      // we've got a window.

      if (m_fInPlaceActive) {
         hwnd = (fGrab) ? m_hwnd : m_hwndParent;
         if (!m_fUIActive && fGrab)
            return SUCCEEDED(InPlaceActivate(OLEIVERB_UIACTIVATE));
         else
            return (::SetFocus(hwnd) == hwnd);
      } else
         return FALSE;
   }

   // dead code
}

#if 0

//=--------------------------------------------------------------------------=
// COleControl::ReflectWindowProc
//=--------------------------------------------------------------------------=
// reflects window messages on to the child window.
//
// Parameters and Output:
//   - see win32 sdk docs

// REVIEW: 14-Oct-1997 [ralphw] Doesn't seem to ever be called

LRESULT CALLBACK COleControl::ReflectWindowProc(HWND hwnd, UINT msg,
   WPARAM wParam, LPARAM lParam)
{
   COleControl *pCtl;

   switch (msg) {
      case WM_COMMAND:
      case WM_NOTIFY:
      case WM_CTLCOLORBTN:
      case WM_CTLCOLORDLG:
      case WM_CTLCOLOREDIT:
      case WM_CTLCOLORLISTBOX:
      case WM_CTLCOLORMSGBOX:
      case WM_CTLCOLORSCROLLBAR:
      case WM_CTLCOLORSTATIC:
      case WM_DRAWITEM:
      case WM_MEASUREITEM:
      case WM_DELETEITEM:
      case WM_VKEYTOITEM:
      case WM_CHARTOITEM:
      case WM_COMPAREITEM:
      case WM_HSCROLL:
      case WM_VSCROLL:
      case WM_PARENTNOTIFY:
      case WM_SETFOCUS:
      case WM_SIZE:
         pCtl = (COleControl *) GetWindowLong(hwnd, GWLP_USERDATA);
         if (pCtl)
            return SendMessage(pCtl->m_hwnd, msg, wParam, lParam);
         break;
   }

   return DefWindowProc(hwnd, msg, wParam, lParam);
}
#endif

//=--------------------------------------------------------------------------=
// COleControl::GetAmbientProperty    [callable]
//=--------------------------------------------------------------------------=
// returns the value of an ambient property
//
// Parameters:
//   DISPID    - [in]   property to get
//   VARTYPE      - [in]   type of desired data
//   void *    - [out] where to put the data
//
// Output:
//   BOOL         - FALSE means didn't work.

BOOL COleControl::GetAmbientProperty(DISPID dispid, VARTYPE vt, void *pData)
{
   DISPPARAMS dispparams;
   VARIANT v, v2;
   HRESULT hr;

   v.vt = VT_EMPTY;
   v.lVal = 0;
   v2.vt = VT_EMPTY;
   v2.lVal = 0;

   // get a pointer to the source of ambient properties.
   //
   if (!m_pDispAmbient) {
      if (m_pClientSite)
         m_pClientSite->QueryInterface(IID_IDispatch, (void **)&m_pDispAmbient);

      if (!m_pDispAmbient)
         return FALSE;
   }

   // now go and get the property into a variant.

   memset(&dispparams, 0, sizeof(DISPPARAMS));
   hr = m_pDispAmbient->Invoke(dispid, IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams,
                        &v, NULL, NULL);
   if (FAILED(hr))
      return FALSE;

   // we've got the variant, so now go an coerce it to the type that the user
   // wants.  if the types are the same, then this will copy the stuff to
   // do appropriate ref counting ...
   //
   hr = VariantChangeType(&v2, &v, 0, vt);
   if (FAILED(hr)) {
      VariantClear(&v);
      return FALSE;
   }

   // copy the data to where the user wants it

   CopyMemory(pData, &(v2.lVal), g_rgcbDataTypeSize[vt]);
   VariantClear(&v);
   return TRUE;
}

//=--------------------------------------------------------------------------=
// COleControl::GetAmbientFont     [callable]
//=--------------------------------------------------------------------------=
// gets the current font for the user.
//
// Parameters:
//   IFont **        - [out] where to put the font.
//
// Output:
//   BOOL            - FALSE means couldn't get it.

BOOL COleControl::GetAmbientFont(IFont **ppFont)
{
   IDispatch *pFontDisp;

   // we don't have to do much here except get the ambient property and QI
   // it for the user.

   *ppFont = NULL;
   if (!GetAmbientProperty(DISPID_AMBIENT_FONT, VT_DISPATCH, &pFontDisp))
      return FALSE;

   pFontDisp->QueryInterface(IID_IFont, (void **)ppFont);
   pFontDisp->Release();
   return (*ppFont) ? TRUE : FALSE;
}

//=--------------------------------------------------------------------------=
// COleControl::DesignMode
//=--------------------------------------------------------------------------=
// returns TRUE if we're in Design mode.
//
// Output:
//   BOOL           - true is design mode, false is run mode
//
// Notes:
//

BOOL COleControl::DesignMode(void)
{
   // BUGBUG: if we never call this, then remove it

   VARIANT_BOOL f;

   // if we don't already know our run mode, go and get it.  we'll assume
   // it's true unless told otherwise [or if the operation fails ...]

   if (!m_fModeFlagValid) {
      f = TRUE;
      m_fModeFlagValid = TRUE;
      GetAmbientProperty(DISPID_AMBIENT_USERMODE, VT_BOOL, &f);
      m_fRunMode = f;
   }

   return !m_fRunMode;
}

//=--------------------------------------------------------------------------=
// COleControl::FireEvent
//=--------------------------------------------------------------------------=
// fires an event.   handles arbitrary number of arguments.
//
// Parameters:
//   EVENTINFO *      - [in] struct that describes the event.
//   ...           - arguments to the event
//
// Output:
//   none
//
// Notes:
//   - use stdarg's va_* macros.

void __cdecl COleControl::FireEvent(EVENTINFO *pEventInfo, ...)
{
   va_list    valist;
   DISPPARAMS dispparams;
   VARIANT    rgvParameters[MAX_ARGS];
   VARIANT   *pv;
   VARTYPE    vt;
   int      iParameter;
   int      cbSize;

   ASSERT_COMMENT(pEventInfo->cParameters <= MAX_ARGS, "Doesn't support more than MAX_ARGS params.");

   va_start(valist, pEventInfo);

   // copy the Parameters into the rgvParameters array.  make sure we reverse
   // them for automation
   //
   pv = &(rgvParameters[pEventInfo->cParameters - 1]);
   for (iParameter = 0; iParameter < pEventInfo->cParameters; iParameter++) {

      vt = pEventInfo->rgTypes[iParameter];

      // if it's a by value variant, then just copy the whole thing

      if (vt == VT_VARIANT)
         *pv = va_arg(valist, VARIANT);
      else {
         // copy the vt and the data value.

         pv->vt = vt;
         if (vt & VT_BYREF)
            cbSize = sizeof(void *);
         else
            cbSize = g_rgcbDataTypeSize[vt];

         // small optimization -- we can copy 2/4 bytes over quite
         // quickly.

         if (cbSize == sizeof(short))
            V_I2(pv) = va_arg(valist, short);
         else if (cbSize == 4)
            V_I4(pv) = va_arg(valist, long);
         else {
            // copy over 8 bytes

            ASSERT_COMMENT(cbSize == 8, "don't recognize the type!!");
            V_CY(pv) = va_arg(valist, CURRENCY);
         }
      }

      pv--;
   }

   // fire the event

   dispparams.rgvarg = rgvParameters;
   dispparams.cArgs = pEventInfo->cParameters;
   dispparams.rgdispidNamedArgs = NULL;
   dispparams.cNamedArgs = 0;

   m_cpEvents.DoInvoke(pEventInfo->dispid, &dispparams);

   va_end(valist);
}

#if 0
//=--------------------------------------------------------------------------=
// COleControl::AfterCreateWindow    [overridable]
//=--------------------------------------------------------------------------=
//
// Output:
//   BOOL            - false means fatal error, can't continue

BOOL COleControl::AfterCreateWindow(void)
{
   return TRUE;
}
#endif

//=--------------------------------------------------------------------------=
// COleControl::InvalidateControl    [callable]
//=--------------------------------------------------------------------------=

void COleControl::InvalidateControl(LPCRECT lpRect)
{
   if (m_fInPlaceActive)
      InvalidateRect(m_hwnd, lpRect, TRUE);
   else
      ViewChanged();
}

//=--------------------------------------------------------------------------=
// COleControl::SetControlSize     [callable]
//=--------------------------------------------------------------------------=
// sets the control size. they'll give us the size in pixels.  we've got to
// convert them back to HIMETRIC before passing them on!
//
// Parameters:
//   SIZEL *       - [in] new size
//
// Output:
//   BOOL
//
// Notes:
//

BOOL COleControl::SetControlSize(SIZEL *pSize)
{
   HRESULT hr;
   SIZEL slHiMetric;

   PixelToHiMetric(pSize, &slHiMetric);
   hr = SetExtent(DVASPECT_CONTENT, &slHiMetric);
   return (FAILED(hr)) ? FALSE : TRUE;
}

//=--------------------------------------------------------------------------=
// COleControl::RecreateControlWindow   [callable]
//=--------------------------------------------------------------------------=
// called by a [subclassed, typically] control to recreate it's control
// window.
//
// Parameters:
//   none
//
// Output:
//   HRESULT
//
// Notes:
//   - NOTE: USE ME EXTREMELY SPARINGLY! THIS IS AN EXTREMELY EXPENSIVE
//    OPERATION!
//

#if 0

HRESULT COleControl::RecreateControlWindow(void)
{
   HRESULT hr;
   HWND  hwndPrev;

   DBWIN("RecreateControlWindow called -- it probably shouldn't be.");

   // we need to correctly preserve the control's position within the
   // z-order here.

   if (m_hwnd)
      hwndPrev = ::GetWindow(m_hwnd, GW_HWNDPREV);

   // if we're in place active, then we have to deactivate, and reactivate
   // ourselves with the new window ...

   if (m_fInPlaceActive) {

      hr = InPlaceDeactivate();
      RETURN_ON_FAILURE(hr);
      hr = InPlaceActivate((m_fUIActive) ? OLEIVERB_UIACTIVATE : OLEIVERB_INPLACEACTIVATE);
      RETURN_ON_FAILURE(hr);

   } else if (m_hwnd) {
      DestroyWindow(m_hwnd);
      m_hwnd = NULL;

      CreateInPlaceWindow(0, 0, FALSE);
   }

   // restore z-order position

   if (m_hwnd)
      SetWindowPos(m_hwnd, hwndPrev, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);

   return m_hwnd ? S_OK : E_FAIL;
}

#endif