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

**

** 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 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"

#ifndef QT_NO_DRAGANDDROP

#include "qbitmap.h"

#include "qcursor.h"

#include "qevent.h"

#include "qpainter.h"

#include "qurl.h"

#include "qwidget.h"

#include "qfile.h"

#include "qfileinfo.h"

#include <stdlib.h>

#include <string.h>

#ifndef QT_NO_ACCESSIBILITY

# include "qaccessible.h"

#endif

#include <private/qapplication_p.h>

#include <private/qwidget_p.h>

#include <private/qdnd_p.h>

#include <private/qt_mac_p.h>

QT_BEGIN_NAMESPACE

QT_USE_NAMESPACE

QMacDndAnswerRecord qt_mac_dnd_answer_rec; 

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

  QDnD debug facilities

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

//#define DEBUG_DRAG_EVENTS

//#define DEBUG_DRAG_PROMISES

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

  QDnD globals

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

bool qt_mac_in_drag = false;

#ifndef QT_MAC_USE_COCOA

static DragReference qt_mac_current_dragRef = 0;

#endif

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

  Externals

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

extern void qt_mac_send_modifiers_changed(quint32, QObject *); //qapplication_mac.cpp

extern uint qGlobalPostedEventsCount(); //qapplication.cpp

extern RgnHandle qt_mac_get_rgn(); // qregion_mac.cpp

extern void qt_mac_dispose_rgn(RgnHandle); // qregion_mac.cpp

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

  QDnD utility functions

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

//default pixmap

static const int default_pm_hotx = -2;

static const int default_pm_hoty = -16;

#ifndef QT_MAC_USE_COCOA

static const char * const default_pm[] = {

    "13 9 3 1",

    ".      c None",

    "       c #000000",

    "X      c #FFFFFF",

    "X X X X X X X",

    " X X X X X X ",

    "X ......... X",

    " X.........X ",

    "X ......... X",

    " X.........X ",

    "X ......... X",

    " X X X X X X ",

    "X X X X X X X",

};

#endif

//action management

#ifdef DEBUG_DRAG_EVENTS

# define MAP_MAC_ENUM(x) x, #x

#else

# define MAP_MAC_ENUM(x) x

#endif

struct mac_enum_mapper

{

    int mac_code;

    int qt_code;

#ifdef DEBUG_DRAG_EVENTS

    char *qt_desc;

#endif

};

#ifndef QT_MAC_USE_COCOA

static mac_enum_mapper dnd_action_symbols[] = {

    { kDragActionAlias, MAP_MAC_ENUM(Qt::LinkAction) },

    { kDragActionMove, MAP_MAC_ENUM(Qt::MoveAction) },

    { kDragActionGeneric, MAP_MAC_ENUM(Qt::CopyAction) },

    { kDragActionCopy, MAP_MAC_ENUM(Qt::CopyAction) },

    { 0, MAP_MAC_ENUM(0) }

};

static DragActions qt_mac_dnd_map_qt_actions(Qt::DropActions qActions)

{

    DragActions ret = kDragActionNothing;

    for(int i = 0; dnd_action_symbols[i].qt_code; ++i) {

        if(qActions & dnd_action_symbols[i].qt_code)

            ret |= dnd_action_symbols[i].mac_code;

    }

    return ret;

}

static Qt::DropActions qt_mac_dnd_map_mac_actions(DragActions macActions)

{

#ifdef DEBUG_DRAG_EVENTS

    qDebug("Converting DND ActionList: 0x%lx", macActions);

#endif

    Qt::DropActions ret = Qt::IgnoreAction;

    for(int i = 0; dnd_action_symbols[i].qt_code; ++i) {

#ifdef DEBUG_DRAG_EVENTS

        qDebug(" %d) [%s] : %s", i, dnd_action_symbols[i].qt_desc,

                (macActions & dnd_action_symbols[i].mac_code) ? "true" : "false");

#endif

        if(macActions & dnd_action_symbols[i].mac_code)

            ret |= Qt::DropAction(dnd_action_symbols[i].qt_code);

    }

    return ret;

}

static Qt::DropAction qt_mac_dnd_map_mac_default_action(DragActions macActions)

