qkeymapper_mac.cpp File Reference

#include <private/qt_mac_p.h>
#include <qdebug.h>
#include <qevent.h>
#include <private/qevent_p.h>
#include <qtextcodec.h>
#include <qapplication.h>
#include <qinputcontext.h>
#include <private/qkeymapper_p.h>
#include <private/qapplication_p.h>
#include <private/qmacinputcontext_p.h>

Go to the source code of this file.

Classes
struct	KeyboardLayoutItem
struct	qt_mac_enum_mapper

Macros
#define	QT_MAC_MAP_ENUM(x)   x

Functions
static Boolean	qt_KeyEventComparatorProc (EventRef inEvent, void *data)
static int	qt_mac_get_key (int modif, const QChar &key, int virtualKey)
static int	qt_mac_get_mac_modifiers (Qt::KeyboardModifiers keys)
Qt::KeyboardModifiers	qt_mac_get_modifiers (int keys)
Q_GUI_EXPORT void	qt_mac_secure_keyboard (bool b)
void	qt_mac_send_modifiers_changed (quint32 modifiers, QObject *object)
bool	qt_sendSpontaneousEvent (QObject *obj, QEvent *event)
static bool	translateKeyEventInternal (EventHandlerCallRef er, EventRef keyEvent, int *qtKey, QChar *outChar, Qt::KeyboardModifiers *outModifiers, bool *outHandled)

Variables
static const Qt::KeyboardModifiers	ModsTbl []
bool	qt_mac_eat_unicode_key = false
static qt_mac_enum_mapper	qt_mac_keyboard_symbols []
static qt_mac_enum_mapper	qt_mac_keyvkey_symbols []
static qt_mac_enum_mapper	qt_mac_modifier_symbols []
static qt_mac_enum_mapper	qt_mac_private_unicode []

Macro Definition Documentation

QT_MAC_MAP_ENUM

#define QT_MAC_MAP_ENUM

(

x

)

x

Definition at line 134 of file qkeymapper_mac.cpp.

Referenced by qt_mac_send_modifiers_changed().

Function Documentation

qt_KeyEventComparatorProc()

static Boolean qt_KeyEventComparatorProc ( EventRef  inEvent, void *  data  )

static

Definition at line 428 of file qkeymapper_mac.cpp.

Referenced by QKeyMapperPrivate::translateKeyEvent().

{
    UInt32 ekind = GetEventKind(inEvent),
           eclass = GetEventClass(inEvent);
    return (eclass == kEventClassKeyboard && (void *)ekind == data);
}

qt_mac_get_key()

static int qt_mac_get_key ( int  modif, const QChar &  key, int  virtualKey  )

static

Definition at line 352 of file qkeymapper_mac.cpp.

Referenced by translateKeyEventInternal(), and QKeyMapperPrivate::updateKeyMap().

