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

**

** All rights reserved.

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

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qapplication.h"

#include "qapplication_p.h"

#include "qevent.h"

#include "qpainter.h"

#include "qwidget.h"

#include "qbuffer.h"

#include "qdatastream.h"

#include "qcursor.h"

#include "qt_windows.h"

#include <shlobj.h>

#ifndef QT_NO_ACCESSIBILITY

#include "qaccessible.h"

#endif

#include "qdnd_p.h"

#include "qdebug.h"

#if defined(Q_OS_WINCE)

#include "qguifunctions_wince.h"

#endif

// support for xbuttons

#ifndef MK_XBUTTON1

#define MK_XBUTTON1         0x0020

#define MK_XBUTTON2         0x0040

#endif

QT_BEGIN_NAMESPACE

#if !(defined(QT_NO_DRAGANDDROP) && defined(QT_NO_CLIPBOARD))

//---------------------------------------------------------------------

//                    QOleDataObject Constructor

//---------------------------------------------------------------------

QOleDataObject::QOleDataObject(QMimeData *mimeData)

{

    m_refs = 1;

    data = mimeData;

    CF_PERFORMEDDROPEFFECT = RegisterClipboardFormat(CFSTR_PERFORMEDDROPEFFECT);

    performedEffect = DROPEFFECT_NONE;

}

QOleDataObject::~QOleDataObject()

{

}

void QOleDataObject::releaseQt()

{

    data = 0;

}

const QMimeData *QOleDataObject::mimeData() const

{

    return data;

}

DWORD QOleDataObject::reportedPerformedEffect() const

{

    return performedEffect;

}

//---------------------------------------------------------------------

//                    IUnknown Methods

//---------------------------------------------------------------------

STDMETHODIMP

QOleDataObject::QueryInterface(REFIID iid, void FAR* FAR* ppv)

{

    if (iid == IID_IUnknown || iid == IID_IDataObject) {

        *ppv = this;

        AddRef();

        return NOERROR;

    }

    *ppv = NULL;

    return ResultFromScode(E_NOINTERFACE);

}

STDMETHODIMP_(ULONG)

QOleDataObject::AddRef(void)

{

    return ++m_refs;

}

STDMETHODIMP_(ULONG)

QOleDataObject::Release(void)

{

    if (--m_refs == 0) {

        releaseQt();

        delete this;

        return 0;

    }

    return m_refs;

}

//---------------------------------------------------------------------

//                    IDataObject Methods

//

// The following methods are NOT supported for data transfer using the

// clipboard or drag-drop:

//

//      IDataObject::SetData    -- return E_NOTIMPL

//      IDataObject::DAdvise    -- return OLE_E_ADVISENOTSUPPORTED

//                 ::DUnadvise

//                 ::EnumDAdvise

//      IDataObject::GetCanonicalFormatEtc -- return E_NOTIMPL

//                     (NOTE: must set pformatetcOut->ptd = NULL)

//---------------------------------------------------------------------

STDMETHODIMP

QOleDataObject::GetData(LPFORMATETC pformatetc, LPSTGMEDIUM pmedium)

{

#ifdef QDND_DEBUG

    qDebug("QOleDataObject::GetData(LPFORMATETC pformatetc, LPSTGMEDIUM pmedium)");

#ifndef Q_OS_WINCE

    wchar_t buf[256] = {0};

    GetClipboardFormatName(pformatetc->cfFormat, buf, 255);

    qDebug("CF = %d : %s", pformatetc->cfFormat, QString::fromWCharArray(buf));

#endif

#endif

    if (!data)

        return ResultFromScode(DATA_E_FORMATETC);

    QWindowsMime *converter = QWindowsMime::converterFromMime(*pformatetc, data);

    if (converter && converter->convertFromMime(*pformatetc, data, pmedium))

        return ResultFromScode(S_OK);

    else

        return ResultFromScode(DATA_E_FORMATETC);

}

STDMETHODIMP

QOleDataObject::GetDataHere(LPFORMATETC, LPSTGMEDIUM)

{

    return ResultFromScode(DATA_E_FORMATETC);

}

