/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:BSD$

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

**

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

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

** met:

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

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

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

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

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

**     distribution.

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

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

**     products derived from this software without specific prior written

**     permission.

**

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

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

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

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

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

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

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

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

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

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

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

** $QT_END_LICENSE$

**

****************************************************************************/

#define QT_NO_CAST_TO_ASCII

#ifndef QT_NO_WIN_ACTIVEQT

#include <qabstracteventdispatcher.h>

#include <qapplication.h>

#include <qbuffer.h>

#include <qdatastream.h>

#include <qdebug.h>

#include <qevent.h>

#include <qeventloop.h>

#include <qfile.h>

#include <qpointer.h>

#include <qhash.h>

#include <qmap.h>

#include <qmenubar.h>

#include <qmenu.h>

#include <qmetaobject.h>

#include <qpixmap.h>

#include <qstatusbar.h>

#include <qwhatsthis.h>

#include <ocidl.h>

#include <olectl.h>

#include <private/qcoreapplication_p.h>

#include "qaxfactory.h"

#include "qaxbindable.h"

#include "qaxaggregated.h"

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

#if defined Q_CC_GNU

#   include <w32api.h>

#endif

#ifndef Q_OS_WIN64

#define ULONG_PTR DWORD

#endif

QT_BEGIN_NAMESPACE

extern HHOOK qax_hhook;

// in qaxserver.cpp

extern ITypeLib *qAxTypeLibrary;

extern QAxFactory *qAxFactory();

extern unsigned long qAxLock();

extern unsigned long qAxUnlock();

extern HANDLE qAxInstance;

extern bool qAxOutProcServer;

static int invokeCount = 0;

#ifdef QT_DEBUG

unsigned long qaxserverbase_instance_count = 0;

#endif

// in qaxserverdll.cpp

extern bool qax_ownQApp;

struct QAxExceptInfo

{

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

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

    {

    }

    int code;

    QString src;

    QString desc;

    QString context;

};

bool qt_sendSpontaneousEvent(QObject*, QEvent*);

/*

    \class QAxServerBase

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

    \internal

*/

class QAxServerBase :

    public QObject,

    public IAxServerBase,

    public IDispatch,

    public IOleObject,

    public IOleControl,

#if defined Q_CC_GNU

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

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

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

#   endif

#endif

    public IViewObject2,

    public IOleInPlaceObject,

    public IOleInPlaceActiveObject,

    public IProvideClassInfo2,

    public IConnectionPointContainer,

    public IPersistStream,

    public IPersistStreamInit,

    public IPersistStorage,

    public IPersistPropertyBag,

    public IPersistFile,

    public IDataObject

{

public:

    typedef QMap<QUuid,IConnectionPoint*> ConnectionPoints;

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

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

    QAxServerBase(QObject *o);

    void init();

    ~QAxServerBase();

// Window creation

    HWND create(HWND hWndParent, RECT& rcPos);

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

    void createMenu(QMenuBar *menuBar);

    void removeMenu();

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

// Object registration with OLE

    void registerActiveObject(IUnknown *object);

    void revokeActiveObject();

// IUnknown

    unsigned long WINAPI AddRef()

    {

	if (m_outerUnknown)

	    return m_outerUnknown->AddRef();

	EnterCriticalSection(&refCountSection);

	unsigned long r = ++ref;

	LeaveCriticalSection(&refCountSection);

	return r;

    }

    unsigned long WINAPI Release()

    {

    	if (m_outerUnknown)

	    return m_outerUnknown->Release();

	EnterCriticalSection(&refCountSection);

	unsigned long r = --ref;

	LeaveCriticalSection(&refCountSection);

	if (!r) {

	    delete this;

	    return 0;

	}

	return r;

    }

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

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

// IAxServerBase

    IUnknown *clientSite() const

    {

	return m_spClientSite;

    }

    void emitPropertyChanged(const char*);

    bool emitRequestPropertyChange(const char*);

    QObject *qObject() const

    {

	return theObject;

    }

    void ensureMetaData();

    bool isPropertyExposed(int index);

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

    {

        if (exception)

            delete exception;

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

    }

// IDispatch

    STDMETHOD(GetTypeInfoCount)(UINT* pctinfo);

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

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

    STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid,

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

		EXCEPINFO* pexcepinfo, UINT* puArgErr);