{
#ifdef DEBUG_KEY_BINDINGS
    qDebug("**Mapping key: %d (0x%04x) - %d (0x%04x)", key.unicode(), key.unicode(), virtualKey, virtualKey);
#endif

    if (key == kClearCharCode && virtualKey == 0x47)
        return Qt::Key_Clear;

    if (key.isDigit()) {
#ifdef DEBUG_KEY_BINDINGS
            qDebug("%d: got key: %d", __LINE__, key.digitValue());
#endif
        return key.digitValue() + Qt::Key_0;
    }

    if (key.isLetter()) {
#ifdef DEBUG_KEY_BINDINGS
        qDebug("%d: got key: %d", __LINE__, (key.toUpper().unicode() - 'A'));
#endif
        return (key.toUpper().unicode() - 'A') + Qt::Key_A;
    }
    if (key.isSymbol()) {
#ifdef DEBUG_KEY_BINDINGS
        qDebug("%d: got key: %d", __LINE__, (key.unicode()));
#endif
        return key.unicode();
    }

    for (int i = 0; qt_mac_keyboard_symbols[i].qt_code; i++) {
        if (qt_mac_keyboard_symbols[i].mac_code == key) {
            /* To work like Qt for X11 we issue Backtab when Shift + Tab are pressed */
            if (qt_mac_keyboard_symbols[i].qt_code == Qt::Key_Tab && (modif & Qt::ShiftModifier)) {
#ifdef DEBUG_KEY_BINDINGS
                qDebug("%d: got key: Qt::Key_Backtab", __LINE__);
#endif
                return Qt::Key_Backtab;
            }

#ifdef DEBUG_KEY_BINDINGS
            qDebug("%d: got key: %s", __LINE__, qt_mac_keyboard_symbols[i].desc);
#endif
            return qt_mac_keyboard_symbols[i].qt_code;
        }
    }

    //last ditch try to match the scan code
    for (int i = 0; qt_mac_keyvkey_symbols[i].qt_code; i++) {
        if (qt_mac_keyvkey_symbols[i].mac_code == virtualKey) {
#ifdef DEBUG_KEY_BINDINGS
            qDebug("%d: got key: %s", __LINE__, qt_mac_keyvkey_symbols[i].desc);
#endif
            return qt_mac_keyvkey_symbols[i].qt_code;
        }
    }

    // check if they belong to key codes in private unicode range
    if (key >= 0xf700 && key <= 0xf747) {
        if (key >= 0xf704 && key <= 0xf726) {
            return Qt::Key_F1 + (key.unicode() - 0xf704) ;
        }
        for (int i = 0; qt_mac_private_unicode[i].qt_code; i++) {
            if (qt_mac_private_unicode[i].mac_code == key) {
                return qt_mac_private_unicode[i].qt_code;
            }
        }

    }

    //oh well
#ifdef DEBUG_KEY_BINDINGS
    qDebug("Unknown case.. %s:%d %d[%d] %d", __FILE__, __LINE__, key.unicode(), key.toLatin1(), virtualKey);
#endif
    return Qt::Key_unknown;
}

qt_mac_get_mac_modifiers()

static int qt_mac_get_mac_modifiers ( Qt::KeyboardModifiers  keys )

static

Definition at line 174 of file qkeymapper_mac.cpp.

Referenced by QKeyMapperPrivate::updateKeyMap().

{
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
    qDebug("Qt: internal: **Mapping modifiers: %d (0x%04x)", (int)keys, (int)keys);
#endif
    int ret = 0;
    for (int i = 0; qt_mac_modifier_symbols[i].qt_code; i++) {
        if (keys & qt_mac_modifier_symbols[i].qt_code) {
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
            qDebug("Qt: internal: got modifier: %s", qt_mac_modifier_symbols[i].desc);
#endif
            ret |= qt_mac_modifier_symbols[i].mac_code;
        }
    }

    if (qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta)) {
        int oldModifiers = ret;
        ret &= ~(controlKeyBit | cmdKeyBit);
        if (oldModifiers & controlKeyBit)
            ret |= cmdKeyBit;
        if (oldModifiers & cmdKeyBit)
            ret |= controlKeyBit;
    }
    return ret;
}

qt_mac_get_modifiers()

Qt::KeyboardModifiers qt_mac_get_modifiers

(

int

keys

)

Definition at line 150 of file qkeymapper_mac.cpp.

Referenced by QApplicationPrivate::globalEventProcessor(), qt_mac_send_modifiers_changed(), QApplication::queryKeyboardModifiers(), and translateKeyEventInternal().

{
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
    qDebug("Qt: internal: **Mapping modifiers: %d (0x%04x)", keys, keys);
#endif
    Qt::KeyboardModifiers ret = Qt::NoModifier;
    for (int i = 0; qt_mac_modifier_symbols[i].qt_code; i++) {
        if (keys & qt_mac_modifier_symbols[i].mac_code) {
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
            qDebug("Qt: internal: got modifier: %s", qt_mac_modifier_symbols[i].desc);
#endif
            ret |= Qt::KeyboardModifier(qt_mac_modifier_symbols[i].qt_code);
        }
    }
    if (qApp->testAttribute(Qt::AA_MacDontSwapCtrlAndMeta)) {
        Qt::KeyboardModifiers oldModifiers = ret;
        ret &= ~(Qt::MetaModifier | Qt::ControlModifier);
        if (oldModifiers & Qt::ControlModifier)
            ret |= Qt::MetaModifier;
        if (oldModifiers & Qt::MetaModifier)
            ret |= Qt::ControlModifier;
    }
    return ret;
}