STDMETHODIMP

QOleDataObject::QueryGetData(LPFORMATETC pformatetc)

{

#ifdef QDND_DEBUG

    qDebug("QOleDataObject::QueryGetData(LPFORMATETC pformatetc)");

#endif

    if (!data)

        return ResultFromScode(DATA_E_FORMATETC);

    if (QWindowsMime::converterFromMime(*pformatetc, data))

        return ResultFromScode(S_OK);

    return ResultFromScode(S_FALSE);

}

STDMETHODIMP

QOleDataObject::GetCanonicalFormatEtc(LPFORMATETC, LPFORMATETC pformatetcOut)

{

    pformatetcOut->ptd = NULL;

    return ResultFromScode(E_NOTIMPL);

}

STDMETHODIMP

QOleDataObject::SetData(LPFORMATETC pFormatetc, STGMEDIUM *pMedium, BOOL fRelease)

{

    if (pFormatetc->cfFormat == CF_PERFORMEDDROPEFFECT && pMedium->tymed == TYMED_HGLOBAL) {

        DWORD * val = (DWORD*)GlobalLock(pMedium->hGlobal);

        performedEffect = *val;

        GlobalUnlock(pMedium->hGlobal);

        if (fRelease)

            ReleaseStgMedium(pMedium);

        return ResultFromScode(S_OK);

    }

    return ResultFromScode(E_NOTIMPL);

}

STDMETHODIMP

QOleDataObject::EnumFormatEtc(DWORD dwDirection, LPENUMFORMATETC FAR* ppenumFormatEtc)

{

#ifdef QDND_DEBUG

    qDebug("QOleDataObject::EnumFormatEtc(DWORD dwDirection, LPENUMFORMATETC FAR* ppenumFormatEtc)");

#endif

    if (!data)

        return ResultFromScode(DATA_E_FORMATETC);

    SCODE sc = S_OK;

    QVector<FORMATETC> fmtetcs;

    if (dwDirection == DATADIR_GET) {

        fmtetcs = QWindowsMime::allFormatsForMime(data);

    } else {

        FORMATETC formatetc;

        formatetc.cfFormat = CF_PERFORMEDDROPEFFECT;

        formatetc.dwAspect = DVASPECT_CONTENT;

        formatetc.lindex = -1;

        formatetc.ptd = NULL;

        formatetc.tymed = TYMED_HGLOBAL;

        fmtetcs.append(formatetc);

    }

    QOleEnumFmtEtc *enumFmtEtc = new QOleEnumFmtEtc(fmtetcs);

    *ppenumFormatEtc = enumFmtEtc;

    if (enumFmtEtc->isNull()) {

        delete enumFmtEtc;

        *ppenumFormatEtc = NULL;

        sc = E_OUTOFMEMORY;

    }

    return ResultFromScode(sc);

}

STDMETHODIMP

QOleDataObject::DAdvise(FORMATETC FAR*, DWORD,

                       LPADVISESINK, DWORD FAR*)

{

    return ResultFromScode(OLE_E_ADVISENOTSUPPORTED);

}

STDMETHODIMP

QOleDataObject::DUnadvise(DWORD)

{

    return ResultFromScode(OLE_E_ADVISENOTSUPPORTED);

}

STDMETHODIMP

QOleDataObject::EnumDAdvise(LPENUMSTATDATA FAR*)

{

    return ResultFromScode(OLE_E_ADVISENOTSUPPORTED);

}

#endif // QT_NO_DRAGANDDROP && QT_NO_CLIPBOARD

#ifndef QT_NO_DRAGANDDROP

//#define QDND_DEBUG

#ifdef QDND_DEBUG

extern QString dragActionsToString(Qt::DropActions actions);

#endif

Qt::DropActions translateToQDragDropActions(DWORD pdwEffects)

{

    Qt::DropActions actions = Qt::IgnoreAction;

    if (pdwEffects & DROPEFFECT_LINK)

        actions |= Qt::LinkAction;

    if (pdwEffects & DROPEFFECT_COPY)

        actions |= Qt::CopyAction;

    if (pdwEffects & DROPEFFECT_MOVE)

        actions |= Qt::MoveAction;

    return actions;

}