{

    static Qt::DropAction preferred_actions[] = { Qt::CopyAction, Qt::LinkAction, //in order

        Qt::MoveAction, Qt::IgnoreAction };

    Qt::DropAction ret = Qt::IgnoreAction;

    const Qt::DropActions qtActions = qt_mac_dnd_map_mac_actions(macActions);

    for(int i = 0; preferred_actions[i] != Qt::IgnoreAction; ++i) {

        if(qtActions & preferred_actions[i]) {

            ret = preferred_actions[i];

            break;

        }

    }

#ifdef DEBUG_DRAG_EVENTS

    for(int i = 0; dnd_action_symbols[i].qt_code; ++i) {

        if(dnd_action_symbols[i].qt_code == ret) {

            qDebug("Got default action: %s [0x%lx]", dnd_action_symbols[i].qt_desc, macActions);

            break;

        }

    }

#endif

    return ret;

}

static void qt_mac_dnd_update_action(DragReference dragRef) {

    SInt16 modifiers;

    GetDragModifiers(dragRef, &modifiers, 0, 0);

    qt_mac_send_modifiers_changed(modifiers, qApp);

    Qt::DropAction qtAction = Qt::IgnoreAction;

    {

        DragActions macAllowed = kDragActionNothing;

        GetDragDropAction(dragRef, &macAllowed);

        Qt::DropActions qtAllowed = qt_mac_dnd_map_mac_actions(macAllowed);

        qtAction = QDragManager::self()->defaultAction(qtAllowed, QApplication::keyboardModifiers());

#if 1

        if(!(qtAllowed & qtAction))

            qtAction = qt_mac_dnd_map_mac_default_action(macAllowed);

#endif

    }

    DragActions macAction = qt_mac_dnd_map_qt_actions(qtAction);

    DragActions currentActions;

    GetDragDropAction(dragRef, &currentActions);

    if(currentActions != macAction) {

        SetDragDropAction(dragRef, macAction);

        QDragManager::self()->emitActionChanged(qtAction);

    }

}

#endif // !QT_MAC_USE_COCOA

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

  DnD functions

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

bool QDropData::hasFormat_sys(const QString &mime) const

{

#ifndef QT_MAC_USE_COCOA

    OSPasteboardRef board;

    if(GetDragPasteboard(qt_mac_current_dragRef, &board) != noErr) {

        qDebug("DnD: Cannot get PasteBoard!");

        return false;

    }

    return QMacPasteboard(board, QMacPasteboardMime::MIME_DND).hasFormat(mime);

#else

    Q_UNUSED(mime);

    return false;

#endif // !QT_MAC_USE_COCOA

}

QVariant QDropData::retrieveData_sys(const QString &mime, QVariant::Type type) const

{

#ifndef QT_MAC_USE_COCOA

    OSPasteboardRef board;

    if(GetDragPasteboard(qt_mac_current_dragRef, &board) != noErr) {

        qDebug("DnD: Cannot get PasteBoard!");

        return QVariant();

    }

    return QMacPasteboard(board, QMacPasteboardMime::MIME_DND).retrieveData(mime, type);

#else

    Q_UNUSED(mime);

    Q_UNUSED(type);

    return QVariant();

#endif // !QT_MAC_USE_COCOA

}

QStringList QDropData::formats_sys() const

{

#ifndef QT_MAC_USE_COCOA

    OSPasteboardRef board;

    if(GetDragPasteboard(qt_mac_current_dragRef, &board) != noErr) {

        qDebug("DnD: Cannot get PasteBoard!");

        return QStringList();

    }

    return QMacPasteboard(board, QMacPasteboardMime::MIME_DND).formats();

#else

    return QStringList();

#endif

}

void QDragManager::timerEvent(QTimerEvent*)

{

}

bool QDragManager::eventFilter(QObject *, QEvent *)

{

    return false;

}

void QDragManager::updateCursor()

{

}

void QDragManager::cancel(bool)

{

    if(object) {

        beingCancelled = true;

        object = 0;

    }

#ifndef QT_NO_ACCESSIBILITY

    QAccessible::updateAccessibility(this, 0, QAccessible::DragDropEnd);

#endif

}

void QDragManager::move(const QPoint &)

{

}

void QDragManager::drop()

{

}

/**

    If a drop action is already set on the carbon event

    (from e.g. an earlier enter event), we insert the same

    action on the new Qt event that has yet to be sendt.

*/

static inline bool qt_mac_set_existing_drop_action(const DragRef &dragRef, QDropEvent &event)

{

#ifndef QT_MAC_USE_COCOA

    DragActions currentAction = kDragActionNothing;        

    OSStatus err = GetDragDropAction(dragRef, &currentAction);

    if (err == noErr && currentAction != kDragActionNothing) {

        // This looks a bit evil, but we only ever set one action, so it's OK.

        event.setDropAction(Qt::DropAction(int(qt_mac_dnd_map_mac_actions(currentAction))));

        return true;

    }

#else

    Q_UNUSED(dragRef);

    Q_UNUSED(event);

#endif

    return false;

}