qt_mac_secure_keyboard()

Q_GUI_EXPORT void qt_mac_secure_keyboard

(

bool

b

)

Definition at line 70 of file qkeymapper_mac.cpp.

Referenced by QLineEdit::focusInEvent(), QLineEdit::focusOutEvent(), and QLineEdit::setEchoMode().

{
    static bool secure = false;
    if (b != secure){
        b ? EnableSecureEventInput() : DisableSecureEventInput();
        secure = b;
    }
}

qt_mac_send_modifiers_changed()

void qt_mac_send_modifiers_changed	(	quint32	modifiers,
		QObject *	object
	)

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_sendSpontaneousEvent()

bool qt_sendSpontaneousEvent	(	QObject *	obj,
		QEvent *	event
	)

Definition at line 5779 of file qapplication.cpp.

Referenced by qt_mac_send_modifiers_changed(), and QKeyMapper::sendKeyEvent().

{
    return QCoreApplication::sendSpontaneousEvent(receiver, event);
}

translateKeyEventInternal()

static bool translateKeyEventInternal ( EventHandlerCallRef  er, EventRef  keyEvent, int *  qtKey, QChar *  outChar, Qt::KeyboardModifiers *  outModifiers, bool *  outHandled  )

static

Definition at line 435 of file qkeymapper_mac.cpp.

Referenced by qt_keyrelease_scanner(), QKeyMapperPrivate::translateKeyEvent(), and translateKeySym().