Qt::DropAction translateToQDragDropAction(DWORD pdwEffect)

{

    if (pdwEffect & DROPEFFECT_LINK)

        return Qt::LinkAction;

    if (pdwEffect & DROPEFFECT_COPY)

        return Qt::CopyAction;

    if (pdwEffect & DROPEFFECT_MOVE)

        return Qt::MoveAction;

    return Qt::IgnoreAction;

}

DWORD translateToWinDragEffects(Qt::DropActions action)

{

    DWORD effect = DROPEFFECT_NONE;

    if (action & Qt::LinkAction)

        effect |= DROPEFFECT_LINK;

    if (action & Qt::CopyAction)

        effect |= DROPEFFECT_COPY;

    if (action & Qt::MoveAction)

        effect |= DROPEFFECT_MOVE;

    return effect;

}

Qt::KeyboardModifiers toQtKeyboardModifiers(DWORD keyState)

{

    Qt::KeyboardModifiers modifiers = Qt::NoModifier;

    if (keyState & MK_SHIFT)

        modifiers |= Qt::ShiftModifier;

    if (keyState & MK_CONTROL)

        modifiers |= Qt::ControlModifier;

    if (keyState & MK_ALT)

        modifiers |= Qt::AltModifier;

    return modifiers;

}

Qt::MouseButtons toQtMouseButtons(DWORD keyState)

{

    Qt::MouseButtons buttons = Qt::NoButton;

    if (keyState & MK_LBUTTON)

        buttons |= Qt::LeftButton;

    if (keyState & MK_RBUTTON)

        buttons |= Qt::RightButton;

    if (keyState & MK_MBUTTON)

        buttons |= Qt::MidButton;

    return buttons;

}

class QOleDropSource : public IDropSource

{

public:

    QOleDropSource();

    virtual ~QOleDropSource();

    void createCursors();

    // IUnknown methods

    STDMETHOD(QueryInterface)(REFIID riid, void ** ppvObj);

    STDMETHOD_(ULONG,AddRef)(void);

    STDMETHOD_(ULONG,Release)(void);

    // IDropSource methods

    STDMETHOD(QueryContinueDrag)(BOOL fEscapePressed, DWORD grfKeyState);

    STDMETHOD(GiveFeedback)(DWORD dwEffect);

private:

    Qt::MouseButtons currentButtons;

    Qt::DropAction currentAction;

    QMap <Qt::DropAction, QCursor> cursors;

    ULONG m_refs;

};

QOleDropSource::QOleDropSource()

{

    currentButtons = Qt::NoButton;

    m_refs = 1;

    currentAction = Qt::IgnoreAction;

}

QOleDropSource::~QOleDropSource()

{

}

void QOleDropSource::createCursors()

