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

**

** Copyright (C) 2010 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$

**

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

#include "qaxwidget.h"

#ifndef QT_NO_WIN_ACTIVEQT

#include <ActiveQt/qaxaggregated.h>

#include <qabstracteventdispatcher.h>

#include <qapplication.h>

#include <private/qapplication_p.h>

#include <qdockwidget.h>

#include <qevent.h>

#include <qlayout.h>

#include <qmainwindow.h>

#include <qmenu.h>

#include <qmenubar.h>

#include <qmetaobject.h>

#include <qpainter.h>

#include <qpointer.h>

#include <qregexp.h>

#include <quuid.h>

#include <qwhatsthis.h>

#include <windowsx.h>

#include <ocidl.h>

#include <olectl.h>

#include <docobj.h>

// #define QAX_DEBUG

#ifdef QAX_DEBUG

#define AX_DEBUG(x) qDebug(#x);

#else

#define AX_DEBUG(x);

#endif

// #define QAX_SUPPORT_WINDOWLESS

// #define QAX_SUPPORT_BORDERSPACE

// missing interface from win32api

#if defined(Q_CC_GNU)

#   if !defined(IOleInPlaceObjectWindowless)

#       undef INTERFACE

#       define INTERFACE IOleInPlaceObjectWindowless

        DECLARE_INTERFACE_(IOleInPlaceObjectWindowless,IOleInPlaceObject)

        {

           STDMETHOD(QueryInterface)(THIS_ REFIID,PVOID*) PURE;

           STDMETHOD_(ULONG,AddRef)(THIS) PURE;

           STDMETHOD_(ULONG,Release)(THIS) PURE;

           STDMETHOD(GetWindow)(THIS_ HWND*) PURE;

           STDMETHOD(ContextSensitiveHelp)(THIS_ BOOL) PURE;

           STDMETHOD(InPlaceDeactivate)(THIS) PURE;

           STDMETHOD(UIDeactivate)(THIS) PURE;

           STDMETHOD(SetObjectRects)(THIS_ LPCRECT,LPCRECT) PURE;

           STDMETHOD(ReactivateAndUndo)(THIS) PURE;

           STDMETHOD(OnWindowMessage)(THIS_ UINT, WPARAM, LPARAM, LRESULT*) PURE;

           STDMETHOD(GetDropTarget)(THIS_ IDropTarget**) PURE;

        };

#   endif

#endif

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

QT_BEGIN_NAMESPACE

/*  \class QAxHostWidget

    \brief The QAxHostWidget class is the actual container widget.

    \internal

*/

class QAxHostWidget : public QWidget

{

    friend class QAxClientSite;

public:

    Q_OBJECT_CHECK

    QAxHostWidget(QWidget *parent, QAxClientSite *ax);

    ~QAxHostWidget();

    QSize sizeHint() const;

    QSize minimumSizeHint() const;

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

    void* qt_metacast(const char *clname);

    inline QAxClientSite *clientSite() const

    {

        return axhost;

    }

protected:

    bool winEvent(MSG *msg, long *result);

    bool event(QEvent *e);

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

    void resizeEvent(QResizeEvent *e);

    void focusInEvent(QFocusEvent *e);

    void focusOutEvent(QFocusEvent *e);

    void paintEvent(QPaintEvent *e);

    void showEvent(QShowEvent *e);

    QPaintEngine* paintEngine() const

    {

        return 0;

    }

private:

    void resizeObject();

    int setFocusTimer;

    bool hasFocus;

    QAxClientSite *axhost;

};

/*  \class QAxClientSite

    \brief The QAxClientSite class implements the client site interfaces.

    \internal

*/

class QAxClientSite : public IDispatch,

                    public IOleClientSite,

                    public IOleControlSite,

#ifdef QAX_SUPPORT_WINDOWLESS

                    public IOleInPlaceSiteWindowless,

#else

                    public IOleInPlaceSite,

#endif

                    public IOleInPlaceFrame,

                    public IOleDocumentSite,

                    public IAdviseSink