{
#if !defined(QT_MAC_USE_COCOA) || defined(Q_OS_MAC64)
    Q_UNUSED(er);
    Q_UNUSED(outHandled);
#endif
    const UInt32 ekind = GetEventKind(keyEvent);
    {
        UInt32 mac_modifiers = 0;
        GetEventParameter(keyEvent, kEventParamKeyModifiers, typeUInt32, 0,
                          sizeof(mac_modifiers), 0, &mac_modifiers);
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
        qDebug("************ Mapping modifiers and key ***********");
#endif
        *outModifiers = qt_mac_get_modifiers(mac_modifiers);
#ifdef DEBUG_KEY_BINDINGS_MODIFIERS
        qDebug("------------ Mapping modifiers and key -----------");
#endif
    }

    //get keycode
    UInt32 keyCode = 0;
    GetEventParameter(keyEvent, kEventParamKeyCode, typeUInt32, 0, sizeof(keyCode), 0, &keyCode);

    //get mac mapping
    static UInt32 tmp_unused_state = 0L;
    const UCKeyboardLayout *uchrData = 0;
#if defined(Q_OS_MAC32)
    KeyboardLayoutRef keyLayoutRef = 0;
    KLGetCurrentKeyboardLayout(&keyLayoutRef);
    OSStatus err;
    if (keyLayoutRef != 0) {
        err = KLGetKeyboardLayoutProperty(keyLayoutRef, kKLuchrData,
                                  (reinterpret_cast<const void **>(&uchrData)));
        if (err != noErr) {
            qWarning("Qt::internal::unable to get keyboardlayout %ld %s:%d",
                     long(err), __FILE__, __LINE__);
        }
    }
#else
    QCFType<TISInputSourceRef> inputSource = TISCopyCurrentKeyboardInputSource();
    Q_ASSERT(inputSource != 0);
    CFDataRef data = static_cast<CFDataRef>(TISGetInputSourceProperty(inputSource,
                                                                 kTISPropertyUnicodeKeyLayoutData));
    uchrData = data ? reinterpret_cast<const UCKeyboardLayout *>(CFDataGetBytePtr(data)) : 0;
#endif
    *qtKey = Qt::Key_unknown;
    if (uchrData) {
        // The easy stuff; use the unicode stuff!
        UniChar string[4];
        UniCharCount actualLength;
        UInt32 currentModifiers = GetCurrentEventKeyModifiers();
        UInt32 currentModifiersWOAltOrControl = currentModifiers & ~(controlKey | optionKey);
        int keyAction;
        switch (ekind) {
        default:
        case kEventRawKeyDown:
            keyAction = kUCKeyActionDown;
            break;
        case kEventRawKeyUp:
            keyAction = kUCKeyActionUp;
            break;
        case kEventRawKeyRepeat:
            keyAction = kUCKeyActionAutoKey;
            break;
        }
        OSStatus err = UCKeyTranslate(uchrData, keyCode, keyAction,
                                  ((currentModifiersWOAltOrControl >> 8) & 0xff), LMGetKbdType(),
                                  kUCKeyTranslateNoDeadKeysMask, &tmp_unused_state, 4, &actualLength,
                                  string);
        if (err == noErr) {
            *outChar = QChar(string[0]);
            *qtKey = qt_mac_get_key(*outModifiers, *outChar, keyCode);
            if (currentModifiersWOAltOrControl != currentModifiers) {
                // Now get the real char.
                err = UCKeyTranslate(uchrData, keyCode, keyAction,
                                     ((currentModifiers >> 8) & 0xff), LMGetKbdType(),
                                      kUCKeyTranslateNoDeadKeysMask, &tmp_unused_state, 4, &actualLength,
                                      string);
                if (err == noErr)
                    *outChar = QChar(string[0]);
            }
        } else {
            qWarning("Qt::internal::UCKeyTranslate is returnining %ld %s:%d",
                     long(err), __FILE__, __LINE__);
        }
    }
#ifdef Q_OS_MAC32
    else {
        // The road less travelled; use KeyTranslate
        const void *keyboard_layout;
        KeyboardLayoutRef keyLayoutRef = 0;
        KLGetCurrentKeyboardLayout(&keyLayoutRef);
        err = KLGetKeyboardLayoutProperty(keyLayoutRef, kKLKCHRData,
                                  reinterpret_cast<const void **>(&keyboard_layout));

        int translatedChar = KeyTranslate(keyboard_layout, (GetCurrentEventKeyModifiers() &
                                                             (kEventKeyModifierNumLockMask|shiftKey|cmdKey|
                                                              rightShiftKey|alphaLock)) | keyCode,
                                           &tmp_unused_state);
        if (!translatedChar) {
#ifdef QT_MAC_USE_COCOA
            if (outHandled) {
                qt_mac_eat_unicode_key = false;
                if (er)
                    CallNextEventHandler(er, keyEvent);
                *outHandled = qt_mac_eat_unicode_key;
            }
#endif
            return false;
        }

        //map it into qt keys
        *qtKey = qt_mac_get_key(*outModifiers, QChar(translatedChar), keyCode);
        if (*outModifiers & (Qt::AltModifier | Qt::ControlModifier)) {
            if (translatedChar & (1 << 7)) //high ascii
                translatedChar = 0;
        } else {          //now get the real ascii value
            UInt32 tmp_mod = 0L;
            static UInt32 tmp_state = 0L;
            if (*outModifiers & Qt::ShiftModifier)
                tmp_mod |= shiftKey;
            if (*outModifiers & Qt::MetaModifier)
                tmp_mod |= controlKey;
            if (*outModifiers & Qt::ControlModifier)
                tmp_mod |= cmdKey;
            if (GetCurrentEventKeyModifiers() & alphaLock) //no Qt mapper
                tmp_mod |= alphaLock;
            if (*outModifiers & Qt::AltModifier)
                tmp_mod |= optionKey;
            if (*outModifiers & Qt::KeypadModifier)
                tmp_mod |= kEventKeyModifierNumLockMask;
            translatedChar = KeyTranslate(keyboard_layout, tmp_mod | keyCode, &tmp_state);
        }
        {
            ByteCount unilen = 0;
            if (GetEventParameter(keyEvent, kEventParamKeyUnicodes, typeUnicodeText, 0, 0, &unilen, 0)
                    == noErr && unilen == 2) {
                GetEventParameter(keyEvent, kEventParamKeyUnicodes, typeUnicodeText, 0, unilen, 0, outChar);
            } else if (translatedChar) {
                static QTextCodec *c = 0;
                if (!c)
                    c = QTextCodec::codecForName("Apple Roman");
        char tmpChar = (char)translatedChar; // **sigh**
                *outChar = c->toUnicode(&tmpChar, 1).at(0);
            } else {
                *qtKey = qt_mac_get_key(*outModifiers, QChar(translatedChar), keyCode);
            }
        }
    }
#endif
    if (*qtKey == Qt::Key_unknown)
        *qtKey = qt_mac_get_key(*outModifiers, *outChar, keyCode);
    return true;
}