/**

    If an answer rect has been set on the event (after being sent

    to the global event processor), we store that rect so we can

    check if the mouse is in the same area upon next drag move event. 

*/

void qt_mac_copy_answer_rect(const QDragMoveEvent &event)

{

    if (!event.answerRect().isEmpty()) {

        qt_mac_dnd_answer_rec.rect = event.answerRect();

        qt_mac_dnd_answer_rec.buttons = event.mouseButtons();

        qt_mac_dnd_answer_rec.modifiers = event.keyboardModifiers();

        qt_mac_dnd_answer_rec.lastAction = event.dropAction();

    }    

}

bool qt_mac_mouse_inside_answer_rect(QPoint mouse)

{

    if (!qt_mac_dnd_answer_rec.rect.isEmpty()

            && qt_mac_dnd_answer_rec.rect.contains(mouse)

            && QApplication::mouseButtons() == qt_mac_dnd_answer_rec.buttons

            && QApplication::keyboardModifiers() == qt_mac_dnd_answer_rec.modifiers)

        return true;

    else

        return false;

}

bool QWidgetPrivate::qt_mac_dnd_event(uint kind, DragRef dragRef)

{

#ifndef QT_MAC_USE_COCOA

    Q_Q(QWidget);

    qt_mac_current_dragRef = dragRef;

    if (kind != kEventControlDragLeave)

        qt_mac_dnd_update_action(dragRef);

    Point mouse;

    GetDragMouse(dragRef, &mouse, 0L);

    if(!mouse.h && !mouse.v)

        GetGlobalMouse(&mouse);

    if(QApplicationPrivate::modalState()) {

        for(QWidget *modal = q; modal; modal = modal->parentWidget()) {

            if(modal->isWindow()) {

                if(modal != QApplication::activeModalWidget())

                    return noErr;

                break;

            }

        }

    }

    //lookup the possible actions

    DragActions allowed = kDragActionNothing;

    GetDragAllowableActions(dragRef, &allowed);

    Qt::DropActions qtAllowed = qt_mac_dnd_map_mac_actions(allowed);

    //lookup the source dragAccepted 

    QMimeData *dropdata = QDragManager::self()->dropData;

    if(QDragManager::self()->source())

        dropdata = QDragManager::self()->dragPrivate()->data;

    // 'interrestedInDrag' should end up being 'true' if a later drop

    // will be accepted by the widget for the current mouse position 

    bool interrestedInDrag = true;

    //Dispatch events

    if (kind == kEventControlDragWithin) {

        if (qt_mac_mouse_inside_answer_rect(q->mapFromGlobal(QPoint(mouse.h, mouse.v))))

            return qt_mac_dnd_answer_rec.lastAction == Qt::IgnoreAction;

        else

            qt_mac_dnd_answer_rec.clear();

        QDragMoveEvent qDMEvent(q->mapFromGlobal(QPoint(mouse.h, mouse.v)), qtAllowed, dropdata,

                QApplication::mouseButtons(), QApplication::keyboardModifiers());

        // Accept the event by default if a

        // drag action exists on the carbon event

        if (qt_mac_set_existing_drop_action(dragRef, qDMEvent))

            qDMEvent.accept();

        QApplication::sendEvent(q, &qDMEvent);

        if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction)

            interrestedInDrag = false;

        qt_mac_copy_answer_rect(qDMEvent);

        SetDragDropAction(dragRef, qt_mac_dnd_map_qt_actions(qDMEvent.dropAction()));

    } else if (kind == kEventControlDragEnter) {

        qt_mac_dnd_answer_rec.clear();

        QDragEnterEvent qDEEvent(q->mapFromGlobal(QPoint(mouse.h, mouse.v)), qtAllowed, dropdata,

                QApplication::mouseButtons(), QApplication::keyboardModifiers());

        qt_mac_set_existing_drop_action(dragRef, qDEEvent);                         

        QApplication::sendEvent(q, &qDEEvent);

        SetDragDropAction(dragRef, qt_mac_dnd_map_qt_actions(qDEEvent.dropAction()));

        if (!qDEEvent.isAccepted())

            // The widget is simply not interested in this

            // drag. So tell carbon this by returning 'false'. We will then

            // not receive any further move, drop or leave events for this widget.

            return false;

        else {

            // Documentation states that a drag move event is sent immediately after

            // a drag enter event. So we do that. This will honor widgets overriding

            // 'dragMoveEvent' only, and not 'dragEnterEvent' 

            QDragMoveEvent qDMEvent(q->mapFromGlobal(QPoint(mouse.h, mouse.v)), qtAllowed, dropdata,

                    QApplication::mouseButtons(), QApplication::keyboardModifiers());

            qDMEvent.accept(); // accept by default, since enter event was accepted.

            qDMEvent.setDropAction(qDEEvent.dropAction());         

            QApplication::sendEvent(q, &qDMEvent);

            if (!qDMEvent.isAccepted() || qDMEvent.dropAction() == Qt::IgnoreAction)

                interrestedInDrag = false;

            qt_mac_copy_answer_rect(qDMEvent);           

            SetDragDropAction(dragRef, qt_mac_dnd_map_qt_actions(qDMEvent.dropAction()));

        }

    } else if(kind == kEventControlDragLeave) {

        QDragLeaveEvent de;

        QApplication::sendEvent(q, &de);

    } else if(kind == kEventControlDragReceive) {

        QDropEvent de(q->mapFromGlobal(QPoint(mouse.h, mouse.v)), qtAllowed, dropdata,

                      QApplication::mouseButtons(), QApplication::keyboardModifiers());

        if(QDragManager::self()->object)

            QDragManager::self()->dragPrivate()->target = q;

        QApplication::sendEvent(q, &de);

        if(!de.isAccepted()) {

            interrestedInDrag = false;

            SetDragDropAction(dragRef, kDragActionNothing);

        } else {

            if(QDragManager::self()->object)

                QDragManager::self()->dragPrivate()->executed_action = de.dropAction();

            SetDragDropAction(dragRef, qt_mac_dnd_map_qt_actions(de.dropAction()));

        }

    }