{

    friend class QAxHostWidget;

public:

    QAxClientSite(QAxWidget *c);

    virtual ~QAxClientSite();

    bool activateObject(bool initialized, const QByteArray &data);

    void releaseAll();

    void deactivate();

    inline void reset(QWidget *p)

    {

        if (widget == p)

            widget = 0;

        else if (host == p)

            host = 0;

    }

    inline IOleInPlaceActiveObject *inPlaceObject() const

    {

        return m_spInPlaceActiveObject;

    }

    inline HRESULT doVerb(LONG index)

    {

        if (!m_spOleObject)

            return E_NOTIMPL;

        if (!host)

            return OLE_E_NOT_INPLACEACTIVE;

        RECT rcPos = { host->x(), host->y(), host->x()+host->width(), host->y()+host->height() };

        return m_spOleObject->DoVerb(index, 0, this, 0, host->winId(), &rcPos);

    }

    // IUnknown

    unsigned long WINAPI AddRef();

    unsigned long WINAPI Release();

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

    // IDispatch

    HRESULT __stdcall GetTypeInfoCount(unsigned int *) { return E_NOTIMPL; }

    HRESULT __stdcall GetTypeInfo(UINT, LCID, ITypeInfo **) { return E_NOTIMPL; }

    HRESULT __stdcall GetIDsOfNames(const _GUID &, wchar_t **, unsigned int, unsigned long, long *) { return E_NOTIMPL; }

    HRESULT __stdcall Invoke(DISPID dispIdMember,

        REFIID riid,

        LCID lcid,

        WORD wFlags,

        DISPPARAMS *pDispParams,

        VARIANT *pVarResult,

        EXCEPINFO *pExcepInfo,

        UINT *puArgErr);

    void emitAmbientPropertyChange(DISPID dispid);

    // IOleClientSite

    STDMETHOD(SaveObject)();

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

    STDMETHOD(GetContainer)(LPOLECONTAINER FAR* ppContainer);

    STDMETHOD(ShowObject)();

    STDMETHOD(OnShowWindow)(BOOL fShow);

    STDMETHOD(RequestNewObjectLayout)();

    // IOleControlSite

    STDMETHOD(OnControlInfoChanged)();

    STDMETHOD(LockInPlaceActive)(BOOL fLock);

    STDMETHOD(GetExtendedControl)(IDispatch** ppDisp);

    STDMETHOD(TransformCoords)(POINTL* pPtlHimetric, POINTF* pPtfContainer, DWORD dwFlags);

    STDMETHOD(TranslateAccelerator)(LPMSG lpMsg, DWORD grfModifiers);

    STDMETHOD(OnFocus)(BOOL fGotFocus);

    STDMETHOD(ShowPropertyFrame)();

    // IOleWindow

    STDMETHOD(GetWindow)(HWND *phwnd);

    STDMETHOD(ContextSensitiveHelp)(BOOL fEnterMode);

    // IOleInPlaceSite

    STDMETHOD(CanInPlaceActivate)();

    STDMETHOD(OnInPlaceActivate)();

    STDMETHOD(OnUIActivate)();

    STDMETHOD(GetWindowContext)(IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc, LPRECT lprcPosRect, LPRECT lprcClipRect, LPOLEINPLACEFRAMEINFO lpFrameInfo);

    STDMETHOD(Scroll)(SIZE scrollExtant);

    STDMETHOD(OnUIDeactivate)(BOOL fUndoable);

    STDMETHOD(OnInPlaceDeactivate)();

    STDMETHOD(DiscardUndoState)();

    STDMETHOD(DeactivateAndUndo)();

    STDMETHOD(OnPosRectChange)(LPCRECT lprcPosRect);

#ifdef QAX_SUPPORT_WINDOWLESS

// IOleInPlaceSiteEx ###

    STDMETHOD(OnInPlaceActivateEx)(BOOL* /*pfNoRedraw*/, DWORD /*dwFlags*/)

    {

        return S_OK;

    }

    STDMETHOD(OnInPlaceDeactivateEx)(BOOL /*fNoRedraw*/)

    {

        return S_OK;

    }

    STDMETHOD(RequestUIActivate)()

    {

        return S_OK;

    }

// IOleInPlaceSiteWindowless ###

    STDMETHOD(CanWindowlessActivate)()

    {

        return S_OK;

    }

    STDMETHOD(GetCapture)()

    {

        return S_FALSE;

    }

    STDMETHOD(SetCapture)(BOOL /*fCapture*/)

    {

        return S_FALSE;

    }

    STDMETHOD(GetFocus)()

    {

        return S_FALSE;

    }

    STDMETHOD(SetFocus)(BOOL /*fCapture*/)

    {

        return S_FALSE;

    }

    STDMETHOD(GetDC)(LPCRECT /*pRect*/, DWORD /*grfFlags*/, HDC *phDC)

    {

        *phDC = 0;

        return S_OK;

    }

    STDMETHOD(ReleaseDC)(HDC hDC)

    {

        ::ReleaseDC(widget->winId(), hDC);

        return S_OK;

    }

    STDMETHOD(InvalidateRect)(LPCRECT pRect, BOOL fErase)

    {

        ::InvalidateRect(host->winId(), pRect, fErase);

        return S_OK;

    }

    STDMETHOD(InvalidateRgn)(HRGN hRGN, BOOL fErase)

    {

        ::InvalidateRgn(host->winId(), hRGN, fErase);

        return S_OK;

    }

    STDMETHOD(ScrollRect)(int /*dx*/, int /*dy*/, LPCRECT /*pRectScroll*/, LPCRECT /*pRectClip*/)

    {

        return S_OK;

    }

    STDMETHOD(AdjustRect)(LPRECT /*prc*/)

    {

        return S_OK;

    }

#ifdef Q_CC_GNU // signature incorrect in win32api

    STDMETHOD(AdjustRect)(LPCRECT /*prc*/)

    {

        RECT rect;

        return AdjustRect(&rect);

    }

#endif

    STDMETHOD(OnDefWindowMessage)(UINT /*msg*/, WPARAM /*wPara*/, LPARAM /*lParam*/, LRESULT* /*plResult*/)

    {

        return S_FALSE;

    }

#endif

    // IOleInPlaceFrame

    STDMETHOD(InsertMenus(HMENU hmenuShared, LPOLEMENUGROUPWIDTHS lpMenuWidths));

    STDMETHOD(SetMenu(HMENU hmenuShared, HOLEMENU holemenu, HWND hwndActiveObject));

    STDMETHOD(RemoveMenus(HMENU hmenuShared));

    STDMETHOD(SetStatusText(LPCOLESTR pszStatusText));

    STDMETHOD(EnableModeless(BOOL fEnable));

    STDMETHOD(TranslateAccelerator(LPMSG lpMsg, WORD grfModifiers));

    // IOleInPlaceUIWindow

    STDMETHOD(GetBorder(LPRECT lprectBorder));

    STDMETHOD(RequestBorderSpace(LPCBORDERWIDTHS pborderwidths));

    STDMETHOD(SetBorderSpace(LPCBORDERWIDTHS pborderwidths));

    STDMETHOD(SetActiveObject(IOleInPlaceActiveObject *pActiveObject, LPCOLESTR pszObjName));

    // IOleDocumentSite

    STDMETHOD(ActivateMe(IOleDocumentView *pViewToActivate));

    // IAdviseSink

    STDMETHOD_(void, OnDataChange)(FORMATETC* /*pFormatetc*/, STGMEDIUM* /*pStgmed*/)

    {

        AX_DEBUG(QAxClientSite::OnDataChange);

    }

    STDMETHOD_(void, OnViewChange)(DWORD /*dwAspect*/, LONG /*lindex*/)

    {

        AX_DEBUG(QAxClientSite::OnViewChange);

    }

    STDMETHOD_(void, OnRename)(IMoniker* /*pmk*/)

    {

    }

    STDMETHOD_(void, OnSave)()

    {

    }

    STDMETHOD_(void, OnClose)()

    {

    }

    QSize sizeHint() const { return sizehint; }

    QSize minimumSizeHint() const;

    inline void resize(QSize sz) { if (host) host->resize(sz); }

    bool translateKeyEvent(int message, int keycode) const

    {

        if (!widget)

            return false;

        return widget->translateKeyEvent(message, keycode);

    }

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

    void windowActivationChange();

    bool eventTranslated : 1;

private:

#if !defined(Q_WS_WINCE)

    struct OleMenuItem {

        OleMenuItem(HMENU hm = 0, int ID = 0, QMenu *menu = 0)

            : hMenu(hm), id(ID), subMenu(menu)

        {}

        HMENU hMenu;

        int id;

        QMenu *subMenu;

    };

    QMenu *generatePopup(HMENU subMenu, QWidget *parent);

#endif

    IOleObject *m_spOleObject;

    IOleControl *m_spOleControl;

    IOleInPlaceObjectWindowless *m_spInPlaceObject;

    IOleInPlaceActiveObject *m_spInPlaceActiveObject;

    IOleDocumentView *m_spActiveView;

    QAxAggregated *aggregatedObject;

    bool inPlaceObjectWindowless :1;

    bool inPlaceModelessEnabled :1;

    bool canHostDocument : 1;

    DWORD m_dwOleObject;

#if !defined(Q_WS_WINCE)

    HWND m_menuOwner;

#endif

    CONTROLINFO control_info;

    QSize sizehint;

    unsigned long ref;

    QAxWidget *widget;

    QAxHostWidget *host;

#if !defined(Q_WS_WINCE)

    QPointer<QMenuBar> menuBar;

    QMap<QAction*,OleMenuItem> menuItemMap;

#endif

};