// IProvideClassInfo

    STDMETHOD(GetClassInfo)(ITypeInfo** pptinfo);

// IProvideClassInfo2

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

// IOleObject

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

    STDMETHOD(Close)(DWORD dwSaveOption);

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

    STDMETHOD(EnumAdvise)(IEnumSTATDATA** ppenumAdvise);

    STDMETHOD(EnumVerbs)(IEnumOLEVERB** ppEnumOleVerb);

    STDMETHOD(GetClientSite)(IOleClientSite** ppClientSite);

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

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

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

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

    STDMETHOD(GetUserClassID)(CLSID* pClsid);

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

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

    STDMETHOD(IsUpToDate)();

    STDMETHOD(SetClientSite)(IOleClientSite* pClientSite);

    STDMETHOD(SetColorScheme)(LOGPALETTE* pLogPal);

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

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

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

    STDMETHOD(Unadvise)(DWORD dwConnection);

    STDMETHOD(Update)();

// IViewObject

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

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

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

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

		    HDC hicTargetDev, LOGPALETTE **ppColorSet);

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

    STDMETHOD(Unfreeze)(DWORD dwFreeze);

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

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

// IViewObject2

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

// IOleControl

    STDMETHOD(FreezeEvents)(BOOL);

    STDMETHOD(GetControlInfo)(LPCONTROLINFO);

    STDMETHOD(OnAmbientPropertyChange)(DISPID);

    STDMETHOD(OnMnemonic)(LPMSG);

// IOleWindow

    STDMETHOD(GetWindow)(HWND *pHwnd);

    STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode);

// IOleInPlaceObject

    STDMETHOD(InPlaceDeactivate)();

    STDMETHOD(UIDeactivate)();

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

    STDMETHOD(ReactivateAndUndo)();

// IOleInPlaceActiveObject

    STDMETHOD(TranslateAcceleratorW)(MSG *pMsg);

    STDMETHOD(TranslateAcceleratorA)(MSG *pMsg);

    STDMETHOD(OnFrameWindowActivate)(BOOL);

    STDMETHOD(OnDocWindowActivate)(BOOL fActivate);

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

    STDMETHOD(EnableModeless)(BOOL);

// IConnectionPointContainer

    STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints**);

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

// IPersist

    STDMETHOD(GetClassID)(GUID*clsid)

    {

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

	return S_OK;

    }

// IPersistStreamInit

    STDMETHOD(InitNew)(VOID);

    STDMETHOD(IsDirty)();

    STDMETHOD(Load)(IStream *pStm);

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

    STDMETHOD(GetSizeMax)(ULARGE_INTEGER *pcbSize);

// IPersistPropertyBag

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

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

// IPersistStorage

    STDMETHOD(InitNew)(IStorage *pStg);

    STDMETHOD(Load)(IStorage *pStg);

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

    STDMETHOD(SaveCompleted)(IStorage *pStgNew);

    STDMETHOD(HandsOffStorage)();

// IPersistFile

    STDMETHOD(SaveCompleted)(LPCOLESTR fileName);

    STDMETHOD(GetCurFile)(LPOLESTR *currentFile);

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

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

// IDataObject

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

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

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

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

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

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

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

    STDMETHOD(DUnadvise)(DWORD dwConnection);

    STDMETHOD(EnumDAdvise)(IEnumSTATDATA **ppenumAdvise);

// QObject

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

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