Variable Documentation

ModsTbl

const Qt::KeyboardModifiers ModsTbl[]

static

Initial value:

= {
    Qt::NoModifier,                                             
    Qt::ShiftModifier,                                          
    Qt::ControlModifier,                                        
    Qt::ControlModifier | Qt::ShiftModifier,                    
    Qt::AltModifier,                                            
    Qt::AltModifier | Qt::ShiftModifier,                        
    Qt::AltModifier | Qt::ControlModifier,                      
    Qt::AltModifier | Qt::ShiftModifier | Qt::ControlModifier,  
    Qt::MetaModifier,                                           
    Qt::MetaModifier | Qt::ShiftModifier,                       
    Qt::MetaModifier | Qt::ControlModifier,                    
    Qt::MetaModifier | Qt::ControlModifier | Qt::ShiftModifier,
    Qt::MetaModifier | Qt::AltModifier,                        
    Qt::MetaModifier | Qt::AltModifier | Qt::ShiftModifier,    
    Qt::MetaModifier | Qt::AltModifier | Qt::ControlModifier,  
    Qt::MetaModifier | Qt::AltModifier | Qt::ShiftModifier | Qt::ControlModifier,  
}

Definition at line 106 of file qkeymapper_mac.cpp.

Referenced by QKeyMapperPrivate::possibleKeys(), and QKeyMapperPrivate::updateKeyMap().

qt_mac_eat_unicode_key

bool qt_mac_eat_unicode_key = false

Definition at line 67 of file qkeymapper_mac.cpp.

Referenced by QMacInputContext::globalEventProcessor(), QKeyMapperPrivate::translateKeyEvent(), and translateKeyEventInternal().

qt_mac_keyboard_symbols

qt_mac_enum_mapper qt_mac_keyboard_symbols[]

static

Definition at line 253 of file qkeymapper_mac.cpp.

qt_mac_keyvkey_symbols

qt_mac_enum_mapper qt_mac_keyvkey_symbols[]

static

Initial value:

= { 
    { 122, QT_MAC_MAP_ENUM(Qt::Key_F1) },
    { 120, QT_MAC_MAP_ENUM(Qt::Key_F2) },
    { 99,  QT_MAC_MAP_ENUM(Qt::Key_F3) },
    { 118, QT_MAC_MAP_ENUM(Qt::Key_F4) },
    { 96,  QT_MAC_MAP_ENUM(Qt::Key_F5) },
    { 97,  QT_MAC_MAP_ENUM(Qt::Key_F6) },
    { 98,  QT_MAC_MAP_ENUM(Qt::Key_F7) },
    { 100, QT_MAC_MAP_ENUM(Qt::Key_F8) },
    { 101, QT_MAC_MAP_ENUM(Qt::Key_F9) },
    { 109, QT_MAC_MAP_ENUM(Qt::Key_F10) },
    { 103, QT_MAC_MAP_ENUM(Qt::Key_F11) },
    { 111, QT_MAC_MAP_ENUM(Qt::Key_F12) },
    { 105, QT_MAC_MAP_ENUM(Qt::Key_F13) },
    { 107, QT_MAC_MAP_ENUM(Qt::Key_F14) },
    { 113, QT_MAC_MAP_ENUM(Qt::Key_F15) },
    { 106, QT_MAC_MAP_ENUM(Qt::Key_F16) },
    {   0, QT_MAC_MAP_ENUM(0) }
}

