qdnd_mac.mm File Reference

#include "qapplication.h"
#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>
#include "qaccessible.h"
#include <private/qapplication_p.h>
#include <private/qwidget_p.h>
#include <private/qdnd_p.h>
#include <private/qt_mac_p.h>

Go to the source code of this file.

Classes
struct	mac_enum_mapper

Macros
#define	MAP_MAC_ENUM(x)   x

Functions
uint	qGlobalPostedEventsCount ()
void	qt_mac_copy_answer_rect (const QDragMoveEvent &event)
void	qt_mac_dispose_rgn (RgnHandle)
static Qt::DropActions	qt_mac_dnd_map_mac_actions (DragActions macActions)
static Qt::DropAction	qt_mac_dnd_map_mac_default_action (DragActions macActions)
static DragActions	qt_mac_dnd_map_qt_actions (Qt::DropActions qActions)
static void	qt_mac_dnd_update_action (DragReference dragRef)
RgnHandle	qt_mac_get_rgn ()
bool	qt_mac_mouse_inside_answer_rect (QPoint mouse)
void	qt_mac_send_modifiers_changed (quint32, QObject *)
static bool	qt_mac_set_existing_drop_action (const DragRef &dragRef, QDropEvent &event)

Variables
static const char *const	default_pm []
static const int	default_pm_hotx = -2
static const int	default_pm_hoty = -16
static mac_enum_mapper	dnd_action_symbols []
static DragReference	qt_mac_current_dragRef = 0
QMacDndAnswerRecord	qt_mac_dnd_answer_rec
bool	qt_mac_in_drag = false

Macro Definition Documentation

MAP_MAC_ENUM

#define MAP_MAC_ENUM

(

x

)

x

Definition at line 119 of file qdnd_mac.mm.

Function Documentation

qGlobalPostedEventsCount()

uint qGlobalPostedEventsCount

(

)

Definition at line 348 of file qcoreapplication.cpp.

Referenced by qt_mac_mouse_inside_answer_rect().

{
    QThreadData *currentThreadData = QThreadData::current();
    return currentThreadData->postEventList.size() - currentThreadData->postEventList.startOffset;
}

qt_mac_copy_answer_rect()

void qt_mac_copy_answer_rect

(

const QDragMoveEvent &

event

)

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.

Definition at line 318 of file qdnd_mac.mm.

Referenced by QMacDndAnswerRecord::clear(), and qt_mac_mouse_inside_answer_rect().

{
    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();
    }    
}

qt_mac_dispose_rgn()

void qt_mac_dispose_rgn

(

RgnHandle

)

qt_mac_dnd_map_mac_actions()

static Qt::DropActions qt_mac_dnd_map_mac_actions ( DragActions  macActions )

static

Definition at line 146 of file qdnd_mac.mm.

Referenced by qt_mac_dnd_map_mac_default_action(), qt_mac_dnd_update_action(), qt_mac_mouse_inside_answer_rect(), and qt_mac_set_existing_drop_action().

{
#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;
}

qt_mac_dnd_map_mac_default_action()

static Qt::DropAction qt_mac_dnd_map_mac_default_action ( DragActions  macActions )

static

Definition at line 162 of file qdnd_mac.mm.

Referenced by QDragManager::drag(), qt_mac_dnd_update_action(), and qt_mac_mouse_inside_answer_rect().

{
    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;
}

qt_mac_dnd_map_qt_actions()

static DragActions qt_mac_dnd_map_qt_actions ( Qt::DropActions  qActions )

static

Definition at line 137 of file qdnd_mac.mm.

Referenced by QDragManager::drag(), qt_mac_dnd_update_action(), and qt_mac_mouse_inside_answer_rect().

{
    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;
}

qt_mac_dnd_update_action()

static void qt_mac_dnd_update_action ( DragReference  dragRef )

static

Definition at line 184 of file qdnd_mac.mm.

Referenced by QDragManager::drag(), and qt_mac_mouse_inside_answer_rect().

                                                            {
    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);
    }
}

qt_mac_get_rgn()

RgnHandle qt_mac_get_rgn

(

)

qt_mac_mouse_inside_answer_rect()

bool qt_mac_mouse_inside_answer_rect

(

QPoint

mouse

)

Definition at line 328 of file qdnd_mac.mm.