static const ushort mouseTbl[] = {

    WM_MOUSEMOVE,       QEvent::MouseMove,              0,

    WM_LBUTTONDOWN,     QEvent::MouseButtonPress,       Qt::LeftButton,

    WM_LBUTTONUP,       QEvent::MouseButtonRelease,     Qt::LeftButton,

    WM_LBUTTONDBLCLK,   QEvent::MouseButtonDblClick,    Qt::LeftButton,

    WM_RBUTTONDOWN,     QEvent::MouseButtonPress,       Qt::RightButton,

    WM_RBUTTONUP,       QEvent::MouseButtonRelease,     Qt::RightButton,

    WM_RBUTTONDBLCLK,   QEvent::MouseButtonDblClick,    Qt::RightButton,

    WM_MBUTTONDOWN,     QEvent::MouseButtonPress,       Qt::MidButton,

    WM_MBUTTONUP,       QEvent::MouseButtonRelease,     Qt::MidButton,

    WM_MBUTTONDBLCLK,   QEvent::MouseButtonDblClick,    Qt::MidButton,

    0,                  0,                              0

};

static Qt::MouseButtons translateMouseButtonState(int s)

{

    Qt::MouseButtons bst = 0;

    if (s & MK_LBUTTON)

        bst |= Qt::LeftButton;

    if (s & MK_MBUTTON)

        bst |= Qt::MidButton;

    if (s & MK_RBUTTON)

        bst |= Qt::RightButton;

    return bst;

}