#ifdef DEBUG_DRAG_EVENTS

    {

        const char *desc = 0;

        switch(kind) {

        case kEventControlDragWithin: desc = "DragMove"; break;

        case kEventControlDragEnter: desc = "DragEnter"; break;

        case kEventControlDragLeave: desc = "DragLeave"; break;

        case kEventControlDragReceive: desc = "DragDrop"; break;

        }

        if(desc) {

            QPoint pos(q->mapFromGlobal(QPoint(mouse.h, mouse.v)));

            qDebug("Sending <%s>(%d, %d) event to %p(%s::%s) [%d] (%p)",

                   desc, pos.x(), pos.y(), q, q->metaObject()->className(),

                   q->objectName().toLocal8Bit().constData(), ret, dragRef);

        }

    }

#endif

    //set the cursor

    bool found_cursor = false;

    if(kind == kEventControlDragWithin || kind == kEventControlDragEnter) {

        ThemeCursor cursor = kThemeNotAllowedCursor;

        found_cursor = true;

        if (interrestedInDrag) {

            DragActions action = kDragActionNothing;

            GetDragDropAction(dragRef, &action);

            switch(qt_mac_dnd_map_mac_default_action(action)) {

            case Qt::IgnoreAction:

                cursor = kThemeNotAllowedCursor;

                break;

            case Qt::MoveAction:

                cursor = kThemeArrowCursor;

                break;

            case Qt::CopyAction:

                cursor = kThemeCopyArrowCursor;

                break;

            case Qt::LinkAction:

                cursor = kThemeAliasArrowCursor;

                break;

            default:

                cursor = kThemeNotAllowedCursor;

                break;

            }

        }

        SetThemeCursor(cursor);

    }

    if(found_cursor) {

        qt_mac_set_cursor(0, QPoint()); //just use our's

    } else {

        QCursor cursor(Qt::ArrowCursor);

        if(qApp && qApp->overrideCursor()) {

            cursor = *qApp->overrideCursor();

        } else if(q) {

            for(QWidget *p = q; p; p = p->parentWidget()) {

                if(p->isEnabled() && p->testAttribute(Qt::WA_SetCursor)) {

                    cursor = p->cursor();

                    break;

                }

            }

        }

        qt_mac_set_cursor(&cursor, QPoint(mouse.h, mouse.v));

    }

    //idle things

    if(qGlobalPostedEventsCount()) {

        QApplication::sendPostedEvents();

        QApplication::flush();

    }

    // If this was not a drop, tell carbon that we will be interresed in receiving more

    // events for the current drag. We do that by returning true. 

    if (kind == kEventControlDragReceive)

        return interrestedInDrag;

    else

        return true;

#else

    Q_UNUSED(kind);

    Q_UNUSED(dragRef);

    return false;

#endif // !QT_MAC_USE_COCOA

}

#ifndef QT_MAC_USE_COCOA