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