1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the ActiveQt framework of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:BSD$

    10 ** You may use this file under the terms of the BSD license as follows:

    11 **

    12 ** "Redistribution and use in source and binary forms, with or without

    13 ** modification, are permitted provided that the following conditions are

    14 ** met:

    15 **   * Redistributions of source code must retain the above copyright

    16 **     notice, this list of conditions and the following disclaimer.

    17 **   * Redistributions in binary form must reproduce the above copyright

    18 **     notice, this list of conditions and the following disclaimer in

    19 **     the documentation and/or other materials provided with the

    20 **     distribution.

    21 **   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor

    22 **     the names of its contributors may be used to endorse or promote

    23 **     products derived from this software without specific prior written

    24 **     permission.

    25 **

    26 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    27 ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

    28 ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

    29 ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

    30 ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

    31 ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

    32 ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

    33 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

    34 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    35 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    36 ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."

    37 ** $QT_END_LICENSE$

    38 **

    39 ****************************************************************************/

    40 

    41 #define QT_NO_CAST_TO_ASCII

    42 

    43 #ifndef QT_NO_WIN_ACTIVEQT

    44 

    45 #include <qabstracteventdispatcher.h>

    46 #include <qapplication.h>

    47 #include <qbuffer.h>

    48 #include <qdatastream.h>

    49 #include <qdebug.h>

    50 #include <qevent.h>

    51 #include <qeventloop.h>

    52 #include <qfile.h>

    53 #include <qpointer.h>

    54 #include <qhash.h>

    55 #include <qmap.h>

    56 #include <qmenubar.h>

    57 #include <qmenu.h>

    58 #include <qmetaobject.h>

    59 #include <qpixmap.h>

    60 #include <qstatusbar.h>

    61 #include <qwhatsthis.h>

    62 #include <ocidl.h>

    63 #include <olectl.h>

    64 #include <private/qcoreapplication_p.h>

    65 

    66 #include "qaxfactory.h"

    67 #include "qaxbindable.h"

    68 #include "qaxaggregated.h"

    69 

    70 #include "../shared/qaxtypes.h"

    71 

    72 #if defined Q_CC_GNU

    73 #   include <w32api.h>

    74 #endif

    75 

    76 #ifndef Q_OS_WIN64

    77 #define ULONG_PTR DWORD

    78 #endif

    79 

    80 QT_BEGIN_NAMESPACE

    81 

    82 extern HHOOK qax_hhook;

    83 

    84 // in qaxserver.cpp

    85 extern ITypeLib *qAxTypeLibrary;

    86 extern QAxFactory *qAxFactory();

    87 extern unsigned long qAxLock();

    88 extern unsigned long qAxUnlock();

    89 extern HANDLE qAxInstance;

    90 extern bool qAxOutProcServer;

    91 

    92 static int invokeCount = 0;

    93 

    94 #ifdef QT_DEBUG

    95 unsigned long qaxserverbase_instance_count = 0;

    96 #endif

    97 

    98 // in qaxserverdll.cpp

    99 extern bool qax_ownQApp;

   100 

   101 struct QAxExceptInfo

   102 {

   103     QAxExceptInfo(int c, const QString &s, const QString &d, const QString &x)

   104 	: code(c), src(s), desc(d), context(x)

   105     {

   106     }

   107     int code;

   108     QString src;

   109     QString desc;

   110     QString context;

   111 };

   112 

   113 

   114 bool qt_sendSpontaneousEvent(QObject*, QEvent*);

   115 

   116 /*

   117     \class QAxServerBase

   118     \brief The QAxServerBase class is an ActiveX control hosting a QWidget.

   119 

   120     \internal

   121 */

   122 class QAxServerBase :

   123     public QObject,

   124     public IAxServerBase,

   125     public IDispatch,

   126     public IOleObject,

   127     public IOleControl,

   128 #if defined Q_CC_GNU

   129 #   if (__W32API_MAJOR_VERSION < 2 || (__W32API_MAJOR_VERSION == 2 && __W32API_MINOR_VERSION < 5))

   130     public IViewObject, // this should not be needed as IViewObject2 is meant to inherit from this,

   131                         // untill the mingw headers are fixed this will need to stay.

   132 #   endif

   133 #endif

   134     public IViewObject2,

   135     public IOleInPlaceObject,

   136     public IOleInPlaceActiveObject,

   137     public IProvideClassInfo2,

   138     public IConnectionPointContainer,

   139     public IPersistStream,

   140     public IPersistStreamInit,

   141     public IPersistStorage,

   142     public IPersistPropertyBag,

   143     public IPersistFile,

   144     public IDataObject

   145 {

   146 public:

   147     typedef QMap<QUuid,IConnectionPoint*> ConnectionPoints;

   148     typedef QMap<QUuid,IConnectionPoint*>::Iterator ConnectionPointsIterator;

   149 

   150     QAxServerBase(const QString &classname, IUnknown *outerUnknown);

   151     QAxServerBase(QObject *o);

   152 

   153     void init();

   154 

   155     ~QAxServerBase();

   156 

   157 // Window creation

   158     HWND create(HWND hWndParent, RECT& rcPos);

   159     HMENU createPopup(QMenu *popup, HMENU oldMenu = 0);

   160     void createMenu(QMenuBar *menuBar);

   161     void removeMenu();

   162 

   163     static LRESULT CALLBACK ActiveXProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

   164 

   165 // Object registration with OLE

   166     void registerActiveObject(IUnknown *object);

   167     void revokeActiveObject();

   168 

   169 // IUnknown

   170     unsigned long WINAPI AddRef()

   171     {

   172 	if (m_outerUnknown)

   173 	    return m_outerUnknown->AddRef();

   174 

   175 	EnterCriticalSection(&refCountSection);

   176 	unsigned long r = ++ref;

   177 	LeaveCriticalSection(&refCountSection);

   178 

   179 	return r;

   180     }

   181     unsigned long WINAPI Release()

   182     {

   183     	if (m_outerUnknown)

   184 	    return m_outerUnknown->Release();

   185 

   186 	EnterCriticalSection(&refCountSection);

   187 	unsigned long r = --ref;

   188 	LeaveCriticalSection(&refCountSection);

   189 

   190 	if (!r) {

   191 	    delete this;

   192 	    return 0;

   193 	}

   194 	return r;

   195     }

   196     HRESULT WINAPI QueryInterface(REFIID iid, void **iface);

   197     HRESULT InternalQueryInterface(REFIID iid, void **iface);

   198 

   199 // IAxServerBase

   200     IUnknown *clientSite() const

   201     {

   202 	return m_spClientSite;

   203     }

   204 

   205     void emitPropertyChanged(const char*);

   206     bool emitRequestPropertyChange(const char*);

   207     QObject *qObject() const

   208     {

   209 	return theObject;

   210     }

   211     void ensureMetaData();

   212     bool isPropertyExposed(int index);

   213 

   214     void reportError(int code, const QString &src, const QString &desc, const QString &context)

   215     {

   216         if (exception)

   217             delete exception;

   218         exception = new QAxExceptInfo(code, src, desc, context);

   219     }

   220 

   221 // IDispatch

   222     STDMETHOD(GetTypeInfoCount)(UINT* pctinfo);

   223     STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo** pptinfo);

   224     STDMETHOD(GetIDsOfNames)(REFIID riid, LPOLESTR* rgszNames, UINT cNames, LCID lcid, DISPID* rgdispid);

   225     STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid,

   226 		LCID lcid, WORD wFlags, DISPPARAMS* pdispparams, VARIANT* pvarResult,

   227 		EXCEPINFO* pexcepinfo, UINT* puArgErr);

   228 

   229 // IProvideClassInfo

   230     STDMETHOD(GetClassInfo)(ITypeInfo** pptinfo);

   231 

   232 // IProvideClassInfo2

   233     STDMETHOD(GetGUID)(DWORD dwGuidKind, GUID* pGUID);

   234 

   235 // IOleObject

   236     STDMETHOD(Advise)(IAdviseSink* pAdvSink, DWORD* pdwConnection);

   237     STDMETHOD(Close)(DWORD dwSaveOption);

   238     STDMETHOD(DoVerb)(LONG iVerb, LPMSG lpmsg, IOleClientSite* pActiveSite, LONG lindex, HWND hwndParent, LPCRECT lprcPosRect);

   239     STDMETHOD(EnumAdvise)(IEnumSTATDATA** ppenumAdvise);

   240     STDMETHOD(EnumVerbs)(IEnumOLEVERB** ppEnumOleVerb);

   241     STDMETHOD(GetClientSite)(IOleClientSite** ppClientSite);

   242     STDMETHOD(GetClipboardData)(DWORD dwReserved, IDataObject** ppDataObject);

   243     STDMETHOD(GetExtent)(DWORD dwDrawAspect, SIZEL* psizel);

   244     STDMETHOD(GetMiscStatus)(DWORD dwAspect, DWORD *pdwStatus);

   245     STDMETHOD(GetMoniker)(DWORD dwAssign, DWORD dwWhichMoniker, IMoniker** ppmk);

   246     STDMETHOD(GetUserClassID)(CLSID* pClsid);

   247     STDMETHOD(GetUserType)(DWORD dwFormOfType, LPOLESTR *pszUserType);

   248     STDMETHOD(InitFromData)(IDataObject* pDataObject, BOOL fCreation, DWORD dwReserved);

   249     STDMETHOD(IsUpToDate)();

   250     STDMETHOD(SetClientSite)(IOleClientSite* pClientSite);

   251     STDMETHOD(SetColorScheme)(LOGPALETTE* pLogPal);

   252     STDMETHOD(SetExtent)(DWORD dwDrawAspect, SIZEL* psizel);

   253     STDMETHOD(SetHostNames)(LPCOLESTR szContainerApp, LPCOLESTR szContainerObj);

   254     STDMETHOD(SetMoniker)(DWORD dwWhichMoniker, IMoniker* ppmk);

   255     STDMETHOD(Unadvise)(DWORD dwConnection);

   256     STDMETHOD(Update)();

   257 

   258 // IViewObject

   259     STDMETHOD(Draw)(DWORD dwAspect, LONG lIndex, void *pvAspect, DVTARGETDEVICE *ptd,

   260 		    HDC hicTargetDevice, HDC hdcDraw, LPCRECTL lprcBounds, LPCRECTL lprcWBounds,

   261 		    BOOL(__stdcall*pfnContinue)(ULONG_PTR), ULONG_PTR dwContinue);

   262     STDMETHOD(GetColorSet)(DWORD dwDrawAspect, LONG lindex, void *pvAspect, DVTARGETDEVICE *ptd,

   263 		    HDC hicTargetDev, LOGPALETTE **ppColorSet);

   264     STDMETHOD(Freeze)(DWORD dwAspect, LONG lindex, void *pvAspect, DWORD *pdwFreeze);

   265     STDMETHOD(Unfreeze)(DWORD dwFreeze);

   266     STDMETHOD(SetAdvise)(DWORD aspects, DWORD advf, IAdviseSink *pAdvSink);

   267     STDMETHOD(GetAdvise)(DWORD *aspects, DWORD *advf, IAdviseSink **pAdvSink);

   268 

   269 // IViewObject2

   270     STDMETHOD(GetExtent)(DWORD dwAspect, LONG lindex, DVTARGETDEVICE *ptd, LPSIZEL lpsizel);

   271 

   272 // IOleControl

   273     STDMETHOD(FreezeEvents)(BOOL);

   274     STDMETHOD(GetControlInfo)(LPCONTROLINFO);

   275     STDMETHOD(OnAmbientPropertyChange)(DISPID);

   276     STDMETHOD(OnMnemonic)(LPMSG);

   277 

   278 // IOleWindow

   279     STDMETHOD(GetWindow)(HWND *pHwnd);

   280     STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode);

   281 

   282 // IOleInPlaceObject

   283     STDMETHOD(InPlaceDeactivate)();

   284     STDMETHOD(UIDeactivate)();

   285     STDMETHOD(SetObjectRects)(LPCRECT lprcPosRect, LPCRECT lprcClipRect);

   286     STDMETHOD(ReactivateAndUndo)();

   287 

   288 // IOleInPlaceActiveObject

   289     STDMETHOD(TranslateAcceleratorW)(MSG *pMsg);

   290     STDMETHOD(TranslateAcceleratorA)(MSG *pMsg);

   291     STDMETHOD(OnFrameWindowActivate)(BOOL);

   292     STDMETHOD(OnDocWindowActivate)(BOOL fActivate);

   293     STDMETHOD(ResizeBorder)(LPCRECT prcBorder, IOleInPlaceUIWindow *pUIWindow, BOOL fFrameWindow);

   294     STDMETHOD(EnableModeless)(BOOL);

   295 

   296 // IConnectionPointContainer

   297     STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints**);

   298     STDMETHOD(FindConnectionPoint)(REFIID, IConnectionPoint**);

   299 

   300 // IPersist

   301     STDMETHOD(GetClassID)(GUID*clsid)

   302     {

   303 	*clsid = qAxFactory()->classID(class_name);

   304 	return S_OK;

   305     }

   306 

   307 // IPersistStreamInit

   308     STDMETHOD(InitNew)(VOID);

   309     STDMETHOD(IsDirty)();

   310     STDMETHOD(Load)(IStream *pStm);

   311     STDMETHOD(Save)(IStream *pStm, BOOL fClearDirty);

   312     STDMETHOD(GetSizeMax)(ULARGE_INTEGER *pcbSize);

   313 

   314 // IPersistPropertyBag

   315     STDMETHOD(Load)(IPropertyBag *, IErrorLog *);

   316     STDMETHOD(Save)(IPropertyBag *, BOOL, BOOL);

   317 

   318 // IPersistStorage

   319     STDMETHOD(InitNew)(IStorage *pStg);

   320     STDMETHOD(Load)(IStorage *pStg);

   321     STDMETHOD(Save)(IStorage *pStg, BOOL fSameAsLoad);

   322     STDMETHOD(SaveCompleted)(IStorage *pStgNew);

   323     STDMETHOD(HandsOffStorage)();

   324 

   325 // IPersistFile

   326     STDMETHOD(SaveCompleted)(LPCOLESTR fileName);

   327     STDMETHOD(GetCurFile)(LPOLESTR *currentFile);

   328     STDMETHOD(Load)(LPCOLESTR fileName, DWORD mode);

   329     STDMETHOD(Save)(LPCOLESTR fileName, BOOL fRemember);

   330 

   331 // IDataObject

   332     STDMETHOD(GetData)(FORMATETC *pformatetcIn, STGMEDIUM *pmedium);

   333     STDMETHOD(GetDataHere)(FORMATETC* /* pformatetc */, STGMEDIUM* /* pmedium */);

   334     STDMETHOD(QueryGetData)(FORMATETC* /* pformatetc */);

   335     STDMETHOD(GetCanonicalFormatEtc)(FORMATETC* /* pformatectIn */,FORMATETC* /* pformatetcOut */);

   336     STDMETHOD(SetData)(FORMATETC* /* pformatetc */, STGMEDIUM* /* pmedium */, BOOL /* fRelease */);

   337     STDMETHOD(EnumFormatEtc)(DWORD /* dwDirection */, IEnumFORMATETC** /* ppenumFormatEtc */);

   338     STDMETHOD(DAdvise)(FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection);

   339     STDMETHOD(DUnadvise)(DWORD dwConnection);

   340     STDMETHOD(EnumDAdvise)(IEnumSTATDATA **ppenumAdvise);

   341 

   342 // QObject

   343     int qt_metacall(QMetaObject::Call, int index, void **argv);

   344 

   345     bool eventFilter(QObject *o, QEvent *e);

   346 private:

   347     void update();

   348     void resize(const QSize &newSize);

   349     void updateGeometry();

   350     void updateMask();

   351     bool internalCreate();

   352     void internalBind();

   353     void internalConnect();

   354     HRESULT internalActivate();

   355 

   356     friend class QAxBindable;

   357     friend class QAxPropertyPage;

   358 

   359     QAxAggregated *aggregatedObject;

   360     ConnectionPoints points;

   361 

   362     union {

   363 	QWidget *widget;

   364 	QObject *object;

   365     } qt;

   366     QPointer<QObject> theObject;

   367     unsigned isWidget		:1;

   368     unsigned ownObject		:1;

   369     unsigned initNewCalled	:1;

   370     unsigned dirtyflag		:1;

   371     unsigned hasStockEvents	:1;

   372     unsigned stayTopLevel	:1;

   373     unsigned isInPlaceActive	:1;

   374     unsigned isUIActive		:1;

   375     unsigned wasUIActive	:1;

   376     unsigned inDesignMode	:1;

   377     unsigned canTakeFocus	:1;

   378     short freezeEvents;

   379 

   380     HWND m_hWnd;

   381 

   382     HMENU hmenuShared;

   383     HOLEMENU holemenu;

   384     HWND hwndMenuOwner;

   385     QMap<HMENU, QMenu*> menuMap;

   386     QMap<UINT, QAction*> actionMap;

   387     QPointer<QMenuBar> menuBar;

   388     QPointer<QStatusBar> statusBar;

   389     QPointer<QMenu> currentPopup;

   390     QAxExceptInfo *exception;

   391 

   392     CRITICAL_SECTION refCountSection;

   393     CRITICAL_SECTION createWindowSection;

   394 

   395     unsigned long ref;

   396     unsigned long ole_ref;

   397 

   398     QString class_name;

   399     QString currentFileName;

   400 

   401     QHash<long, int> indexCache;

   402     QHash<int,DISPID> signalCache;

   403 

   404     IUnknown *m_outerUnknown;

   405     IAdviseSink *m_spAdviseSink;

   406     QList<STATDATA> adviseSinks;

   407     IOleClientSite *m_spClientSite;

   408     IOleInPlaceSiteWindowless *m_spInPlaceSite;

   409     IOleInPlaceFrame *m_spInPlaceFrame;

   410     ITypeInfo *m_spTypeInfo;

   411     IStorage *m_spStorage;

   412     QSize m_currentExtent;

   413 };

   414 

   415 class QAxServerAggregate : public IUnknown

   416 {

   417 public:

   418     QAxServerAggregate(const QString &className, IUnknown *outerUnknown)

   419 	: m_outerUnknown(outerUnknown), ref(0)

   420     {

   421 	object = new QAxServerBase(className, outerUnknown);

   422 	object->registerActiveObject(this);

   423 

   424 	InitializeCriticalSection(&refCountSection);

   425 	InitializeCriticalSection(&createWindowSection);

   426     }

   427     ~QAxServerAggregate()

   428     {

   429 	DeleteCriticalSection(&refCountSection);

   430 	DeleteCriticalSection(&createWindowSection);

   431 

   432 	delete object;

   433     }

   434 

   435 // IUnknown

   436     unsigned long WINAPI AddRef()

   437     {

   438 	EnterCriticalSection(&refCountSection);

   439 	unsigned long r = ++ref;

   440 	LeaveCriticalSection(&refCountSection);

   441 

   442 	return r;

   443     }

   444     unsigned long WINAPI Release()

   445     {

   446 	EnterCriticalSection(&refCountSection);

   447 	unsigned long r = --ref;

   448 	LeaveCriticalSection(&refCountSection);

   449 

   450 	if (!r) {

   451 	    delete this;

   452 	    return 0;

   453 	}

   454 	return r;

   455     }

   456     HRESULT WINAPI QueryInterface(REFIID iid, void **iface)

   457     {

   458 	*iface = 0;

   459 

   460 	HRESULT res = E_NOINTERFACE;

   461 	if (iid == IID_IUnknown) {

   462 	    *iface = (IUnknown*)this;

   463 	    AddRef();

   464 	    return S_OK;

   465 	}

   466 	return object->InternalQueryInterface(iid, iface);

   467     }

   468 

   469 private:

   470     QAxServerBase *object;

   471     IUnknown *m_outerUnknown;

   472     unsigned long ref;

   473 

   474     CRITICAL_SECTION refCountSection;

   475     CRITICAL_SECTION createWindowSection;

   476 };

   477 

   478 bool QAxFactory::createObjectWrapper(QObject *object, IDispatch **wrapper)

   479 {

   480     *wrapper = 0;

   481     QAxServerBase *obj = new QAxServerBase(object);

   482     obj->QueryInterface(IID_IDispatch, (void**)wrapper);

   483     if (*wrapper)

   484 	return true;

   485 

   486     delete obj;

   487     return false;

   488 }

   489 

   490 

   491 /*

   492     Helper class to enumerate all supported event interfaces.

   493 */

   494 class QAxSignalVec : public IEnumConnectionPoints

   495 {

   496 public:

   497     QAxSignalVec(const QAxServerBase::ConnectionPoints &points)

   498 	: cpoints(points), ref(0)

   499     {

   500 	InitializeCriticalSection(&refCountSection);

   501 	for (QAxServerBase::ConnectionPointsIterator i = cpoints.begin(); i != cpoints.end(); ++i)

   502 	    (*i)->AddRef();

   503     }

   504     QAxSignalVec(const QAxSignalVec &old)

   505     {

   506 	InitializeCriticalSection(&refCountSection);

   507 	ref = 0;

   508 	cpoints = old.cpoints;

   509 	for (QAxServerBase::ConnectionPointsIterator i = cpoints.begin(); i != cpoints.end(); ++i)

   510 	    (*i)->AddRef();

   511 	it = old.it;

   512     }

   513     ~QAxSignalVec()

   514     {

   515 	for (QAxServerBase::ConnectionPointsIterator i = cpoints.begin(); i != cpoints.end(); ++i)

   516 	    (*i)->Release();

   517 

   518 	DeleteCriticalSection(&refCountSection);

   519     }

   520 

   521     unsigned long __stdcall AddRef()

   522     {

   523 	EnterCriticalSection(&refCountSection);

   524 	unsigned long r = ++ref;

   525 	LeaveCriticalSection(&refCountSection);

   526 	return ++r;

   527     }

   528     unsigned long __stdcall Release()

   529     {

   530 	EnterCriticalSection(&refCountSection);

   531 	unsigned long r = --ref;

   532 	LeaveCriticalSection(&refCountSection);

   533 

   534 	if (!r) {

   535 	    delete this;

   536 	    return 0;

   537 	}

   538 	return r;

   539     }

   540     STDMETHOD(QueryInterface)(REFIID iid, void **iface)

   541     {

   542 	*iface = 0;

   543 	if (iid == IID_IUnknown)

   544 	    *iface = this;

   545 	else if (iid == IID_IEnumConnectionPoints)

   546 	    *iface = this;

   547 	else

   548 	    return E_NOINTERFACE;

   549 

   550 	AddRef();

   551 	return S_OK;

   552     }

   553     STDMETHOD(Next)(ULONG cConnections, IConnectionPoint **cpoint, ULONG *pcFetched)

   554     {

   555 	unsigned long i;

   556 	for (i = 0; i < cConnections; i++) {

   557 	    if (it == cpoints.end())

   558 		break;

   559 	    IConnectionPoint *cp = *it;

   560 	    cp->AddRef();

   561 	    cpoint[i] = cp;

   562 	    ++it;

   563 	}

   564 	*pcFetched = i;

   565 	return i == cConnections ? S_OK : S_FALSE;

   566     }

   567     STDMETHOD(Skip)(ULONG cConnections)

   568     {

   569 	while (cConnections) {

   570 	    ++it;

   571 	    --cConnections;

   572 	    if (it == cpoints.end())

   573 		return S_FALSE;

   574 	}

   575 	return S_OK;

   576     }

   577     STDMETHOD(Reset)()

   578     {

   579 	it = cpoints.begin();

   580 

   581 	return S_OK;

   582     }

   583     STDMETHOD(Clone)(IEnumConnectionPoints **ppEnum)

   584     {

   585 	*ppEnum = new QAxSignalVec(*this);

   586 	(*ppEnum)->AddRef();

   587 

   588 	return S_OK;

   589     }

   590 

   591     QAxServerBase::ConnectionPoints cpoints;

   592     QAxServerBase::ConnectionPointsIterator it;

   593 

   594 private:

   595     CRITICAL_SECTION refCountSection;

   596 

   597     unsigned long ref;

   598 };

   599 

   600 /*

   601     Helper class to store and enumerate all connected event listeners.

   602 */

   603 class QAxConnection : public IConnectionPoint,

   604 		      public IEnumConnections

   605 {

   606 public:

   607     typedef QList<CONNECTDATA> Connections;

   608     typedef QList<CONNECTDATA>::Iterator Iterator;

   609 

   610     QAxConnection(QAxServerBase *parent, const QUuid &uuid)

   611 	: that(parent), iid(uuid), ref(1)

   612     {

   613 	InitializeCriticalSection(&refCountSection);

   614     }

   615     QAxConnection(const QAxConnection &old)

   616     {

   617 	InitializeCriticalSection(&refCountSection);

   618 	ref = 0;

   619 	connections = old.connections;

   620 	it = old.it;

   621 	that = old.that;

   622 	iid = old.iid;

   623 	QList<CONNECTDATA>::Iterator it = connections.begin();

   624 	while (it != connections.end()) {

   625 	    CONNECTDATA connection = *it;

   626 	    ++it;

   627 	    connection.pUnk->AddRef();

   628 	}

   629     }

   630     ~QAxConnection()

   631     {

   632 	DeleteCriticalSection(&refCountSection);

   633     }

   634 

   635     unsigned long __stdcall AddRef()

   636     {

   637 	EnterCriticalSection(&refCountSection);

   638 	unsigned long r = ++ref;

   639 	LeaveCriticalSection(&refCountSection);

   640 	return r;

   641     }

   642     unsigned long __stdcall Release()

   643     {

   644 	EnterCriticalSection(&refCountSection);

   645 	unsigned long r = --ref;

   646 	LeaveCriticalSection(&refCountSection);

   647 

   648 	if (!r) {

   649 	    delete this;

   650 	    return 0;

   651 	}

   652 	return r;

   653     }

   654     STDMETHOD(QueryInterface)(REFIID iid, void **iface)

   655     {

   656 	*iface = 0;

   657 	if (iid == IID_IUnknown)

   658 	    *iface = (IConnectionPoint*)this;

   659 	else if (iid == IID_IConnectionPoint)

   660 	    *iface = this;

   661 	else if (iid == IID_IEnumConnections)

   662 	    *iface = this;

   663 	else

   664 	    return E_NOINTERFACE;

   665 

   666 	AddRef();

   667 	return S_OK;

   668     }

   669     STDMETHOD(GetConnectionInterface)(IID *pIID)

   670     {

   671 	*pIID = iid;

   672 	return S_OK;

   673     }

   674     STDMETHOD(GetConnectionPointContainer)(IConnectionPointContainer **ppCPC)

   675     {

   676 	return that->QueryInterface(IID_IConnectionPointContainer, (void**)ppCPC);

   677     }

   678     STDMETHOD(Advise)(IUnknown*pUnk, DWORD *pdwCookie)

   679     {

   680 	{

   681 	    IDispatch *checkImpl = 0;

   682 	    pUnk->QueryInterface(iid, (void**)&checkImpl);

   683 	    if (!checkImpl)

   684 		return CONNECT_E_CANNOTCONNECT;

   685 	    checkImpl->Release();

   686 	}

   687 

   688 	CONNECTDATA cd;

   689 	cd.dwCookie = connections.count()+1;

   690 	cd.pUnk = pUnk;

   691 	cd.pUnk->AddRef();

   692 	connections.append(cd);

   693 

   694 	*pdwCookie = cd.dwCookie;

   695 	return S_OK;

   696     }

   697     STDMETHOD(Unadvise)(DWORD dwCookie)

   698     {

   699 	QList<CONNECTDATA>::Iterator it = connections.begin();

   700 	while (it != connections.end()) {

   701 	    CONNECTDATA cd = *it;

   702 	    if (cd.dwCookie == dwCookie) {

   703 		cd.pUnk->Release();

   704 		connections.erase(it);

   705 		return S_OK;

   706 	    }

   707 	    ++it;

   708 	}

   709 	return CONNECT_E_NOCONNECTION;

   710     }

   711     STDMETHOD(EnumConnections)(IEnumConnections **ppEnum)

   712     {

   713 	*ppEnum = this;

   714 	AddRef();

   715 

   716 	return S_OK;

   717     }

   718     STDMETHOD(Next)(ULONG cConnections, CONNECTDATA *cd, ULONG *pcFetched)

   719     {

   720 	unsigned long i;

   721 	for (i = 0; i < cConnections; i++) {

   722 	    if (it == connections.end())

   723 		break;

   724 	    cd[i] = *it;

   725 	    cd[i].pUnk->AddRef();

   726 	    ++it;

   727 	}

   728 	if (pcFetched)

   729 	    *pcFetched = i;

   730 	return i == cConnections ? S_OK : S_FALSE;

   731     }

   732     STDMETHOD(Skip)(ULONG cConnections)

   733     {

   734 	while (cConnections) {

   735 	    ++it;

   736 	    --cConnections;

   737 	    if (it == connections.end())

   738 		return S_FALSE;

   739 	}

   740 	return S_OK;

   741     }

   742     STDMETHOD(Reset)()

   743     {

   744 	it = connections.begin();

   745 

   746 	return S_OK;

   747     }

   748     STDMETHOD(Clone)(IEnumConnections **ppEnum)

   749     {

   750 	*ppEnum = new QAxConnection(*this);

   751 	(*ppEnum)->AddRef();

   752 

   753 	return S_OK;

   754     }

   755 

   756 private:

   757     QAxServerBase *that;

   758     QUuid iid;

   759     Connections connections;

   760     Iterator it;

   761 

   762     CRITICAL_SECTION refCountSection;

   763     unsigned long ref;

   764 };

   765 

   766 // callback for DLL server to hook into non-Qt eventloop

   767 LRESULT CALLBACK axs_FilterProc(int nCode, WPARAM wParam, LPARAM lParam)

   768 {

   769     if (qApp && !invokeCount)

   770         qApp->sendPostedEvents();

   771 

   772     return CallNextHookEx(qax_hhook, nCode, wParam, lParam);

   773 }

   774 

   775 // filter for executable case to hook into Qt eventloop

   776 // for DLLs the client calls TranslateAccelerator

   777 bool qax_winEventFilter(void *message)

   778 {

   779     MSG *pMsg = (MSG*)message;

   780     if (pMsg->message < WM_KEYFIRST || pMsg->message > WM_KEYLAST)

   781 	return false;

   782 

   783     bool ret = false;

   784     QWidget *aqt = QWidget::find(pMsg->hwnd);

   785     if (!aqt)

   786 	return ret;

   787 

   788     HWND baseHwnd = ::GetParent(aqt->winId());

   789     QAxServerBase *axbase = 0;

   790     while (!axbase && baseHwnd) {

   791 #ifdef GWLP_USERDATA

   792         axbase = (QAxServerBase*)GetWindowLongPtr(baseHwnd, GWLP_USERDATA);

   793 #else

   794         axbase = (QAxServerBase*)GetWindowLong(baseHwnd, GWL_USERDATA);

   795 #endif

   796 

   797 	baseHwnd = ::GetParent(baseHwnd);

   798     }

   799     if (!axbase)

   800 	return ret;

   801 

   802     HRESULT hres = axbase->TranslateAcceleratorW(pMsg);

   803     return hres == S_OK;

   804 }

   805 

   806 extern void qWinMsgHandler(QtMsgType t, const char* str);

   807 

   808 // COM Factory class, mapping COM requests to ActiveQt requests.

   809 // One instance of this class for each ActiveX the server can provide.

   810 class QClassFactory : public IClassFactory2

   811 {

   812 public:

   813     QClassFactory(CLSID clsid)

   814 	: ref(0), licensed(false)

   815     {

   816 	InitializeCriticalSection(&refCountSection);

   817 

   818 	// COM only knows the CLSID, but QAxFactory is class name based...

   819 	QStringList keys = qAxFactory()->featureList();

   820 	for (QStringList::Iterator  key = keys.begin(); key != keys.end(); ++key) {

   821 	    if (qAxFactory()->classID(*key) == clsid) {

   822 		className = *key;

   823 		break;

   824 	    }

   825 	}

   826 

   827 	const QMetaObject *mo = qAxFactory()->metaObject(className);

   828 	if (mo) {

   829 	    classKey = QLatin1String(mo->classInfo(mo->indexOfClassInfo("LicenseKey")).value());

   830 	    licensed = !classKey.isEmpty();

   831 	}

   832     }

   833 

   834     ~QClassFactory()

   835     {

   836 	DeleteCriticalSection(&refCountSection);

   837     }

   838 

   839     // IUnknown

   840     unsigned long WINAPI AddRef()

   841     {

   842 	EnterCriticalSection(&refCountSection);

   843 	unsigned long r = ++ref;

   844 	LeaveCriticalSection(&refCountSection);

   845 	return ++r;

   846     }

   847     unsigned long WINAPI Release()

   848     {

   849 	EnterCriticalSection(&refCountSection);

   850 	unsigned long r = --ref;

   851 	LeaveCriticalSection(&refCountSection);

   852 

   853 	if (!r) {

   854 	    delete this;

   855 	    return 0;

   856 	}

   857 	return r;

   858     }

   859     HRESULT WINAPI QueryInterface(REFIID iid, LPVOID *iface)

   860     {

   861 	*iface = 0;

   862 	if (iid == IID_IUnknown)

   863 	    *iface = (IUnknown*)this;

   864 	else if (iid == IID_IClassFactory)

   865 	    *iface = (IClassFactory*)this;

   866 	else if (iid == IID_IClassFactory2 && licensed)

   867 	    *iface = (IClassFactory2*)this;

   868 	else

   869 	    return E_NOINTERFACE;

   870 

   871 	AddRef();

   872 	return S_OK;

   873     }

   874 

   875     HRESULT WINAPI CreateInstanceHelper(IUnknown *pUnkOuter, REFIID iid, void **ppObject)

   876     {

   877 	if (pUnkOuter) {

   878 	    if (iid != IID_IUnknown)

   879 		return CLASS_E_NOAGGREGATION;

   880 	    const QMetaObject *mo = qAxFactory()->metaObject(className);

   881 	    if (mo && !qstricmp(mo->classInfo(mo->indexOfClassInfo("Aggregatable")).value(), "no"))

   882 		return CLASS_E_NOAGGREGATION;

   883 	}

   884 

   885     	// Make sure a QApplication instance is present (inprocess case)

   886         if (!qApp) {

   887             qInstallMsgHandler(qWinMsgHandler);

   888             qax_ownQApp = true;

   889             int argc = 0;

   890             QApplication *app = new QApplication(argc, 0);

   891         }

   892         qApp->setQuitOnLastWindowClosed(false);

   893 

   894         if (qAxOutProcServer)

   895             QAbstractEventDispatcher::instance()->setEventFilter(qax_winEventFilter);

   896         else

   897             QApplication::instance()->d_func()->in_exec = true;

   898 

   899         // hook into eventloop; this allows a server to create his own QApplication object

   900         if (!qax_hhook && qax_ownQApp) {

   901             qax_hhook = SetWindowsHookEx(WH_GETMESSAGE, axs_FilterProc, 0, GetCurrentThreadId());

   902         }

   903 

   904 	HRESULT res;

   905 	// Create the ActiveX wrapper - aggregate if requested

   906 	if (pUnkOuter) {

   907 	    QAxServerAggregate *aggregate = new QAxServerAggregate(className, pUnkOuter);

   908 	    res = aggregate->QueryInterface(iid, ppObject);

   909 	    if (FAILED(res))

   910 		delete aggregate;

   911 	} else {

   912 	    QAxServerBase *activeqt = new QAxServerBase(className, pUnkOuter);

   913 	    res = activeqt->QueryInterface(iid, ppObject);

   914 	    if (FAILED(res))

   915 		delete activeqt;

   916 	    else

   917 		activeqt->registerActiveObject((IUnknown*)(IDispatch*)activeqt);

   918 	}

   919 	return res;

   920     }

   921 

   922     // IClassFactory

   923     HRESULT WINAPI CreateInstance(IUnknown *pUnkOuter, REFIID iid, void **ppObject)

   924     {

   925 	// class is licensed

   926 	if (licensed && !qAxFactory()->validateLicenseKey(className, QString()))

   927 	    return CLASS_E_NOTLICENSED;

   928 

   929 	return CreateInstanceHelper(pUnkOuter, iid, ppObject);

   930     }

   931     HRESULT WINAPI LockServer(BOOL fLock)

   932     {

   933 	if (fLock)

   934 	    qAxLock();

   935 	else

   936 	    qAxUnlock();

   937 

   938 	return S_OK;

   939     }

   940 

   941     // IClassFactory2

   942     HRESULT WINAPI RequestLicKey(DWORD, BSTR *pKey)

   943     {

   944 	if (!pKey)

   945 	    return E_POINTER;

   946 	*pKey = 0;

   947 

   948 	// This of course works only on fully licensed machines

   949 	if (!qAxFactory()->validateLicenseKey(className, QString()))

   950 	    return CLASS_E_NOTLICENSED;

   951 

   952 	*pKey = QStringToBSTR(classKey);

   953 	return S_OK;

   954     }

   955 

   956     HRESULT WINAPI GetLicInfo(LICINFO *pLicInfo)

   957     {

   958 	if (!pLicInfo)

   959 	    return E_POINTER;

   960 	pLicInfo->cbLicInfo = sizeof(LICINFO);

   961 

   962 	// class specific license key?

   963 	const QMetaObject *mo = qAxFactory()->metaObject(className);

   964 	const char *key = mo->classInfo(mo->indexOfClassInfo("LicenseKey")).value();

   965 	pLicInfo->fRuntimeKeyAvail = key && key[0];

   966 

   967 	// machine fully licensed?

   968 	pLicInfo->fLicVerified = qAxFactory()->validateLicenseKey(className, QString());

   969 

   970 	return S_OK;

   971     }

   972 

   973     HRESULT WINAPI CreateInstanceLic(IUnknown *pUnkOuter, IUnknown *pUnkReserved, REFIID iid, BSTR bKey, PVOID *ppObject)

   974     {

   975         QString licenseKey = QString::fromWCharArray(bKey);

   976 	if (!qAxFactory()->validateLicenseKey(className, licenseKey))

   977 	    return CLASS_E_NOTLICENSED;

   978 	return CreateInstanceHelper(pUnkOuter, iid, ppObject);

   979     }

   980 

   981     QString className;

   982 

   983 protected:

   984     CRITICAL_SECTION refCountSection;

   985     unsigned long ref;

   986     bool licensed;

   987     QString classKey;

   988 };

   989 

   990 // Create a QClassFactory object for class \a iid

   991 HRESULT GetClassObject(REFIID clsid, REFIID iid, void **ppUnk)

   992 {

   993     QClassFactory *factory = new QClassFactory(clsid);

   994     if (!factory)

   995 	return E_OUTOFMEMORY;

   996     if (factory->className.isEmpty()) {

   997 	delete factory;

   998 	return E_NOINTERFACE;

   999     }

  1000     HRESULT res = factory->QueryInterface(iid, ppUnk);

  1001     if (res != S_OK)

  1002 	delete factory;

  1003     return res;

  1004 }

  1005 

  1006 

  1007 /*!

  1008     Constructs a QAxServerBase object wrapping the QWidget \a

  1009     classname into an ActiveX control.

  1010 

  1011     The constructor is called by the QClassFactory object provided by

  1012     the COM server for the respective CLSID.

  1013 */

  1014 QAxServerBase::QAxServerBase(const QString &classname, IUnknown *outerUnknown)

  1015 : aggregatedObject(0), ref(0), ole_ref(0), class_name(classname),

  1016   m_hWnd(0), hmenuShared(0), hwndMenuOwner(0),

  1017   m_outerUnknown(outerUnknown)

  1018 {

  1019     init();

  1020 

  1021     internalCreate();

  1022 }

  1023 

  1024 /*!

  1025     Constructs a QAxServerBase object wrapping \a o.

  1026 */

  1027 QAxServerBase::QAxServerBase(QObject *o)

  1028 : aggregatedObject(0), ref(0), ole_ref(0),

  1029   m_hWnd(0), hmenuShared(0), hwndMenuOwner(0),

  1030   m_outerUnknown(0)

  1031 {

  1032     init();

  1033 

  1034     qt.object = o;

  1035     if (o) {

  1036 	theObject = o;

  1037 	isWidget = false;

  1038 	class_name = QLatin1String(o->metaObject()->className());

  1039     }

  1040     internalBind();

  1041     internalConnect();

  1042 }

  1043 

  1044 /*!

  1045     Initializes data members.

  1046 */

  1047 void QAxServerBase::init()

  1048 {

  1049     qt.object = 0;

  1050     isWidget		= false;

  1051     ownObject		= false;

  1052     initNewCalled	= false;

  1053     dirtyflag		= false;

  1054     hasStockEvents	= false;

  1055     stayTopLevel	= false;

  1056     isInPlaceActive	= false;

  1057     isUIActive		= false;

  1058     wasUIActive		= false;

  1059     inDesignMode	= false;

  1060     canTakeFocus	= false;

  1061     freezeEvents = 0;

  1062     exception = 0;

  1063 

  1064     m_spAdviseSink = 0;

  1065     m_spClientSite = 0;

  1066     m_spInPlaceSite = 0;

  1067     m_spInPlaceFrame = 0;

  1068     m_spTypeInfo = 0;

  1069     m_spStorage = 0;

  1070 

  1071     InitializeCriticalSection(&refCountSection);

  1072     InitializeCriticalSection(&createWindowSection);

  1073 

  1074 #ifdef QT_DEBUG

  1075     EnterCriticalSection(&refCountSection);

  1076     ++qaxserverbase_instance_count;

  1077     LeaveCriticalSection(&refCountSection);

  1078 #endif

  1079 

  1080     qAxLock();

  1081 

  1082     points[IID_IPropertyNotifySink] = new QAxConnection(this, IID_IPropertyNotifySink);

  1083 }

  1084 

  1085 /*!

  1086     Destroys the QAxServerBase object, releasing all allocated

  1087     resources and interfaces.

  1088 */

  1089 QAxServerBase::~QAxServerBase()

  1090 {

  1091 #ifdef QT_DEBUG

  1092     EnterCriticalSection(&refCountSection);

  1093     --qaxserverbase_instance_count;

  1094     LeaveCriticalSection(&refCountSection);

  1095 #endif

  1096 

  1097     revokeActiveObject();

  1098 

  1099     for (QAxServerBase::ConnectionPointsIterator it = points.begin(); it != points.end(); ++it) {

  1100 	if (it.value())

  1101 	    (*it)->Release();

  1102     }

  1103     delete aggregatedObject;

  1104     aggregatedObject = 0;

  1105     if (theObject) {

  1106 	qt.object->disconnect(this);

  1107 	QObject *aqt = qt.object;

  1108 	qt.object = 0;

  1109 	if (ownObject)

  1110 	    delete aqt;

  1111     }

  1112 

  1113     if (m_spAdviseSink) m_spAdviseSink->Release();

  1114     m_spAdviseSink = 0;

  1115     for (int i = 0; i < adviseSinks.count(); ++i) {

  1116         adviseSinks.at(i).pAdvSink->Release();

  1117     }

  1118     if (m_spClientSite) m_spClientSite->Release();

  1119     m_spClientSite = 0;

  1120     if (m_spInPlaceFrame) m_spInPlaceFrame->Release();

  1121     m_spInPlaceFrame = 0;

  1122     if (m_spInPlaceSite) m_spInPlaceSite->Release();

  1123     m_spInPlaceSite = 0;

  1124     if (m_spTypeInfo) m_spTypeInfo->Release();

  1125     m_spTypeInfo = 0;

  1126     if (m_spStorage) m_spStorage->Release();

  1127     m_spStorage = 0;

  1128 

  1129     DeleteCriticalSection(&refCountSection);

  1130     DeleteCriticalSection(&createWindowSection);

  1131 

  1132     qAxUnlock();

  1133 }

  1134