private:

    void update();

    void resize(const QSize &newSize);

    void updateGeometry();

    void updateMask();

    bool internalCreate();

    void internalBind();

    void internalConnect();

    HRESULT internalActivate();

    friend class QAxBindable;

    friend class QAxPropertyPage;

    QAxAggregated *aggregatedObject;

    ConnectionPoints points;

    union {

	QWidget *widget;

	QObject *object;

    } qt;

    QPointer<QObject> theObject;

    unsigned isWidget		:1;

    unsigned ownObject		:1;

    unsigned initNewCalled	:1;

    unsigned dirtyflag		:1;

    unsigned hasStockEvents	:1;

    unsigned stayTopLevel	:1;

    unsigned isInPlaceActive	:1;

    unsigned isUIActive		:1;

    unsigned wasUIActive	:1;

    unsigned inDesignMode	:1;

    unsigned canTakeFocus	:1;

    short freezeEvents;

    HWND m_hWnd;

    HMENU hmenuShared;

    HOLEMENU holemenu;

    HWND hwndMenuOwner;

    QMap<HMENU, QMenu*> menuMap;

    QMap<UINT, QAction*> actionMap;

    QPointer<QMenuBar> menuBar;

    QPointer<QStatusBar> statusBar;

    QPointer<QMenu> currentPopup;

    QAxExceptInfo *exception;

    CRITICAL_SECTION refCountSection;

    CRITICAL_SECTION createWindowSection;

    unsigned long ref;

    unsigned long ole_ref;

    QString class_name;

    QString currentFileName;

    QHash<long, int> indexCache;

    QHash<int,DISPID> signalCache;

    IUnknown *m_outerUnknown;

    IAdviseSink *m_spAdviseSink;

    QList<STATDATA> adviseSinks;

    IOleClientSite *m_spClientSite;

    IOleInPlaceSiteWindowless *m_spInPlaceSite;

    IOleInPlaceFrame *m_spInPlaceFrame;

    ITypeInfo *m_spTypeInfo;

    IStorage *m_spStorage;

    QSize m_currentExtent;

};

class QAxServerAggregate : public IUnknown

{

public:

    QAxServerAggregate(const QString &className, IUnknown *outerUnknown)

	: m_outerUnknown(outerUnknown), ref(0)

    {

	object = new QAxServerBase(className, outerUnknown);

	object->registerActiveObject(this);

	InitializeCriticalSection(&refCountSection);

	InitializeCriticalSection(&createWindowSection);

    }

    ~QAxServerAggregate()

    {

	DeleteCriticalSection(&refCountSection);

	DeleteCriticalSection(&createWindowSection);

	delete object;

    }

// IUnknown

    unsigned long WINAPI AddRef()

    {

	EnterCriticalSection(&refCountSection);

	unsigned long r = ++ref;

	LeaveCriticalSection(&refCountSection);

	return r;

    }

    unsigned long WINAPI Release()

    {

	EnterCriticalSection(&refCountSection);

	unsigned long r = --ref;

	LeaveCriticalSection(&refCountSection);

	if (!r) {

	    delete this;

	    return 0;

	}

	return r;

    }

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

    {

	*iface = 0;

	HRESULT res = E_NOINTERFACE;

	if (iid == IID_IUnknown) {

	    *iface = (IUnknown*)this;

	    AddRef();

	    return S_OK;

	}

	return object->InternalQueryInterface(iid, iface);

    }

private:

    QAxServerBase *object;

    IUnknown *m_outerUnknown;

    unsigned long ref;

    CRITICAL_SECTION refCountSection;

    CRITICAL_SECTION createWindowSection;

};

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

{

    *wrapper = 0;

    QAxServerBase *obj = new QAxServerBase(object);

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

    if (*wrapper)

	return true;

    delete obj;

    return false;

}

/*

    Helper class to enumerate all supported event interfaces.

*/

class QAxSignalVec : public IEnumConnectionPoints

{

public:

    QAxSignalVec(const QAxServerBase::ConnectionPoints &points)

	: cpoints(points), ref(0)

    {

	InitializeCriticalSection(&refCountSection);

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

	    (*i)->AddRef();

    }

    QAxSignalVec(const QAxSignalVec &old)

    {

	InitializeCriticalSection(&refCountSection);

	ref = 0;

	cpoints = old.cpoints;

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

	    (*i)->AddRef();

	it = old.it;

    }

    ~QAxSignalVec()

    {

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

	    (*i)->Release();

	DeleteCriticalSection(&refCountSection);

    }

    unsigned long __stdcall AddRef()

    {

	EnterCriticalSection(&refCountSection);

	unsigned long r = ++ref;

	LeaveCriticalSection(&refCountSection);

	return ++r;

    }

    unsigned long __stdcall Release()