src/msw/ole/activex.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/ole/activex.cpp
   3 // Purpose:     wxActiveXContainer implementation
   4 // Author:      Ryan Norton <wxprojects@comcast.net>, Lindsay Mathieson <???>
   5 // Modified by:
   6 // Created:     11/07/04
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Lindsay Mathieson, (c) 2005 Ryan Norton
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #if wxUSE_ACTIVEX
  27
  28 #ifndef WX_PRECOMP
  29     #include "wx/dcclient.h"
  30     #include "wx/math.h"
  31 #endif
  32
  33 #include "wx/msw/dc.h"
  34
  35 #include "wx/msw/ole/activex.h"
  36 #include "wx/msw/private.h" // for wxCopyRectToRECT
  37
  38 // autointerfaces that we only use here
  39 typedef wxAutoOleInterface<IOleInPlaceSite> wxAutoIOleInPlaceSite;
  40 typedef wxAutoOleInterface<IOleDocument> wxAutoIOleDocument;
  41 typedef wxAutoOleInterface<IPersistStreamInit> wxAutoIPersistStreamInit;
  42 typedef wxAutoOleInterface<IAdviseSink> wxAutoIAdviseSink;
  43 typedef wxAutoOleInterface<IProvideClassInfo> wxAutoIProvideClassInfo;
  44 typedef wxAutoOleInterface<ITypeInfo> wxAutoITypeInfo;
  45 typedef wxAutoOleInterface<IConnectionPoint> wxAutoIConnectionPoint;
  46 typedef wxAutoOleInterface<IConnectionPointContainer> wxAutoIConnectionPointContainer;
  47
  48 wxDEFINE_EVENT( wxEVT_ACTIVEX, wxActiveXEvent );
  49
  50 // Ole class helpers (sort of MFC-like) from wxActiveX
  51 #define DECLARE_OLE_UNKNOWN(cls)\
  52     private:\
  53     class TAutoInitInt\
  54     {\
  55         public:\
  56         LONG l;\
  57         TAutoInitInt() : l(1) {}\
  58     };\
  59     TAutoInitInt refCount, lockCount;\
  60     static void _GetInterface(cls *self, REFIID iid, void **_interface, const char *&desc);\
  61     public:\
  62     LONG GetRefCount();\
  63     HRESULT STDMETHODCALLTYPE QueryInterface(REFIID iid, void ** ppvObject);\
  64     ULONG STDMETHODCALLTYPE AddRef();\
  65     ULONG STDMETHODCALLTYPE Release();\
  66     ULONG STDMETHODCALLTYPE AddLock();\
  67     ULONG STDMETHODCALLTYPE ReleaseLock()
  68
  69 #define DEFINE_OLE_TABLE(cls)\
  70     LONG cls::GetRefCount() {return refCount.l;}\
  71     HRESULT STDMETHODCALLTYPE cls::QueryInterface(REFIID iid, void ** ppvObject)\
  72     {\
  73         if (! ppvObject)\
  74         {\
  75             return E_FAIL;\
  76         }\
  77         const char *desc = NULL;\
  78         cls::_GetInterface(this, iid, ppvObject, desc);\
  79         if (! *ppvObject)\
  80         {\
  81             return E_NOINTERFACE;\
  82         }\
  83         ((IUnknown * )(*ppvObject))->AddRef();\
  84         return S_OK;\
  85     }\
  86     ULONG STDMETHODCALLTYPE cls::AddRef()\
  87     {\
  88         InterlockedIncrement(&refCount.l);\
  89         return refCount.l;\
  90     }\
  91     ULONG STDMETHODCALLTYPE cls::Release()\
  92     {\
  93         if (refCount.l > 0)\
  94         {\
  95             InterlockedDecrement(&refCount.l);\
  96             if (refCount.l == 0)\
  97             {\
  98                 delete this;\
  99                 return 0;\
 100             }\
 101             return refCount.l;\
 102         }\
 103         else\
 104             return 0;\
 105     }\
 106     ULONG STDMETHODCALLTYPE cls::AddLock()\
 107     {\
 108         InterlockedIncrement(&lockCount.l);\
 109         return lockCount.l;\
 110     }\
 111     ULONG STDMETHODCALLTYPE cls::ReleaseLock()\
 112     {\
 113         if (lockCount.l > 0)\
 114         {\
 115             InterlockedDecrement(&lockCount.l);\
 116             return lockCount.l;\
 117         }\
 118         else\
 119             return 0;\
 120     }\
 121     DEFINE_OLE_BASE(cls)
 122
 123 #define DEFINE_OLE_BASE(cls)\
 124     void cls::_GetInterface(cls *self, REFIID iid, void **_interface, const char *&desc)\
 125     {\
 126         *_interface = NULL;\
 127         desc = NULL;
 128
 129 #define OLE_INTERFACE(_iid, _type)\
 130     if (IsEqualIID(iid, _iid))\
 131     {\
 132         *_interface = (IUnknown *) (_type *) self;\
 133         desc = # _iid;\
 134         return;\
 135     }
 136
 137 #define OLE_IINTERFACE(_face) OLE_INTERFACE(IID_##_face, _face)
 138
 139 #define OLE_INTERFACE_CUSTOM(func)\
 140     if (func(self, iid, _interface, desc))\
 141     {\
 142         return;\
 143     }
 144
 145 #define END_OLE_TABLE\
 146     }
 147
 148 // ============================================================================
 149 // implementation
 150 // ============================================================================
 151
 152 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 153 // PixelsToHimetric
 154 //
 155 // Utility to convert from pixels to the himetric values in some COM methods
 156 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 157
 158
 159 #define HIMETRIC_PER_INCH   2540
 160 #define MAP_PIX_TO_LOGHIM(x,ppli)   MulDiv(HIMETRIC_PER_INCH, (x), (ppli))
 161
 162 static void PixelsToHimetric(SIZEL &sz)
 163 {
 164     static int logX = 0;
 165     static int logY = 0;
 166
 167     if (logY == 0)
 168     {
 169         // initaliase
 170         HDC dc = GetDC(NULL);
 171         logX = GetDeviceCaps(dc, LOGPIXELSX);
 172         logY = GetDeviceCaps(dc, LOGPIXELSY);
 173         ReleaseDC(NULL, dc);
 174     };
 175
 176 #define HIMETRIC_INCH   2540
 177 #define CONVERT(x, logpixels)   wxMulDivInt32(HIMETRIC_INCH, (x), (logpixels))
 178
 179     sz.cx = CONVERT(sz.cx, logX);
 180     sz.cy = CONVERT(sz.cy, logY);
 181
 182 #undef CONVERT
 183 #undef HIMETRIC_INCH
 184 }
 185
 186
 187 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 188 //
 189 // FrameSite
 190 //
 191 // Handles the actual wxActiveX container implementation
 192 //
 193 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 194 class FrameSite :
 195     public IOleClientSite,
 196     public IOleInPlaceSiteEx,
 197     public IOleInPlaceFrame,
 198     public IOleItemContainer,
 199     public IDispatch,
 200     public IOleCommandTarget,
 201     public IOleDocumentSite,
 202     public IAdviseSink,
 203     public IOleControlSite
 204 {
 205 private:
 206     DECLARE_OLE_UNKNOWN(FrameSite);
 207
 208 public:
 209     FrameSite(wxWindow * win, wxActiveXContainer * win2)
 210     {
 211         m_window = win2;
 212         m_bSupportsWindowlessActivation = true;
 213         m_bInPlaceLocked = false;
 214         m_bUIActive = false;
 215         m_bInPlaceActive = false;
 216         m_bWindowless = false;
 217
 218         m_nAmbientLocale = 0;
 219         m_clrAmbientForeColor = ::GetSysColor(COLOR_WINDOWTEXT);
 220         m_clrAmbientBackColor = ::GetSysColor(COLOR_WINDOW);
 221         m_bAmbientShowHatching = true;
 222         m_bAmbientShowGrabHandles = true;
 223         m_bAmbientAppearance = true;
 224
 225         m_hDCBuffer = NULL;
 226         m_hWndParent = (HWND)win->GetHWND();
 227     }
 228     virtual ~FrameSite(){}
 229     //***************************IDispatch*****************************
 230     HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID, OLECHAR ** ,
 231                                             unsigned int , LCID ,
 232                                             DISPID * )
 233     {   return E_NOTIMPL;   }
 234     STDMETHOD(GetTypeInfo)(unsigned int, LCID, ITypeInfo **)
 235     {   return E_NOTIMPL;   }
 236     HRESULT STDMETHODCALLTYPE GetTypeInfoCount(unsigned int *)
 237     {   return E_NOTIMPL;   }
 238     HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID, LCID,
 239                             WORD wFlags, DISPPARAMS *,
 240                             VARIANT * pVarResult, EXCEPINFO *,
 241                             unsigned int *)
 242     {
 243         if (!(wFlags & DISPATCH_PROPERTYGET))
 244             return S_OK;
 245
 246         if (pVarResult == NULL)
 247             return E_INVALIDARG;
 248
 249         //The most common case is boolean, use as an initial type
 250         V_VT(pVarResult) = VT_BOOL;
 251
 252         switch (dispIdMember)
 253         {
 254             case DISPID_AMBIENT_MESSAGEREFLECT:
 255                 V_BOOL(pVarResult)= FALSE;
 256                 return S_OK;
 257
 258             case DISPID_AMBIENT_DISPLAYASDEFAULT:
 259                 V_BOOL(pVarResult)= TRUE;
 260                 return S_OK;
 261
 262             case DISPID_AMBIENT_OFFLINEIFNOTCONNECTED:
 263                 V_BOOL(pVarResult) = TRUE;
 264                 return S_OK;
 265
 266             case DISPID_AMBIENT_SILENT:
 267                 V_BOOL(pVarResult)= TRUE;
 268                 return S_OK;
 269
 270             case DISPID_AMBIENT_APPEARANCE:
 271                 pVarResult->vt = VT_BOOL;
 272                 pVarResult->boolVal = m_bAmbientAppearance;
 273                 break;
 274
 275             case DISPID_AMBIENT_FORECOLOR:
 276                 pVarResult->vt = VT_I4;
 277                 pVarResult->lVal = (long) m_clrAmbientForeColor;
 278                 break;
 279
 280             case DISPID_AMBIENT_BACKCOLOR:
 281                 pVarResult->vt = VT_I4;
 282                 pVarResult->lVal = (long) m_clrAmbientBackColor;
 283                 break;
 284
 285             case DISPID_AMBIENT_LOCALEID:
 286                 pVarResult->vt = VT_I4;
 287                 pVarResult->lVal = (long) m_nAmbientLocale;
 288                 break;
 289
 290             case DISPID_AMBIENT_USERMODE:
 291                 pVarResult->vt = VT_BOOL;
 292                 pVarResult->boolVal = m_window->m_bAmbientUserMode;
 293                 break;
 294
 295             case DISPID_AMBIENT_SHOWGRABHANDLES:
 296                 pVarResult->vt = VT_BOOL;
 297                 pVarResult->boolVal = m_bAmbientShowGrabHandles;
 298                 break;
 299
 300             case DISPID_AMBIENT_SHOWHATCHING:
 301                 pVarResult->vt = VT_BOOL;
 302                 pVarResult->boolVal = m_bAmbientShowHatching;
 303                 break;
 304
 305             default:
 306                 return DISP_E_MEMBERNOTFOUND;
 307         }
 308
 309         return S_OK;
 310     }
 311
 312     //**************************IOleWindow***************************
 313     HRESULT STDMETHODCALLTYPE GetWindow(HWND * phwnd)
 314     {
 315         if (phwnd == NULL)
 316             return E_INVALIDARG;
 317         (*phwnd) = m_hWndParent;
 318         return S_OK;
 319     }
 320     HRESULT STDMETHODCALLTYPE ContextSensitiveHelp(BOOL)
 321     {return S_OK;}
 322     //**************************IOleInPlaceUIWindow*****************
 323     HRESULT STDMETHODCALLTYPE GetBorder(LPRECT lprectBorder)
 324     {
 325         if (lprectBorder == NULL)
 326             return E_INVALIDARG;
 327         return INPLACE_E_NOTOOLSPACE;
 328     }
 329     HRESULT STDMETHODCALLTYPE RequestBorderSpace(LPCBORDERWIDTHS pborderwidths)
 330     {
 331         if (pborderwidths == NULL)
 332             return E_INVALIDARG;
 333         return INPLACE_E_NOTOOLSPACE;
 334     }
 335     HRESULT STDMETHODCALLTYPE SetBorderSpace(LPCBORDERWIDTHS)
 336     {return S_OK;}
 337     HRESULT STDMETHODCALLTYPE SetActiveObject(
 338         IOleInPlaceActiveObject *pActiveObject, LPCOLESTR)
 339     {
 340         if (pActiveObject)
 341             pActiveObject->AddRef();
 342
 343         m_window->m_oleInPlaceActiveObject = pActiveObject;
 344         return S_OK;
 345     }
 346
 347     //********************IOleInPlaceFrame************************
 348
 349     STDMETHOD(InsertMenus)(HMENU, LPOLEMENUGROUPWIDTHS){return S_OK;}
 350     STDMETHOD(SetMenu)(HMENU, HOLEMENU, HWND){  return S_OK;}
 351     STDMETHOD(RemoveMenus)(HMENU){return S_OK;}
 352     STDMETHOD(SetStatusText)(LPCOLESTR){ return S_OK;}
 353     HRESULT STDMETHODCALLTYPE EnableModeless(BOOL){return S_OK;}
 354     HRESULT STDMETHODCALLTYPE TranslateAccelerator(LPMSG lpmsg, WORD)
 355     {
 356         // TODO: send an event with this id
 357         if (m_window->m_oleInPlaceActiveObject.IsOk())
 358             m_window->m_oleInPlaceActiveObject->TranslateAccelerator(lpmsg);
 359         return S_FALSE;
 360     }
 361
 362     //*******************IOleInPlaceSite**************************
 363     HRESULT STDMETHODCALLTYPE CanInPlaceActivate(){return S_OK;}
 364     HRESULT STDMETHODCALLTYPE OnInPlaceActivate()
 365     {   m_bInPlaceActive = true;    return S_OK;    }
 366     HRESULT STDMETHODCALLTYPE OnUIActivate()
 367     {   m_bUIActive = true;         return S_OK;    }
 368     HRESULT STDMETHODCALLTYPE GetWindowContext(IOleInPlaceFrame **ppFrame,
 369                                         IOleInPlaceUIWindow **ppDoc,
 370                                         LPRECT lprcPosRect,
 371                                         LPRECT lprcClipRect,
 372                                         LPOLEINPLACEFRAMEINFO lpFrameInfo)
 373     {
 374         if (ppFrame == NULL || ppDoc == NULL || lprcPosRect == NULL ||
 375             lprcClipRect == NULL || lpFrameInfo == NULL)
 376         {
 377             if (ppFrame != NULL)
 378                 (*ppFrame) = NULL;
 379             if (ppDoc != NULL)
 380                 (*ppDoc) = NULL;
 381             return E_INVALIDARG;
 382         }
 383
 384         HRESULT hr = QueryInterface(IID_IOleInPlaceFrame, (void **) ppFrame);
 385         if (! SUCCEEDED(hr))
 386         {
 387             return E_UNEXPECTED;
 388         }
 389
 390         hr = QueryInterface(IID_IOleInPlaceUIWindow, (void **) ppDoc);
 391         if (! SUCCEEDED(hr))
 392         {
 393             (*ppFrame)->Release();
 394             *ppFrame = NULL;
 395             return E_UNEXPECTED;
 396         }
 397
 398         RECT rect;
 399         ::GetClientRect(m_hWndParent, &rect);
 400         if (lprcPosRect)
 401         {
 402             lprcPosRect->left = lprcPosRect->top = 0;
 403             lprcPosRect->right = rect.right;
 404             lprcPosRect->bottom = rect.bottom;
 405         }
 406         if (lprcClipRect)
 407         {
 408             lprcClipRect->left = lprcClipRect->top = 0;
 409             lprcClipRect->right = rect.right;
 410             lprcClipRect->bottom = rect.bottom;
 411         }
 412
 413         memset(lpFrameInfo, 0, sizeof(OLEINPLACEFRAMEINFO));
 414         lpFrameInfo->cb = sizeof(OLEINPLACEFRAMEINFO);
 415         lpFrameInfo->hwndFrame = m_hWndParent;
 416
 417         return S_OK;
 418     }
 419     HRESULT STDMETHODCALLTYPE Scroll(SIZE){return S_OK;}
 420     HRESULT STDMETHODCALLTYPE OnUIDeactivate(BOOL)
 421     {   m_bUIActive = false;         return S_OK;    }
 422     HRESULT STDMETHODCALLTYPE OnInPlaceDeactivate()
 423     {   m_bInPlaceActive = false;    return S_OK;    }
 424     HRESULT STDMETHODCALLTYPE DiscardUndoState(){return S_OK;}
 425     HRESULT STDMETHODCALLTYPE DeactivateAndUndo(){return S_OK; }
 426     HRESULT STDMETHODCALLTYPE OnPosRectChange(LPCRECT lprcPosRect)
 427     {
 428         if (m_window->m_oleInPlaceObject.IsOk() && lprcPosRect)
 429         {
 430            //
 431            // Result of several hours and days of bug hunting -
 432            // this is called by an object when it wants to resize
 433            // itself to something different then our parent window -
 434            // don't let it :)
 435            //
 436 //            m_window->m_oleInPlaceObject->SetObjectRects(
 437 //                lprcPosRect, lprcPosRect);
 438            RECT rcClient;
 439            ::GetClientRect(m_hWndParent, &rcClient);
 440             m_window->m_oleInPlaceObject->SetObjectRects(
 441                 &rcClient, &rcClient);
 442         }
 443         return S_OK;
 444     }
 445     //*************************IOleInPlaceSiteEx***********************
 446     HRESULT STDMETHODCALLTYPE OnInPlaceActivateEx(BOOL * pfNoRedraw, DWORD)
 447     {
 448 #ifdef __WXWINCE__
 449         IRunnableObject* runnable = NULL;
 450         HRESULT hr = QueryInterface(
 451             IID_IRunnableObject, (void**)(& runnable));
 452         if (SUCCEEDED(hr))
 453         {
 454             runnable->LockRunning(TRUE, FALSE);
 455         }
 456 #else
 457         OleLockRunning(m_window->m_ActiveX, TRUE, FALSE);
 458 #endif
 459         if (pfNoRedraw)
 460             (*pfNoRedraw) = FALSE;
 461         return S_OK;
 462     }
 463
 464     HRESULT STDMETHODCALLTYPE OnInPlaceDeactivateEx(BOOL)
 465     {
 466 #ifdef __WXWINCE__
 467         IRunnableObject* runnable = NULL;
 468         HRESULT hr = QueryInterface(
 469             IID_IRunnableObject, (void**)(& runnable));
 470         if (SUCCEEDED(hr))
 471         {
 472             runnable->LockRunning(FALSE, FALSE);
 473         }
 474 #else
 475         OleLockRunning(m_window->m_ActiveX, FALSE, FALSE);
 476 #endif
 477         return S_OK;
 478     }
 479     STDMETHOD(RequestUIActivate)(){ return S_OK;}
 480     //*************************IOleClientSite**************************
 481     HRESULT STDMETHODCALLTYPE SaveObject(){return S_OK;}
 482     const char *OleGetMonikerToStr(DWORD dwAssign)
 483     {
 484         switch (dwAssign)
 485         {
 486         case OLEGETMONIKER_ONLYIFTHERE  : return "OLEGETMONIKER_ONLYIFTHERE";
 487         case OLEGETMONIKER_FORCEASSIGN  : return "OLEGETMONIKER_FORCEASSIGN";
 488         case OLEGETMONIKER_UNASSIGN     : return "OLEGETMONIKER_UNASSIGN";
 489         case OLEGETMONIKER_TEMPFORUSER  : return "OLEGETMONIKER_TEMPFORUSER";
 490         default                         : return "Bad Enum";
 491         }
 492     }
 493
 494     const char *OleGetWhicMonikerStr(DWORD dwWhichMoniker)
 495     {
 496         switch(dwWhichMoniker)
 497         {
 498         case OLEWHICHMK_CONTAINER   : return "OLEWHICHMK_CONTAINER";
 499         case OLEWHICHMK_OBJREL      : return "OLEWHICHMK_OBJREL";
 500         case OLEWHICHMK_OBJFULL     : return "OLEWHICHMK_OBJFULL";
 501         default                     : return "Bad Enum";
 502         }
 503     }
 504     STDMETHOD(GetMoniker)(DWORD, DWORD, IMoniker **){return E_FAIL;}
 505     HRESULT STDMETHODCALLTYPE GetContainer(LPOLECONTAINER * ppContainer)
 506     {
 507         if (ppContainer == NULL)
 508             return E_INVALIDARG;
 509         HRESULT hr = QueryInterface(
 510             IID_IOleContainer, (void**)(ppContainer));
 511         wxASSERT(SUCCEEDED(hr));
 512         return hr;
 513     }
 514     HRESULT STDMETHODCALLTYPE ShowObject()
 515     {
 516         if (m_window->m_oleObjectHWND)
 517             ::ShowWindow(m_window->m_oleObjectHWND, SW_SHOW);
 518         return S_OK;
 519     }
 520     STDMETHOD(OnShowWindow)(BOOL){return S_OK;}
 521     STDMETHOD(RequestNewObjectLayout)(){return E_NOTIMPL;}
 522     //********************IParseDisplayName***************************
 523     HRESULT STDMETHODCALLTYPE ParseDisplayName(
 524         IBindCtx *, LPOLESTR, ULONG *, IMoniker **){return E_NOTIMPL;}
 525     //********************IOleContainer*******************************
 526     STDMETHOD(EnumObjects)(DWORD, IEnumUnknown **){return E_NOTIMPL;}
 527     HRESULT STDMETHODCALLTYPE LockContainer(BOOL){return S_OK;}
 528     //********************IOleItemContainer***************************
 529     HRESULT STDMETHODCALLTYPE
 530     #if 0 // defined(__WXWINCE__) && __VISUALC__ < 1400
 531     GetObject
 532     #elif defined(_UNICODE)
 533     GetObjectW
 534     #else
 535     GetObjectA
 536     #endif
 537     (LPOLESTR pszItem, DWORD, IBindCtx *, REFIID, void ** ppvObject)
 538     {
 539         if (pszItem == NULL || ppvObject == NULL)
 540             return E_INVALIDARG;
 541         *ppvObject = NULL;
 542         return MK_E_NOOBJECT;
 543     }
 544     HRESULT STDMETHODCALLTYPE GetObjectStorage(
 545         LPOLESTR pszItem, IBindCtx * , REFIID, void ** ppvStorage)
 546     {
 547         if (pszItem == NULL || ppvStorage == NULL)
 548             return E_INVALIDARG;
 549         *ppvStorage = NULL;
 550         return MK_E_NOOBJECT;
 551     }
 552     HRESULT STDMETHODCALLTYPE IsRunning(LPOLESTR pszItem)
 553     {
 554         if (pszItem == NULL)
 555             return E_INVALIDARG;
 556         return MK_E_NOOBJECT;
 557     }
 558     //***********************IOleControlSite*****************************
 559     HRESULT STDMETHODCALLTYPE OnControlInfoChanged()
 560     {return S_OK;}
 561     HRESULT STDMETHODCALLTYPE LockInPlaceActive(BOOL fLock)
 562     {
 563         m_bInPlaceLocked = (fLock) ? true : false;
 564         return S_OK;
 565     }
 566     HRESULT STDMETHODCALLTYPE GetExtendedControl(IDispatch **)
 567     {return E_NOTIMPL;}
 568     HRESULT STDMETHODCALLTYPE TransformCoords(
 569         POINTL * pPtlHimetric, POINTF * pPtfContainer, DWORD)
 570     {
 571         if (pPtlHimetric == NULL || pPtfContainer == NULL)
 572             return E_INVALIDARG;
 573         return E_NOTIMPL;
 574     }
 575     HRESULT STDMETHODCALLTYPE TranslateAccelerator(LPMSG, DWORD)
 576     {return E_NOTIMPL;}
 577     HRESULT STDMETHODCALLTYPE OnFocus(BOOL){return S_OK;}
 578     HRESULT STDMETHODCALLTYPE ShowPropertyFrame(){return E_NOTIMPL;}
 579     //**************************IOleCommandTarget***********************
 580     HRESULT STDMETHODCALLTYPE QueryStatus(const GUID *, ULONG cCmds,
 581                                 OLECMD prgCmds[], OLECMDTEXT *)
 582     {
 583         if (prgCmds == NULL) return E_INVALIDARG;
 584         for (ULONG nCmd = 0; nCmd < cCmds; nCmd++)
 585         {
 586             // unsupported by default
 587             prgCmds[nCmd].cmdf = 0;
 588         }
 589         return OLECMDERR_E_UNKNOWNGROUP;
 590     }
 591
 592     HRESULT STDMETHODCALLTYPE Exec(const GUID *, DWORD,
 593                             DWORD, VARIANTARG *, VARIANTARG *)
 594     {return OLECMDERR_E_NOTSUPPORTED;}
 595
 596     //**********************IAdviseSink************************************
 597     void STDMETHODCALLTYPE OnDataChange(FORMATETC *, STGMEDIUM *) {}
 598     void STDMETHODCALLTYPE OnViewChange(DWORD, LONG) {}
 599     void STDMETHODCALLTYPE OnRename(IMoniker *){}
 600     void STDMETHODCALLTYPE OnSave(){}
 601     void STDMETHODCALLTYPE OnClose(){}
 602
 603     //**********************IOleDocumentSite***************************
 604     HRESULT STDMETHODCALLTYPE ActivateMe(
 605         IOleDocumentView __RPC_FAR *pViewToActivate)
 606     {
 607         wxAutoIOleInPlaceSite inPlaceSite(
 608             IID_IOleInPlaceSite, (IDispatch *) this);
 609         if (!inPlaceSite.IsOk())
 610             return E_FAIL;
 611
 612         if (pViewToActivate)
 613         {
 614             m_window->m_docView = pViewToActivate;
 615             m_window->m_docView->SetInPlaceSite(inPlaceSite);
 616         }
 617         else
 618         {
 619             wxAutoIOleDocument oleDoc(
 620                 IID_IOleDocument, m_window->m_oleObject);
 621             if (! oleDoc.IsOk())
 622                 return E_FAIL;
 623
 624             HRESULT hr = oleDoc->CreateView(inPlaceSite, NULL,
 625                                     0, m_window->m_docView.GetRef());
 626             if (hr != S_OK)
 627                 return E_FAIL;
 628
 629             m_window->m_docView->SetInPlaceSite(inPlaceSite);
 630         }
 631
 632         m_window->m_docView->UIActivate(TRUE);
 633         return S_OK;
 634     }
 635
 636     friend bool QueryClientSiteInterface(FrameSite *self, REFIID iid, void **_interface, const char *&desc)
 637     {
 638         return self->m_window->QueryClientSiteInterface(iid,_interface,desc);
 639     }
 640
 641 protected:
 642     wxActiveXContainer * m_window;
 643
 644     HDC m_hDCBuffer;
 645     HWND m_hWndParent;
 646
 647     bool m_bSupportsWindowlessActivation;
 648     bool m_bInPlaceLocked;
 649     bool m_bInPlaceActive;
 650     bool m_bUIActive;
 651     bool m_bWindowless;
 652
 653     LCID m_nAmbientLocale;
 654     COLORREF m_clrAmbientForeColor;
 655     COLORREF m_clrAmbientBackColor;
 656     bool m_bAmbientShowHatching;
 657     bool m_bAmbientShowGrabHandles;
 658     bool m_bAmbientAppearance;
 659 };
 660
 661 DEFINE_OLE_TABLE(FrameSite)
 662     OLE_INTERFACE(IID_IUnknown, IOleClientSite)
 663     OLE_IINTERFACE(IOleClientSite)
 664     OLE_INTERFACE(IID_IOleWindow, IOleInPlaceSite)
 665     OLE_IINTERFACE(IOleInPlaceSite)
 666     OLE_IINTERFACE(IOleInPlaceSiteEx)
 667     OLE_IINTERFACE(IOleInPlaceUIWindow)
 668     OLE_IINTERFACE(IOleInPlaceFrame)
 669     OLE_IINTERFACE(IParseDisplayName)
 670     OLE_IINTERFACE(IOleContainer)
 671     OLE_IINTERFACE(IOleItemContainer)
 672     OLE_IINTERFACE(IDispatch)
 673     OLE_IINTERFACE(IOleCommandTarget)
 674     OLE_IINTERFACE(IOleDocumentSite)
 675     OLE_IINTERFACE(IAdviseSink)
 676     OLE_IINTERFACE(IOleControlSite)
 677     OLE_INTERFACE_CUSTOM(QueryClientSiteInterface)
 678 END_OLE_TABLE
 679
 680
 681 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 682 //
 683 // wxActiveXEvents
 684 //
 685 // Handles and sends activex events received from the ActiveX control
 686 // to the appropriate wxEvtHandler
 687 //
 688 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 689 class wxActiveXEvents : public IDispatch
 690 {
 691 private:
 692     DECLARE_OLE_UNKNOWN(wxActiveXEvents);
 693
 694
 695     wxActiveXContainer *m_activeX;
 696     IID m_customId;
 697     bool m_haveCustomId;
 698
 699     friend bool wxActiveXEventsInterface(wxActiveXEvents *self, REFIID iid, void **_interface, const char *&desc);
 700
 701 public:
 702
 703     // a pointer to this static variable is used as an 'invalid_entry_marker'
 704     // wxVariants containing a void* to this variables are 'empty' in the sense
 705     // that the actual ActiveX OLE parameter has not been converted and inserted
 706     // into m_params.
 707     static wxVariant ms_invalidEntryMarker;
 708
 709     wxActiveXEvents(wxActiveXContainer *ax) : m_activeX(ax), m_haveCustomId(false) {}
 710     wxActiveXEvents(wxActiveXContainer *ax, REFIID iid) : m_activeX(ax), m_customId(iid), m_haveCustomId(true) {}
 711     virtual ~wxActiveXEvents()
 712     {
 713     }
 714
 715     // IDispatch
 716     STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR**, unsigned int, LCID, DISPID*)
 717     {
 718         return E_NOTIMPL;
 719     }
 720
 721     STDMETHODIMP GetTypeInfo(unsigned int, LCID, ITypeInfo**)
 722     {
 723         return E_NOTIMPL;
 724     }
 725
 726     STDMETHODIMP GetTypeInfoCount(unsigned int*)
 727     {
 728         return E_NOTIMPL;
 729     }
 730
 731
 732     STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid,
 733                         LCID lcid,
 734                           WORD wFlags, DISPPARAMS * pDispParams,
 735                           VARIANT * pVarResult, EXCEPINFO * pExcepInfo,
 736                           unsigned int * puArgErr)
 737     {
 738         if (wFlags & (DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF))
 739             return E_NOTIMPL;
 740
 741         wxASSERT(m_activeX);
 742
 743         // ActiveX Event
 744
 745         // Dispatch Event
 746         wxActiveXEvent  event;
 747         event.SetEventType(wxEVT_ACTIVEX);
 748         // Create an empty list of Variants
 749         // Note that the event parameters use lazy evaluation
 750         // They are not actually created until wxActiveXEvent::operator[] is called
 751         event.m_params.NullList();
 752         event.m_dispid = dispIdMember;
 753
 754         // save the native (MSW) event parameters for event handlers that need to access them
 755         // this can be done on the stack since wxActiveXEvent is also allocated on the stack
 756         wxActiveXEventNativeMSW eventParameters(dispIdMember, riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 757         event.SetClientData(&eventParameters);
 758
 759         // The event parameters are not copied to event.m_params until they are actually
 760         // referenced in wxActiveXEvent::operator[]
 761         // This increases performance and avoids error messages and/or crashes
 762         // when the event has parameters that are not (yet or never) supported
 763         // by wxConvertOleToVariant
 764
 765         // process the events from the activex method
 766         m_activeX->ProcessEvent(event);
 767         for (DWORD i = 0; i < pDispParams->cArgs; i++)
 768         {
 769             size_t params_index = pDispParams->cArgs - i - 1;
 770             if (params_index < event.m_params.GetCount()) {
 771                 wxVariant &vx = event.m_params[params_index];
 772                 // copy the result back to pDispParams only if the event has been accessed
 773                 //  i.e.  if vx != ms_invalidEntryMarker
 774                 if (!vx.IsType(wxActiveXEvents::ms_invalidEntryMarker.GetType()) || vx!=ms_invalidEntryMarker) {
 775                     VARIANTARG& va = pDispParams->rgvarg[i];
 776                     wxConvertVariantToOle(vx, va);
 777                 }
 778             }
 779         }
 780
 781         if(event.GetSkipped())
 782             return DISP_E_MEMBERNOTFOUND;
 783
 784         return S_OK;
 785     }
 786 };
 787
 788 namespace
 789 {
 790 // just a unique global variable
 791 const int invalid_entry_marker = 0;
 792 }
 793
 794 wxVariant wxActiveXEvents::ms_invalidEntryMarker((void*)&invalid_entry_marker);
 795
 796 size_t wxActiveXEvent::ParamCount() const
 797 {
 798     wxActiveXEventNativeMSW *native=GetNativeParameters();
 799     // 'native' will always be != if the event has been created
 800     // for an actual active X event.
 801     // But it may be zero if the event has been created by wx program code.
 802     if (native)
 803         return native->pDispParams ? native->pDispParams->cArgs : 0;
 804
 805     return m_params.GetCount();
 806 }
 807
 808 wxVariant &wxActiveXEvent::operator [](size_t idx)
 809 {
 810     wxASSERT(idx < ParamCount());
 811     wxActiveXEventNativeMSW *native=GetNativeParameters();
 812     // 'native' will always be != if the event has been created
 813     // for an actual active X event.
 814     // But it may be zero if the event has been created by wx program code.
 815     if (native)
 816     {
 817         while ( m_params.GetCount()<=idx )
 818         {
 819             m_params.Append(wxActiveXEvents::ms_invalidEntryMarker);
 820         }
 821
 822         wxVariant& vx = m_params[idx];
 823         if ( vx.IsType(wxActiveXEvents::ms_invalidEntryMarker.GetType()) &&
 824                 vx == wxActiveXEvents::ms_invalidEntryMarker)
 825         {
 826             // copy the _real_ parameter into this one
 827             // NOTE: m_params stores the parameters in *reverse* order.
 828             // Whyever, but this was the case in the original implementation of
 829             // wxActiveXEvents::Invoke
 830             // Keep this convention.
 831             VARIANTARG& va = native->pDispParams->rgvarg[ native->pDispParams->cArgs - idx - 1 ];
 832             wxConvertOleToVariant(va, vx);
 833         }
 834         return vx;
 835     }
 836     return m_params[idx];
 837 }
 838
 839 bool wxActiveXEventsInterface(wxActiveXEvents *self, REFIID iid, void **_interface, const char *&desc)
 840 {
 841     if (self->m_haveCustomId && IsEqualIID(iid, self->m_customId))
 842     {
 843         *_interface = (IUnknown *) (IDispatch *) self;
 844         desc = "Custom Dispatch Interface";
 845         return true;
 846     }
 847
 848     return false;
 849 }
 850
 851 DEFINE_OLE_TABLE(wxActiveXEvents)
 852     OLE_IINTERFACE(IUnknown)
 853     OLE_INTERFACE(IID_IDispatch, IDispatch)
 854     OLE_INTERFACE_CUSTOM(wxActiveXEventsInterface)
 855 END_OLE_TABLE
 856
 857 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 858 //
 859 // wxActiveXContainer
 860 //
 861 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 862
 863 //---------------------------------------------------------------------------
 864 // wxActiveXContainer Constructor
 865 //
 866 // Initializes members and creates the native ActiveX container
 867 //---------------------------------------------------------------------------
 868 wxActiveXContainer::wxActiveXContainer(wxWindow * parent,
 869                                        REFIID iid, IUnknown* pUnk)
 870     : m_realparent(parent)
 871 {
 872     m_bAmbientUserMode = true;
 873     m_docAdviseCookie = 0;
 874     CreateActiveX(iid, pUnk);
 875 }
 876
 877 //---------------------------------------------------------------------------
 878 // wxActiveXContainer Destructor
 879 //
 880 // Destroys members (the FrameSite et al. are destroyed implicitly
 881 // through COM ref counting)
 882 //---------------------------------------------------------------------------
 883 wxActiveXContainer::~wxActiveXContainer()
 884 {
 885     // disconnect connection points
 886     if (m_oleInPlaceObject.IsOk())
 887     {
 888         m_oleInPlaceObject->InPlaceDeactivate();
 889         m_oleInPlaceObject->UIDeactivate();
 890     }
 891
 892     if (m_oleObject.IsOk())
 893     {
 894         if (m_docAdviseCookie != 0)
 895             m_oleObject->Unadvise(m_docAdviseCookie);
 896
 897         m_oleObject->DoVerb(
 898             OLEIVERB_HIDE, NULL, m_clientSite, 0, (HWND) GetHWND(), NULL);
 899         m_oleObject->Close(OLECLOSE_NOSAVE);
 900         m_oleObject->SetClientSite(NULL);
 901     }
 902
 903     // m_clientSite uses m_frameSite so destroy it first
 904     m_clientSite.Free();
 905     delete m_frameSite;
 906
 907     // our window doesn't belong to us, don't destroy it
 908     m_hWnd = NULL;
 909 }
 910
 911 // VZ: we might want to really report an error instead of just asserting here
 912 #if wxDEBUG_LEVEL
 913     #define CHECK_HR(hr) \
 914         wxASSERT_LEVEL_2_MSG( SUCCEEDED(hr), \
 915                 wxString::Format("HRESULT = %X", (unsigned)(hr)) )
 916 #else
 917     #define CHECK_HR(hr) wxUnusedVar(hr)
 918 #endif
 919
 920 //---------------------------------------------------------------------------
 921 // wxActiveXContainer::CreateActiveX
 922 //
 923 // Actually creates the ActiveX container through the FrameSite
 924 // and sets up ActiveX events
 925 //
 926 // TODO: Document this more
 927 //---------------------------------------------------------------------------
 928 void wxActiveXContainer::CreateActiveX(REFIID iid, IUnknown* pUnk)
 929 {
 930     HRESULT hret;
 931     hret = m_ActiveX.QueryInterface(iid, pUnk);
 932     CHECK_HR(hret);
 933
 934     // FrameSite
 935     m_frameSite = new FrameSite(m_realparent, this);
 936     // oleClientSite
 937     hret = m_clientSite.QueryInterface(
 938         IID_IOleClientSite, (IDispatch *) m_frameSite);
 939     CHECK_HR(hret);
 940     // adviseSink
 941     wxAutoIAdviseSink adviseSink(IID_IAdviseSink, (IDispatch *) m_frameSite);
 942     wxASSERT(adviseSink.IsOk());
 943
 944     // Get Dispatch interface
 945     hret = m_Dispatch.QueryInterface(IID_IDispatch, m_ActiveX);
 946     CHECK_HR(hret);
 947
 948     //
 949     // SETUP TYPEINFO AND ACTIVEX EVENTS
 950     //
 951
 952     // get type info via class info
 953     wxAutoIProvideClassInfo classInfo(IID_IProvideClassInfo, m_ActiveX);
 954     wxASSERT(classInfo.IsOk());
 955
 956     // type info
 957     wxAutoITypeInfo typeInfo;
 958     hret = classInfo->GetClassInfo(typeInfo.GetRef());
 959     CHECK_HR(hret);
 960     wxASSERT(typeInfo.IsOk());
 961
 962     // TYPEATTR
 963     TYPEATTR *ta = NULL;
 964     hret = typeInfo->GetTypeAttr(&ta);
 965     CHECK_HR(hret);
 966
 967     // this should be a TKIND_COCLASS
 968     wxASSERT(ta->typekind == TKIND_COCLASS);
 969
 970     // iterate contained interfaces
 971     for (int i = 0; i < ta->cImplTypes; i++)
 972     {
 973         HREFTYPE rt = 0;
 974
 975         // get dispatch type info handle
 976         hret = typeInfo->GetRefTypeOfImplType(i, &rt);
 977         if (! SUCCEEDED(hret))
 978             continue;
 979
 980         // get dispatch type info interface
 981         wxAutoITypeInfo  ti;
 982         hret = typeInfo->GetRefTypeInfo(rt, ti.GetRef());
 983         if (! ti.IsOk())
 984             continue;
 985
 986         CHECK_HR(hret);
 987
 988         // check if default event sink
 989         bool defEventSink = false;
 990         int impTypeFlags = 0;
 991         typeInfo->GetImplTypeFlags(i, &impTypeFlags);
 992
 993         if (impTypeFlags & IMPLTYPEFLAG_FDEFAULT)
 994         {
 995             if (impTypeFlags & IMPLTYPEFLAG_FSOURCE)
 996             {
 997                 // WXOLE_TRACEOUT("Default Event Sink");
 998                 defEventSink = true;
 999                 if (impTypeFlags & IMPLTYPEFLAG_FDEFAULTVTABLE)
1000                 {
1001                     // WXOLE_TRACEOUT("*ERROR* - Default Event Sink is via vTable");
1002                     defEventSink = false;
1003                     wxFAIL_MSG(wxT("Default event sink is in vtable!"));
1004                 }
1005             }
1006         }
1007
1008
1009         // wxAutoOleInterface<> assumes a ref has already been added
1010         // TYPEATTR
1011         TYPEATTR *ta = NULL;
1012         hret = ti->GetTypeAttr(&ta);
1013         CHECK_HR(hret);
1014
1015         if (ta->typekind == TKIND_DISPATCH)
1016         {
1017             // WXOLE_TRACEOUT("GUID = " << GetIIDName(ta->guid).c_str());
1018             if (defEventSink)
1019             {
1020                 wxAutoIConnectionPoint    cp;
1021                 DWORD                    adviseCookie = 0;
1022
1023                 wxAutoIConnectionPointContainer cpContainer(IID_IConnectionPointContainer, m_ActiveX);
1024                 wxASSERT( cpContainer.IsOk());
1025
1026                 HRESULT hret =
1027                     cpContainer->FindConnectionPoint(ta->guid, cp.GetRef());
1028
1029                 // Notice that the return value of CONNECT_E_NOCONNECTION is
1030                 // expected if the interface doesn't support connection points.
1031                 if ( hret != CONNECT_E_NOCONNECTION )
1032                 {
1033                     CHECK_HR(hret);
1034                 }
1035
1036                 if ( cp )
1037                 {
1038                     wxActiveXEvents * const
1039                         events = new wxActiveXEvents(this, ta->guid);
1040                     hret = cp->Advise(events, &adviseCookie);
1041
1042                     // We don't need this object any more and cp will keep a
1043                     // reference to it if it needs it, i.e. if Advise()
1044                     // succeeded.
1045                     events->Release();
1046
1047                     CHECK_HR(hret);
1048                 }
1049             }
1050         }
1051
1052         ti->ReleaseTypeAttr(ta);
1053     }
1054
1055     // free
1056     typeInfo->ReleaseTypeAttr(ta);
1057
1058     //
1059     // END
1060     //
1061
1062     // Get IOleObject interface
1063     hret = m_oleObject.QueryInterface(IID_IOleObject, m_ActiveX);
1064     CHECK_HR(hret);
1065
1066     // get IViewObject Interface
1067     hret = m_viewObject.QueryInterface(IID_IViewObject, m_ActiveX);
1068     CHECK_HR(hret);
1069
1070     // document advise
1071     m_docAdviseCookie = 0;
1072     hret = m_oleObject->Advise(adviseSink, &m_docAdviseCookie);
1073     CHECK_HR(hret);
1074
1075     // TODO:Needed?
1076 //    hret = m_viewObject->SetAdvise(DVASPECT_CONTENT, 0, adviseSink);
1077     m_oleObject->SetHostNames(L"wxActiveXContainer", NULL);
1078     OleSetContainedObject(m_oleObject, TRUE);
1079     OleRun(m_oleObject);
1080
1081
1082     // Get IOleInPlaceObject interface
1083     hret = m_oleInPlaceObject.QueryInterface(
1084         IID_IOleInPlaceObject, m_ActiveX);
1085     CHECK_HR(hret);
1086
1087     // status
1088     DWORD dwMiscStatus;
1089     m_oleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
1090     CHECK_HR(hret);
1091
1092     // set client site first ?
1093     if (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)
1094         m_oleObject->SetClientSite(m_clientSite);
1095
1096
1097     // stream init
1098     wxAutoIPersistStreamInit
1099         pPersistStreamInit(IID_IPersistStreamInit, m_oleObject);
1100
1101     if (pPersistStreamInit.IsOk())
1102     {
1103         hret = pPersistStreamInit->InitNew();
1104         CHECK_HR(hret);
1105     }
1106
1107     if (! (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST))
1108         m_oleObject->SetClientSite(m_clientSite);
1109
1110
1111     m_oleObjectHWND = 0;
1112
1113
1114     if (! (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME))
1115     {
1116         hret = m_oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL,
1117             m_clientSite, 0, (HWND)m_realparent->GetHWND(), NULL);
1118         CHECK_HR(hret);
1119
1120         if (m_oleInPlaceObject.IsOk())
1121         {
1122             hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
1123             CHECK_HR(hret);
1124             ::SetActiveWindow(m_oleObjectHWND);
1125         }
1126
1127         RECT posRect;
1128         wxCopyRectToRECT(m_realparent->GetClientSize(), posRect);
1129
1130         if (posRect.right > 0 && posRect.bottom > 0 &&
1131             m_oleInPlaceObject.IsOk())
1132         {
1133             m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
1134         }
1135
1136         hret = m_oleObject->DoVerb(OLEIVERB_SHOW, 0, m_clientSite, 0,
1137             (HWND)m_realparent->GetHWND(), &posRect);
1138         CHECK_HR(hret);
1139     }
1140
1141     if (! m_oleObjectHWND && m_oleInPlaceObject.IsOk())
1142     {
1143         hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
1144         CHECK_HR(hret);
1145     }
1146
1147     if (m_oleObjectHWND)
1148     {
1149         ::SetActiveWindow(m_oleObjectHWND);
1150         ::ShowWindow(m_oleObjectHWND, SW_SHOW);
1151
1152         this->AssociateHandle(m_oleObjectHWND);
1153         this->Reparent(m_realparent);
1154
1155         wxWindow* pWnd = m_realparent;
1156         int id = m_realparent->GetId();
1157
1158         pWnd->Connect(id, wxEVT_SIZE,
1159             wxSizeEventHandler(wxActiveXContainer::OnSize), 0, this);
1160 //        this->Connect(GetId(), wxEVT_PAINT,
1161 //            wxPaintEventHandler(wxActiveXContainer::OnPaint), 0, this);
1162         pWnd->Connect(id, wxEVT_SET_FOCUS,
1163             wxFocusEventHandler(wxActiveXContainer::OnSetFocus), 0, this);
1164         pWnd->Connect(id, wxEVT_KILL_FOCUS,
1165             wxFocusEventHandler(wxActiveXContainer::OnKillFocus), 0, this);
1166     }
1167 }
1168
1169 //---------------------------------------------------------------------------
1170 // wxActiveXContainer::OnSize
1171 //
1172 // Called when the parent is resized - we need to do this to actually
1173 // move the ActiveX control to where the parent is
1174 //---------------------------------------------------------------------------
1175 void wxActiveXContainer::OnSize(wxSizeEvent& event)
1176 {
1177     int w, h;
1178     GetParent()->GetClientSize(&w, &h);
1179
1180     RECT posRect;
1181     posRect.left = 0;
1182     posRect.top = 0;
1183     posRect.right = w;
1184     posRect.bottom = h;
1185
1186     if (w <= 0 || h <= 0)
1187         return;
1188
1189     // extents are in HIMETRIC units
1190     if (m_oleObject.IsOk())
1191     {
1192
1193         SIZEL sz = {w, h};
1194         PixelsToHimetric(sz);
1195
1196         SIZEL sz2;
1197
1198         m_oleObject->GetExtent(DVASPECT_CONTENT, &sz2);
1199         if (sz2.cx !=  sz.cx || sz.cy != sz2.cy)
1200             m_oleObject->SetExtent(DVASPECT_CONTENT, &sz);
1201
1202     }
1203
1204     if (m_oleInPlaceObject.IsOk())
1205         m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
1206
1207     event.Skip();
1208 }
1209
1210 //---------------------------------------------------------------------------
1211 // wxActiveXContainer::OnPaint
1212 //
1213 // Called when the parent is resized - repaints the ActiveX control
1214 //---------------------------------------------------------------------------
1215 void wxActiveXContainer::OnPaint(wxPaintEvent& WXUNUSED(event))
1216 {
1217     wxPaintDC dc(this);
1218     // Draw only when control is windowless or deactivated
1219     if (m_viewObject)
1220     {
1221         int w, h;
1222         GetParent()->GetSize(&w, &h);
1223         RECT posRect;
1224         posRect.left = 0;
1225         posRect.top = 0;
1226         posRect.right = w;
1227         posRect.bottom = h;
1228
1229 #if !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1230         ::RedrawWindow(m_oleObjectHWND, NULL, NULL, RDW_INTERNALPAINT);
1231 #else
1232         ::InvalidateRect(m_oleObjectHWND, NULL, false);
1233 #endif
1234         RECTL *prcBounds = (RECTL *) &posRect;
1235         wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
1236         m_viewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL,
1237             (HDC)msw->GetHDC(), prcBounds, NULL, NULL, 0);
1238     }
1239 }
1240
1241 //---------------------------------------------------------------------------
1242 // wxActiveXContainer::OnSetFocus
1243 //
1244 // Called when the focus is set on the parent - activates the activex control
1245 //---------------------------------------------------------------------------
1246 void wxActiveXContainer::OnSetFocus(wxFocusEvent& event)
1247 {
1248     if (m_oleInPlaceActiveObject.IsOk())
1249         m_oleInPlaceActiveObject->OnFrameWindowActivate(TRUE);
1250
1251     event.Skip();
1252 }
1253
1254 //---------------------------------------------------------------------------
1255 // wxActiveXContainer::OnKillFocus
1256 //
1257 // Called when the focus is killed on the parent -
1258 // deactivates the activex control
1259 //---------------------------------------------------------------------------
1260 void wxActiveXContainer::OnKillFocus(wxFocusEvent& event)
1261 {
1262     if (m_oleInPlaceActiveObject.IsOk())
1263         m_oleInPlaceActiveObject->OnFrameWindowActivate(FALSE);
1264
1265     event.Skip();
1266 }
1267
1268 //---------------------------------------------------------------------------
1269 // wxActiveXContainer::MSWTranslateMessage
1270 //
1271 // Called for every message that needs to be translated.
1272 // Some controls might need more keyboard keys to process (CTRL-C, CTRL-A ect),
1273 // In that case TranslateAccelerator should always be called first.
1274 //---------------------------------------------------------------------------
1275 bool wxActiveXContainer::MSWTranslateMessage(WXMSG* pMsg)
1276 {
1277     if(m_oleInPlaceActiveObject.IsOk() && m_oleInPlaceActiveObject->TranslateAccelerator(pMsg) == S_OK)
1278     {
1279         return true;
1280     }
1281     return wxWindow::MSWTranslateMessage(pMsg);
1282 }
1283
1284 //---------------------------------------------------------------------------
1285 // wxActiveXContainer::QueryClientSiteInterface
1286 //
1287 // Called in the host's site's query method for other interfaces.
1288 //---------------------------------------------------------------------------
1289 bool wxActiveXContainer::QueryClientSiteInterface(REFIID iid, void **_interface, const char *&desc)
1290 {
1291     wxUnusedVar(iid);
1292     wxUnusedVar(_interface);
1293     wxUnusedVar(desc);
1294     return false;
1295 }
1296
1297 #endif // wxUSE_ACTIVEX