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 WX_DECLARE_AUTOOLE(wxAutoIOleInPlaceSite, IOleInPlaceSite)
  40 WX_DECLARE_AUTOOLE(wxAutoIOleDocument, IOleDocument)
  41 WX_DECLARE_AUTOOLE(wxAutoIPersistStreamInit, IPersistStreamInit)
  42 WX_DECLARE_AUTOOLE(wxAutoIAdviseSink, IAdviseSink)
  43 WX_DECLARE_AUTOOLE(wxAutoIProvideClassInfo, IProvideClassInfo)
  44 WX_DECLARE_AUTOOLE(wxAutoITypeInfo, ITypeInfo)
  45 WX_DECLARE_AUTOOLE(wxAutoIConnectionPoint, IConnectionPoint)
  46 WX_DECLARE_AUTOOLE(wxAutoIConnectionPointContainer, IConnectionPointContainer)
  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(0) {}\
  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.Ok())
 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.Ok() && 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.Ok())
 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.Ok())
 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
 637 protected:
 638     wxActiveXContainer * m_window;
 639
 640     HDC m_hDCBuffer;
 641     HWND m_hWndParent;
 642
 643     bool m_bSupportsWindowlessActivation;
 644     bool m_bInPlaceLocked;
 645     bool m_bInPlaceActive;
 646     bool m_bUIActive;
 647     bool m_bWindowless;
 648
 649     LCID m_nAmbientLocale;
 650     COLORREF m_clrAmbientForeColor;
 651     COLORREF m_clrAmbientBackColor;
 652     bool m_bAmbientShowHatching;
 653     bool m_bAmbientShowGrabHandles;
 654     bool m_bAmbientAppearance;
 655 };
 656
 657 DEFINE_OLE_TABLE(FrameSite)
 658     OLE_INTERFACE(IID_IUnknown, IOleClientSite)
 659     OLE_IINTERFACE(IOleClientSite)
 660     OLE_INTERFACE(IID_IOleWindow, IOleInPlaceSite)
 661     OLE_IINTERFACE(IOleInPlaceSite)
 662     OLE_IINTERFACE(IOleInPlaceSiteEx)
 663     OLE_IINTERFACE(IOleInPlaceUIWindow)
 664     OLE_IINTERFACE(IOleInPlaceFrame)
 665     OLE_IINTERFACE(IParseDisplayName)
 666     OLE_IINTERFACE(IOleContainer)
 667     OLE_IINTERFACE(IOleItemContainer)
 668     OLE_IINTERFACE(IDispatch)
 669     OLE_IINTERFACE(IOleCommandTarget)
 670     OLE_IINTERFACE(IOleDocumentSite)
 671     OLE_IINTERFACE(IAdviseSink)
 672     OLE_IINTERFACE(IOleControlSite)
 673 END_OLE_TABLE
 674
 675
 676 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 677 //
 678 // wxActiveXEvents
 679 //
 680 // Handles and sends activex events received from the ActiveX control
 681 // to the appropriate wxEvtHandler
 682 //
 683 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 684 class wxActiveXEvents : public IDispatch
 685 {
 686 private:
 687     DECLARE_OLE_UNKNOWN(wxActiveXEvents);
 688
 689
 690     wxActiveXContainer *m_activeX;
 691     IID m_customId;
 692     bool m_haveCustomId;
 693
 694     friend bool wxActiveXEventsInterface(wxActiveXEvents *self, REFIID iid, void **_interface, const char *&desc);
 695
 696 public:
 697     wxActiveXEvents(wxActiveXContainer *ax) : m_activeX(ax), m_haveCustomId(false) {}
 698     wxActiveXEvents(wxActiveXContainer *ax, REFIID iid) : m_activeX(ax), m_customId(iid), m_haveCustomId(true) {}
 699     virtual ~wxActiveXEvents()
 700     {
 701     }
 702
 703     // IDispatch
 704     STDMETHODIMP GetIDsOfNames(REFIID, OLECHAR**, unsigned int, LCID, DISPID*)
 705     {
 706         return E_NOTIMPL;
 707     }
 708
 709     STDMETHODIMP GetTypeInfo(unsigned int, LCID, ITypeInfo**)
 710     {
 711         return E_NOTIMPL;
 712     }
 713
 714     STDMETHODIMP GetTypeInfoCount(unsigned int*)
 715     {
 716         return E_NOTIMPL;
 717     }
 718
 719
 720     STDMETHODIMP Invoke(DISPID dispIdMember, REFIID WXUNUSED(riid),
 721                         LCID WXUNUSED(lcid),
 722                           WORD wFlags, DISPPARAMS * pDispParams,
 723                           VARIANT * WXUNUSED(pVarResult), EXCEPINFO * WXUNUSED(pExcepInfo),
 724                           unsigned int * WXUNUSED(puArgErr))
 725     {
 726         if (wFlags & (DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF))
 727             return E_NOTIMPL;
 728
 729         wxASSERT(m_activeX);
 730
 731         // ActiveX Event
 732
 733         // Dispatch Event
 734         wxActiveXEvent  event;
 735         event.SetEventType(wxEVT_ACTIVEX);
 736         event.m_params.NullList();
 737         event.m_dispid = dispIdMember;
 738
 739         // arguments
 740         if (pDispParams)
 741         {
 742             for (DWORD i = pDispParams->cArgs; i > 0; i--)
 743             {
 744                 VARIANTARG& va = pDispParams->rgvarg[i-1];
 745                 wxVariant vx;
 746
 747 //                        vx.SetName(px.name);
 748                 wxConvertOleToVariant(va, vx);
 749                 event.m_params.Append(vx);
 750             }
 751         }
 752
 753         // process the events from the activex method
 754            m_activeX->ProcessEvent(event);
 755         for (DWORD i = 0; i < pDispParams->cArgs; i++)
 756         {
 757             VARIANTARG& va = pDispParams->rgvarg[i];
 758             wxVariant& vx =
 759                 event.m_params[pDispParams->cArgs - i - 1];
 760             wxConvertVariantToOle(vx, va);
 761         }
 762
 763         if(event.GetSkipped())
 764             return DISP_E_MEMBERNOTFOUND;
 765
 766         return S_OK;
 767     }
 768 };
 769
 770 bool wxActiveXEventsInterface(wxActiveXEvents *self, REFIID iid, void **_interface, const char *&desc)
 771 {
 772     if (self->m_haveCustomId && IsEqualIID(iid, self->m_customId))
 773     {
 774 //        WXOLE_TRACE("Found Custom Dispatch Interface");
 775         *_interface = (IUnknown *) (IDispatch *) self;
 776         desc = "Custom Dispatch Interface";
 777         return true;
 778     }
 779
 780     return false;
 781 }
 782
 783 DEFINE_OLE_TABLE(wxActiveXEvents)
 784     OLE_IINTERFACE(IUnknown)
 785     OLE_INTERFACE(IID_IDispatch, IDispatch)
 786     OLE_INTERFACE_CUSTOM(wxActiveXEventsInterface)
 787 END_OLE_TABLE
 788
 789 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 790 //
 791 // wxActiveXContainer
 792 //
 793 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 794
 795 //---------------------------------------------------------------------------
 796 // wxActiveXContainer Constructor
 797 //
 798 // Initializes members and creates the native ActiveX container
 799 //---------------------------------------------------------------------------
 800 wxActiveXContainer::wxActiveXContainer(wxWindow * parent,
 801                                        REFIID iid, IUnknown* pUnk)
 802     : m_realparent(parent)
 803 {
 804     m_bAmbientUserMode = true;
 805     m_docAdviseCookie = 0;
 806     CreateActiveX(iid, pUnk);
 807 }
 808
 809 //---------------------------------------------------------------------------
 810 // wxActiveXContainer Destructor
 811 //
 812 // Destroys members (the FrameSite et al. are destroyed implicitly
 813 // through COM ref counting)
 814 //---------------------------------------------------------------------------
 815 wxActiveXContainer::~wxActiveXContainer()
 816 {
 817     // disconnect connection points
 818     if (m_oleInPlaceObject.Ok())
 819     {
 820         m_oleInPlaceObject->InPlaceDeactivate();
 821         m_oleInPlaceObject->UIDeactivate();
 822     }
 823
 824     if (m_oleObject.Ok())
 825     {
 826         if (m_docAdviseCookie != 0)
 827             m_oleObject->Unadvise(m_docAdviseCookie);
 828
 829         m_oleObject->DoVerb(
 830             OLEIVERB_HIDE, NULL, m_clientSite, 0, (HWND) GetHWND(), NULL);
 831         m_oleObject->Close(OLECLOSE_NOSAVE);
 832         m_oleObject->SetClientSite(NULL);
 833     }
 834
 835     // m_clientSite uses m_frameSite so destroy it first
 836     m_clientSite.Free();
 837     delete m_frameSite;
 838
 839     // our window doesn't belong to us, don't destroy it
 840     m_hWnd = NULL;
 841 }
 842
 843 // VZ: we might want to really report an error instead of just asserting here
 844 #ifdef __WXDEBUG__
 845     #define CHECK_HR(hr) \
 846         wxASSERT_MSG( SUCCEEDED(hr), \
 847             wxString::Format("HRESULT = %X", (unsigned)(hr)) )
 848 #else
 849     #define CHECK_HR(hr) wxUnusedVar(hr)
 850 #endif
 851
 852 //---------------------------------------------------------------------------
 853 // wxActiveXContainer::CreateActiveX
 854 //
 855 // Actually creates the ActiveX container through the FrameSite
 856 // and sets up ActiveX events
 857 //
 858 // TODO: Document this more
 859 //---------------------------------------------------------------------------
 860 void wxActiveXContainer::CreateActiveX(REFIID iid, IUnknown* pUnk)
 861 {
 862     HRESULT hret;
 863     hret = m_ActiveX.QueryInterface(iid, pUnk);
 864     CHECK_HR(hret);
 865
 866     // FrameSite
 867     m_frameSite = new FrameSite(m_realparent, this);
 868     // oleClientSite
 869     hret = m_clientSite.QueryInterface(
 870         IID_IOleClientSite, (IDispatch *) m_frameSite);
 871     CHECK_HR(hret);
 872     // adviseSink
 873     wxAutoIAdviseSink adviseSink(IID_IAdviseSink, (IDispatch *) m_frameSite);
 874     wxASSERT(adviseSink.Ok());
 875
 876     // Get Dispatch interface
 877     hret = m_Dispatch.QueryInterface(IID_IDispatch, m_ActiveX);
 878     CHECK_HR(hret);
 879
 880     //
 881     // SETUP TYPEINFO AND ACTIVEX EVENTS
 882     //
 883
 884     // get type info via class info
 885     wxAutoIProvideClassInfo classInfo(IID_IProvideClassInfo, m_ActiveX);
 886     wxASSERT(classInfo.Ok());
 887
 888     // type info
 889     wxAutoITypeInfo typeInfo;
 890     hret = classInfo->GetClassInfo(typeInfo.GetRef());
 891     CHECK_HR(hret);
 892     wxASSERT(typeInfo.Ok());
 893
 894     // TYPEATTR
 895     TYPEATTR *ta = NULL;
 896     hret = typeInfo->GetTypeAttr(&ta);
 897     CHECK_HR(hret);
 898
 899     // this should be a TKIND_COCLASS
 900     wxASSERT(ta->typekind == TKIND_COCLASS);
 901
 902     // iterate contained interfaces
 903     for (int i = 0; i < ta->cImplTypes; i++)
 904     {
 905         HREFTYPE rt = 0;
 906
 907         // get dispatch type info handle
 908         hret = typeInfo->GetRefTypeOfImplType(i, &rt);
 909         if (! SUCCEEDED(hret))
 910             continue;
 911
 912         // get dispatch type info interface
 913         wxAutoITypeInfo  ti;
 914         hret = typeInfo->GetRefTypeInfo(rt, ti.GetRef());
 915         if (! ti.Ok())
 916             continue;
 917
 918         CHECK_HR(hret);
 919
 920         // check if default event sink
 921         bool defEventSink = false;
 922         int impTypeFlags = 0;
 923         typeInfo->GetImplTypeFlags(i, &impTypeFlags);
 924
 925         if (impTypeFlags & IMPLTYPEFLAG_FDEFAULT)
 926         {
 927             if (impTypeFlags & IMPLTYPEFLAG_FSOURCE)
 928             {
 929                 // WXOLE_TRACEOUT("Default Event Sink");
 930                 defEventSink = true;
 931                 if (impTypeFlags & IMPLTYPEFLAG_FDEFAULTVTABLE)
 932                 {
 933                     // WXOLE_TRACEOUT("*ERROR* - Default Event Sink is via vTable");
 934                     defEventSink = false;
 935                     wxFAIL_MSG(wxT("Default event sink is in vtable!"));
 936                 }
 937             }
 938         }
 939
 940
 941         // wxAutoOleInterface<> assumes a ref has already been added
 942         // TYPEATTR
 943         TYPEATTR *ta = NULL;
 944         hret = ti->GetTypeAttr(&ta);
 945         CHECK_HR(hret);
 946
 947         if (ta->typekind == TKIND_DISPATCH)
 948         {
 949             // WXOLE_TRACEOUT("GUID = " << GetIIDName(ta->guid).c_str());
 950             if (defEventSink)
 951             {
 952                 wxAutoIConnectionPoint    cp;
 953                 DWORD                    adviseCookie = 0;
 954
 955                 wxAutoIConnectionPointContainer cpContainer(IID_IConnectionPointContainer, m_ActiveX);
 956                 wxASSERT( cpContainer.Ok());
 957
 958                 HRESULT hret =
 959                     cpContainer->FindConnectionPoint(ta->guid, cp.GetRef());
 960                 CHECK_HR(hret);
 961
 962                 IDispatch* disp;
 963                 m_frameSite->QueryInterface(IID_IDispatch, (void**)&disp);
 964                 hret = cp->Advise(new wxActiveXEvents(this, ta->guid),
 965                                   &adviseCookie);
 966                 CHECK_HR(hret);
 967             }
 968         }
 969
 970         ti->ReleaseTypeAttr(ta);
 971     }
 972
 973     // free
 974     typeInfo->ReleaseTypeAttr(ta);
 975
 976     //
 977     // END
 978     //
 979
 980     // Get IOleObject interface
 981     hret = m_oleObject.QueryInterface(IID_IOleObject, m_ActiveX);
 982     CHECK_HR(hret);
 983
 984     // get IViewObject Interface
 985     hret = m_viewObject.QueryInterface(IID_IViewObject, m_ActiveX);
 986     CHECK_HR(hret);
 987
 988     // document advise
 989     m_docAdviseCookie = 0;
 990     hret = m_oleObject->Advise(adviseSink, &m_docAdviseCookie);
 991     CHECK_HR(hret);
 992
 993     // TODO:Needed?
 994 //    hret = m_viewObject->SetAdvise(DVASPECT_CONTENT, 0, adviseSink);
 995     m_oleObject->SetHostNames(L"wxActiveXContainer", NULL);
 996     OleSetContainedObject(m_oleObject, TRUE);
 997     OleRun(m_oleObject);
 998
 999
1000     // Get IOleInPlaceObject interface
1001     hret = m_oleInPlaceObject.QueryInterface(
1002         IID_IOleInPlaceObject, m_ActiveX);
1003     CHECK_HR(hret);
1004
1005     // status
1006     DWORD dwMiscStatus;
1007     m_oleObject->GetMiscStatus(DVASPECT_CONTENT, &dwMiscStatus);
1008     CHECK_HR(hret);
1009
1010     // set client site first ?
1011     if (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST)
1012         m_oleObject->SetClientSite(m_clientSite);
1013
1014
1015     // stream init
1016     wxAutoIPersistStreamInit
1017         pPersistStreamInit(IID_IPersistStreamInit, m_oleObject);
1018
1019     if (pPersistStreamInit.Ok())
1020     {
1021         hret = pPersistStreamInit->InitNew();
1022         CHECK_HR(hret);
1023     }
1024
1025     if (! (dwMiscStatus & OLEMISC_SETCLIENTSITEFIRST))
1026         m_oleObject->SetClientSite(m_clientSite);
1027
1028
1029     m_oleObjectHWND = 0;
1030
1031     if (m_oleInPlaceObject.Ok())
1032     {
1033         hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
1034         if (SUCCEEDED(hret))
1035             ::SetActiveWindow(m_oleObjectHWND);
1036     }
1037
1038
1039     if (! (dwMiscStatus & OLEMISC_INVISIBLEATRUNTIME))
1040     {
1041         RECT posRect;
1042         wxCopyRectToRECT(m_realparent->GetClientSize(), posRect);
1043
1044         if (posRect.right > 0 && posRect.bottom > 0 &&
1045             m_oleInPlaceObject.Ok())
1046         {
1047             m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
1048         }
1049
1050         hret = m_oleObject->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL,
1051             m_clientSite, 0, (HWND)m_realparent->GetHWND(), &posRect);
1052         CHECK_HR(hret);
1053
1054         hret = m_oleObject->DoVerb(OLEIVERB_SHOW, 0, m_clientSite, 0,
1055             (HWND)m_realparent->GetHWND(), &posRect);
1056         CHECK_HR(hret);
1057     }
1058
1059     if (! m_oleObjectHWND && m_oleInPlaceObject.Ok())
1060     {
1061         hret = m_oleInPlaceObject->GetWindow(&m_oleObjectHWND);
1062         CHECK_HR(hret);
1063     }
1064
1065     if (m_oleObjectHWND)
1066     {
1067         ::SetActiveWindow(m_oleObjectHWND);
1068         ::ShowWindow(m_oleObjectHWND, SW_SHOW);
1069
1070         this->AssociateHandle(m_oleObjectHWND);
1071         this->Reparent(m_realparent);
1072
1073         wxWindow* pWnd = m_realparent;
1074         int id = m_realparent->GetId();
1075
1076         pWnd->Connect(id, wxEVT_SIZE,
1077             wxSizeEventHandler(wxActiveXContainer::OnSize), 0, this);
1078 //        this->Connect(GetId(), wxEVT_PAINT,
1079 //            wxPaintEventHandler(wxActiveXContainer::OnPaint), 0, this);
1080         pWnd->Connect(id, wxEVT_SET_FOCUS,
1081             wxFocusEventHandler(wxActiveXContainer::OnSetFocus), 0, this);
1082         pWnd->Connect(id, wxEVT_KILL_FOCUS,
1083             wxFocusEventHandler(wxActiveXContainer::OnKillFocus), 0, this);
1084     }
1085 }
1086
1087 //---------------------------------------------------------------------------
1088 // wxActiveXContainer::OnSize
1089 //
1090 // Called when the parent is resized - we need to do this to actually
1091 // move the ActiveX control to where the parent is
1092 //---------------------------------------------------------------------------
1093 void wxActiveXContainer::OnSize(wxSizeEvent& event)
1094 {
1095     int w, h;
1096     GetParent()->GetClientSize(&w, &h);
1097
1098     RECT posRect;
1099     posRect.left = 0;
1100     posRect.top = 0;
1101     posRect.right = w;
1102     posRect.bottom = h;
1103
1104     if (w <= 0 && h <= 0)
1105         return;
1106
1107     // extents are in HIMETRIC units
1108     if (m_oleObject.Ok())
1109     {
1110         m_oleObject->DoVerb(OLEIVERB_HIDE, 0, m_clientSite, 0,
1111             (HWND)m_realparent->GetHWND(), &posRect);
1112
1113         SIZEL sz = {w, h};
1114         PixelsToHimetric(sz);
1115
1116         SIZEL sz2;
1117
1118         m_oleObject->GetExtent(DVASPECT_CONTENT, &sz2);
1119         if (sz2.cx !=  sz.cx || sz.cy != sz2.cy)
1120             m_oleObject->SetExtent(DVASPECT_CONTENT, &sz);
1121
1122         m_oleObject->DoVerb(OLEIVERB_SHOW, 0, m_clientSite, 0,
1123             (HWND)m_realparent->GetHWND(), &posRect);
1124     }
1125
1126     if (m_oleInPlaceObject.Ok())
1127         m_oleInPlaceObject->SetObjectRects(&posRect, &posRect);
1128
1129     event.Skip();
1130 }
1131
1132 //---------------------------------------------------------------------------
1133 // wxActiveXContainer::OnPaint
1134 //
1135 // Called when the parent is resized - repaints the ActiveX control
1136 //---------------------------------------------------------------------------
1137 void wxActiveXContainer::OnPaint(wxPaintEvent& WXUNUSED(event))
1138 {
1139     wxPaintDC dc(this);
1140     // Draw only when control is windowless or deactivated
1141     if (m_viewObject)
1142     {
1143         int w, h;
1144         GetParent()->GetSize(&w, &h);
1145         RECT posRect;
1146         posRect.left = 0;
1147         posRect.top = 0;
1148         posRect.right = w;
1149         posRect.bottom = h;
1150
1151 #if !(defined(_WIN32_WCE) && _WIN32_WCE < 400)
1152         ::RedrawWindow(m_oleObjectHWND, NULL, NULL, RDW_INTERNALPAINT);
1153 #else
1154         ::InvalidateRect(m_oleObjectHWND, NULL, false);
1155 #endif
1156         RECTL *prcBounds = (RECTL *) &posRect;
1157         wxMSWDCImpl *msw = wxDynamicCast( dc.GetImpl() , wxMSWDCImpl );
1158         m_viewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, NULL,
1159             (HDC)msw->GetHDC(), prcBounds, NULL, NULL, 0);
1160     }
1161 }
1162
1163 //---------------------------------------------------------------------------
1164 // wxActiveXContainer::OnSetFocus
1165 //
1166 // Called when the focus is set on the parent - activates the activex control
1167 //---------------------------------------------------------------------------
1168 void wxActiveXContainer::OnSetFocus(wxFocusEvent& event)
1169 {
1170     if (m_oleInPlaceActiveObject.Ok())
1171         m_oleInPlaceActiveObject->OnFrameWindowActivate(TRUE);
1172
1173     event.Skip();
1174 }
1175
1176 //---------------------------------------------------------------------------
1177 // wxActiveXContainer::OnKillFocus
1178 //
1179 // Called when the focus is killed on the parent -
1180 // deactivates the activex control
1181 //---------------------------------------------------------------------------
1182 void wxActiveXContainer::OnKillFocus(wxFocusEvent& event)
1183 {
1184     if (m_oleInPlaceActiveObject.Ok())
1185         m_oleInPlaceActiveObject->OnFrameWindowActivate(FALSE);
1186
1187     event.Skip();
1188 }
1189
1190 #endif // wxUSE_ACTIVEX