{

    QDragManager *manager = QDragManager::self();

    if (manager && manager->object

        && (!manager->object->pixmap().isNull()

        || manager->hasCustomDragCursors())) {

        QPixmap pm = manager->object->pixmap();

        QList<Qt::DropAction> actions;

        actions << Qt::MoveAction << Qt::CopyAction << Qt::LinkAction;

        if (!manager->object->pixmap().isNull())

            actions << Qt::IgnoreAction;

        QPoint hotSpot = manager->object->hotSpot();

        for (int cnum = 0; cnum < actions.size(); ++cnum) {

            QPixmap cpm = manager->dragCursor(actions.at(cnum));

            int w = cpm.width();

            int h = cpm.height();

            if (!pm.isNull()) {

                int x1 = qMin(-hotSpot.x(), 0);

                int x2 = qMax(pm.width() - hotSpot.x(), cpm.width());

                int y1 = qMin(-hotSpot.y(), 0);

                int y2 = qMax(pm.height() - hotSpot.y(), cpm.height());

                w = x2 - x1 + 1;

                h = y2 - y1 + 1;

            }

            QRect srcRect = pm.rect();

            QPoint pmDest = QPoint(qMax(0, -hotSpot.x()), qMax(0, -hotSpot.y()));

            QPoint newHotSpot = hotSpot;

#if defined(Q_OS_WINCE)

            // Limited cursor size

            int reqw = GetSystemMetrics(SM_CXCURSOR);

            int reqh = GetSystemMetrics(SM_CYCURSOR);

            QPoint hotspotInPM = newHotSpot - pmDest;

            if (reqw < w) {

                // Not wide enough - move objectpm right

                qreal r = qreal(newHotSpot.x()) / w;

                newHotSpot = QPoint(int(r * reqw), newHotSpot.y());

                if (newHotSpot.x() + cpm.width() > reqw)

                    newHotSpot.setX(reqw - cpm.width());

                srcRect = QRect(QPoint(hotspotInPM.x() - newHotSpot.x(), srcRect.top()), QSize(reqw, srcRect.height()));

            }

            if (reqh < h) {

                qreal r = qreal(newHotSpot.y()) / h;

                newHotSpot = QPoint(newHotSpot.x(), int(r * reqh));

                if (newHotSpot.y() + cpm.height() > reqh)

                    newHotSpot.setY(reqh - cpm.height());

                srcRect = QRect(QPoint(srcRect.left(), hotspotInPM.y() - newHotSpot.y()), QSize(srcRect.width(), reqh));

            }

            // Always use system cursor size

            w = reqw;

            h = reqh;

#endif

            QPixmap newCursor(w, h);

            if (!pm.isNull()) {

                newCursor.fill(QColor(0, 0, 0, 0));

                QPainter p(&newCursor);

                p.drawPixmap(pmDest, pm, srcRect);

                p.drawPixmap(qMax(0,newHotSpot.x()),qMax(0,newHotSpot.y()),cpm);

            } else {

                newCursor = cpm;

            }

#ifndef QT_NO_CURSOR

            cursors[actions.at(cnum)] = QCursor(newCursor, pm.isNull() ? 0 : qMax(0,newHotSpot.x()),

                                                pm.isNull() ? 0 : qMax(0,newHotSpot.y()));

#endif

        }

    }

}

//---------------------------------------------------------------------

//                    IUnknown Methods

//---------------------------------------------------------------------

STDMETHODIMP

QOleDropSource::QueryInterface(REFIID iid, void FAR* FAR* ppv)

{

    if(iid == IID_IUnknown || iid == IID_IDropSource)

    {

      *ppv = this;

      ++m_refs;

      return NOERROR;

    }

    *ppv = NULL;

    return ResultFromScode(E_NOINTERFACE);

}

STDMETHODIMP_(ULONG)

QOleDropSource::AddRef(void)

{

    return ++m_refs;

}

STDMETHODIMP_(ULONG)

QOleDropSource::Release(void)

{

    if(--m_refs == 0)

    {

      delete this;

      return 0;

    }

    return m_refs;

}

static inline Qt::MouseButtons keystate_to_mousebutton(DWORD grfKeyState)

{

    Qt::MouseButtons result;

    if (grfKeyState & MK_LBUTTON)

        result |= Qt::LeftButton;

    if (grfKeyState & MK_MBUTTON)

        result |= Qt::MidButton;

    if (grfKeyState & MK_RBUTTON)

        result |= Qt::RightButton;

    if (grfKeyState & MK_XBUTTON1)

        result |= Qt::XButton1;

    if (grfKeyState & MK_XBUTTON2)

        result |= Qt::XButton2;

    return result;

}

//---------------------------------------------------------------------

//                    IDropSource Methods

//---------------------------------------------------------------------

STDMETHODIMP

QOleDropSource::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)

{

#ifdef QDND_DEBUG

    qDebug("QOleDropSource::QueryContinueDrag(fEscapePressed %d, grfKeyState %d)", fEscapePressed, grfKeyState);

#endif

    if (fEscapePressed) {

        return ResultFromScode(DRAGDROP_S_CANCEL);

    } else if (!(grfKeyState & (MK_LBUTTON|MK_MBUTTON|MK_RBUTTON))) {

        return ResultFromScode(DRAGDROP_S_DROP);