Referenced by QMacDndAnswerRecord::clear(), and qt_mac_mouse_inside_answer_rect().

{
    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;
}

qt_mac_send_modifiers_changed()

void qt_mac_send_modifiers_changed	(	quint32	,
		QObject *
	)

Definition at line 199 of file qkeymapper_mac.cpp.

Referenced by QApplicationPrivate::globalEventProcessor(), qt_dispatchModifiersChanged(), qt_mac_dnd_update_action(), and QKeyMapperPrivate::translateKeyEvent().

{
    static quint32 cachedModifiers = 0;
    quint32 lastModifiers = cachedModifiers,
          changedModifiers = lastModifiers ^ modifiers;
    cachedModifiers = modifiers;

    //check the bits
    static qt_mac_enum_mapper modifier_key_symbols[] = {
        { shiftKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Shift) },
        { rightShiftKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Shift) }, //???
        { controlKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Meta) },
        { rightControlKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Meta) }, //???
        { cmdKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Control) },
        { optionKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Alt) },
        { rightOptionKeyBit, QT_MAC_MAP_ENUM(Qt::Key_Alt) }, //???
        { alphaLockBit, QT_MAC_MAP_ENUM(Qt::Key_CapsLock) },
        { kEventKeyModifierNumLockBit, QT_MAC_MAP_ENUM(Qt::Key_NumLock) },
        {   0, QT_MAC_MAP_ENUM(0) } };
    for (int i = 0; i <= 32; i++) { //just check each bit
        if (!(changedModifiers & (1 << i)))
            continue;
        QEvent::Type etype = QEvent::KeyPress;
        if (lastModifiers & (1 << i))
            etype = QEvent::KeyRelease;
        int key = 0;
        for (uint x = 0; modifier_key_symbols[x].mac_code; x++) {
            if (modifier_key_symbols[x].mac_code == i) {
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
                qDebug("got modifier changed: %s", modifier_key_symbols[x].desc);
#endif
                key = modifier_key_symbols[x].qt_code;
                break;
            }
        }
        if (!key) {
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
            qDebug("could not get modifier changed: %d", i);
#endif
            continue;
        }
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
        qDebug("KeyEvent (modif): Sending %s to %s::%s: %d - 0x%08x",
               etype == QEvent::KeyRelease ? "KeyRelease" : "KeyPress",
               object ? object->metaObject()->className() : "none",
               object ? object->objectName().toLatin1().constData() : "",
               key, (int)modifiers);
#endif
        QKeyEvent ke(etype, key, qt_mac_get_modifiers(modifiers ^ (1 << i)), QLatin1String(""));
        qt_sendSpontaneousEvent(object, &ke);
    }
}

qt_mac_set_existing_drop_action()

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

inlinestatic

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.

Definition at line 296 of file qdnd_mac.mm.

Referenced by qt_mac_mouse_inside_answer_rect().

{
#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;
}

Variable Documentation

default_pm

const char* const default_pm[]

static

Initial value:

= {
    "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",
}

Definition at line 98 of file qdnd_mac.mm.

Referenced by QDragManager::drag().

default_pm_hotx

const int default_pm_hotx = -2

static

Definition at line 95 of file qdnd_mac.mm.

Referenced by QDragManager::drag().

default_pm_hoty

const int default_pm_hoty = -16

static

Definition at line 96 of file qdnd_mac.mm.

Referenced by QDragManager::drag().

dnd_action_symbols

mac_enum_mapper dnd_action_symbols[]

static

Initial value:

= {
    { 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) }
}

Definition at line 130 of file qdnd_mac.mm.

qt_mac_current_dragRef

DragReference qt_mac_current_dragRef = 0

static

Definition at line 80 of file qdnd_mac.mm.

Referenced by QDropData::formats_sys(), QDropData::hasFormat_sys(), qt_mac_mouse_inside_answer_rect(), and QDropData::retrieveData_sys().

qt_mac_dnd_answer_rec

QMacDndAnswerRecord qt_mac_dnd_answer_rec

Definition at line 67 of file qdnd_mac.mm.

Referenced by QMacDndAnswerRecord::clear().

qt_mac_in_drag

bool qt_mac_in_drag = false

Definition at line 78 of file qdnd_mac.mm.

Referenced by QDragManager::drag().