static Qt::KeyboardModifiers translateModifierState(int s)

{

    Qt::KeyboardModifiers bst = 0;

    if (s & MK_SHIFT)

        bst |= Qt::ShiftModifier;

    if (s & MK_CONTROL)

        bst |= Qt::ControlModifier;

    if (GetKeyState(VK_MENU) < 0)

        bst |= Qt::AltModifier;

    return bst;

}

static QAbstractEventDispatcher::EventFilter previous_filter = 0;

#if QT_VERSION >= 0x050000

#error "Fix QAbstractEventDispatcher::setEventFilter"

#endif

#if defined(Q_WS_WINCE)

static int filter_ref = 0;

#else

static const wchar_t *qaxatom = L"QAxContainer4_Atom";

#endif

// The filter procedure listening to user interaction on the control

bool axc_FilterProc(void *m)

{

    MSG *msg = (MSG*)m;

    const uint message = msg->message;

    if ((message >= WM_MOUSEFIRST && message <= WM_MOUSELAST) || (message >= WM_KEYFIRST && message <= WM_KEYLAST)) {

        HWND hwnd = msg->hwnd;

        QAxWidget *ax = 0;

        QAxHostWidget *host = 0;

        while (!host && hwnd) {

            QWidget *widget = QWidget::find(hwnd);

            if (widget && widget->inherits("QAxHostWidget"))

                host = qobject_cast<QAxHostWidget*>(widget);

            hwnd = ::GetParent(hwnd);

        }

        if (host)

            ax = qobject_cast<QAxWidget*>(host->parentWidget());

        if (ax && msg->hwnd != host->winId()) {

            if (message >= WM_KEYFIRST && message <= WM_KEYLAST) {

                QAxClientSite *site = host->clientSite();

                site->eventTranslated = true; // reset in QAxClientSite::TranslateAccelerator

                HRESULT hres = S_FALSE;

                if (site && site->inPlaceObject() && site->translateKeyEvent(msg->message, msg->wParam))

                    hres = site->inPlaceObject()->TranslateAccelerator(msg);

                // if the object calls our TranslateAccelerator implementation, then continue with normal event processing

                // otherwise the object has translated the accelerator, and the event should be stopped

                if (site->eventTranslated && hres == S_OK)

                    return true;

            } else {

                int i;

                for (i = 0; (UINT)mouseTbl[i] != message && mouseTbl[i]; i += 3)

                    ;

                if (mouseTbl[i]) {

                    QEvent::Type type = (QEvent::Type)mouseTbl[++i];

                    int button = mouseTbl[++i];

                    if (type != QEvent::MouseMove || ax->hasMouseTracking() || button) {

                        if (type == QEvent::MouseMove)

                            button = 0;

                        DWORD ol_pos = GetMessagePos();

                        QPoint gpos(GET_X_LPARAM(ol_pos), GET_Y_LPARAM(ol_pos));

                        QPoint pos = ax->mapFromGlobal(gpos);

                        QMouseEvent e(type, pos, gpos, (Qt::MouseButton)button,

                            translateMouseButtonState(msg->wParam),

                            translateModifierState(msg->wParam));

                        QApplication::sendEvent(ax, &e);

                    }

                }

            }

        }

    }

    if (previous_filter)