Definition at line 306 of file qkeymapper_mac.cpp.

qt_mac_modifier_symbols

qt_mac_enum_mapper qt_mac_modifier_symbols[]

static

Initial value:

= {
    { shiftKey, QT_MAC_MAP_ENUM(Qt::ShiftModifier) },
    { rightShiftKey, QT_MAC_MAP_ENUM(Qt::ShiftModifier) },
    { controlKey, QT_MAC_MAP_ENUM(Qt::MetaModifier) },
    { rightControlKey, QT_MAC_MAP_ENUM(Qt::MetaModifier) },
    { cmdKey, QT_MAC_MAP_ENUM(Qt::ControlModifier) },
    { optionKey, QT_MAC_MAP_ENUM(Qt::AltModifier) },
    { rightOptionKey, QT_MAC_MAP_ENUM(Qt::AltModifier) },
    { kEventKeyModifierNumLockMask, QT_MAC_MAP_ENUM(Qt::KeypadModifier) },
    { 0, QT_MAC_MAP_ENUM(0) }
}

Definition at line 139 of file qkeymapper_mac.cpp.

qt_mac_private_unicode

qt_mac_enum_mapper qt_mac_private_unicode[]

static

Initial value:

= {
    { 0xF700, QT_MAC_MAP_ENUM(Qt::Key_Up) },            
    { 0xF701, QT_MAC_MAP_ENUM(Qt::Key_Down) },          
    { 0xF702, QT_MAC_MAP_ENUM(Qt::Key_Left) },          
    { 0xF703, QT_MAC_MAP_ENUM(Qt::Key_Right) },         
    { 0xF727, QT_MAC_MAP_ENUM(Qt::Key_Insert) },        
    { 0xF728, QT_MAC_MAP_ENUM(Qt::Key_Delete) },        
    { 0xF729, QT_MAC_MAP_ENUM(Qt::Key_Home) },          
    { 0xF72B, QT_MAC_MAP_ENUM(Qt::Key_End) },           
    { 0xF72C, QT_MAC_MAP_ENUM(Qt::Key_PageUp) },        
    { 0xF72D, QT_MAC_MAP_ENUM(Qt::Key_PageDown) },      
    { 0xF72F, QT_MAC_MAP_ENUM(Qt::Key_ScrollLock) },    
    { 0xF730, QT_MAC_MAP_ENUM(Qt::Key_Pause) },         
    { 0xF731, QT_MAC_MAP_ENUM(Qt::Key_SysReq) },        
    { 0xF735, QT_MAC_MAP_ENUM(Qt::Key_Menu) },          
    { 0xF738, QT_MAC_MAP_ENUM(Qt::Key_Print) },         
    { 0xF73A, QT_MAC_MAP_ENUM(Qt::Key_Clear) },         
    { 0xF73D, QT_MAC_MAP_ENUM(Qt::Key_Insert) },        
    { 0xF73E, QT_MAC_MAP_ENUM(Qt::Key_Delete) },        
    { 0xF741, QT_MAC_MAP_ENUM(Qt::Key_Select) },        
    { 0xF742, QT_MAC_MAP_ENUM(Qt::Key_Execute) },       
    { 0xF746, QT_MAC_MAP_ENUM(Qt::Key_Help) },          
    { 0xF747, QT_MAC_MAP_ENUM(Qt::Key_Mode_switch) },   
    {   0,    QT_MAC_MAP_ENUM(0) }
}

Definition at line 326 of file qkeymapper_mac.cpp.