QWSKeyboardHandler Class Reference

The QWSKeyboardHandler class is a base class for keyboard drivers in Qt for Embedded Linux. More...

#include <qkbd_qws.h>

Inheritance diagram for QWSKeyboardHandler:

Public Types
enum	KeycodeAction {   None = 0, CapsLockOff = 0x01000000, CapsLockOn = 0x01000001, NumLockOff = 0x02000000,   NumLockOn = 0x02000001, ScrollLockOff = 0x03000000, ScrollLockOn = 0x03000001, Reboot = 0x04000000,   PreviousConsole = 0x05000000, NextConsole = 0x05000001, SwitchConsoleFirst = 0x06000000, SwitchConsoleLast = 0x0600007f,   SwitchConsoleMask = 0x0000007f }
	This enum describes the various special actions that actual QWSKeyboardHandler implementations have to take care of. More...

Public Functions
KeycodeAction	processKeycode (quint16 keycode, bool pressed, bool autorepeat)
	Maps keycode according to a keymap and sends that key event to the Qt for Embedded Linux server application. More...
virtual void	processKeyEvent (int unicode, int keycode, Qt::KeyboardModifiers modifiers, bool isPress, bool autoRepeat)
	Sends a key event to the Qt for Embedded Linux server application. More...
	QWSKeyboardHandler ()
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...
	QWSKeyboardHandler (const QString &device)
	Constructs a keyboard driver. More...
virtual	~QWSKeyboardHandler ()
	Destroys this keyboard driver. More...

Protected Functions
void	beginAutoRepeat (int uni, int code, Qt::KeyboardModifiers mod)
	Begins auto-repeating the specified key press; after a short delay the key press is sent periodically until the endAutoRepeat() function is called. More...
void	endAutoRepeat ()
	Stops auto-repeating a key press. More...
int	transformDirKey (int key)
	Transforms the arrow key specified by the given keycode, to the orientation of the display and returns the transformed keycode. More...

Properties
QWSKbPrivate *	d

Detailed Description

The QWSKeyboardHandler class is a base class for keyboard drivers in Qt for Embedded Linux.

Note that this class is only available in Qt for Embedded Linux.

Qt for Embedded Linux provides ready-made drivers for several keyboard protocols, see the Qt for Embedded Linux Character Input{character input} documentation for details. Custom keyboard drivers can be implemented by subclassing the QWSKeyboardHandler class and creating a keyboard driver plugin (derived from QKbdDriverPlugin). The default implementation of the QKbdDriverFactory class will automatically detect the plugin, and load the driver into the server application at run-time using Qt's How to Create Qt Plugins{plugin system}.

The keyboard driver receives keyboard events from the system device and encapsulates each event with an instance of the QWSEvent class which it then passes to the server application (the server is responsible for propagating the event to the appropriate client). To receive keyboard events, a QWSKeyboardHandler object will usually create a QSocketNotifier object for the given device. The QSocketNotifier class provides support for monitoring activity on a file descriptor. When the socket notifier receives data, it will call the keyboard driver's processKeyEvent() function to send the event to the Qt for Embedded Linux server application for relaying to clients.

QWSKeyboardHandler also provides functions to control auto-repetion of key sequences, beginAutoRepeat() and endAutoRepeat(), and the transformDirKey() function enabling transformation of arrow keys according to the display orientation.

See also

QKbdDriverPlugin, QKbdDriverFactory, {Qt for Embedded Linux Character Input}

Definition at line 57 of file qkbd_qws.h.

Enumerations

KeycodeAction

enum QWSKeyboardHandler::KeycodeAction

This enum describes the various special actions that actual QWSKeyboardHandler implementations have to take care of.

• None No further action required.

• CapsLockOn Set the state of the Caps lock LED to on.
• CapsLockOff Set the state of the Caps lock LED to off.
• NumLockOn Set the state of the Num lock LED to on.
• NumLockOff Set the state of the Num lock LED to off.
• ScrollLockOn Set the state of the Scroll lock LED to on.
• ScrollLockOff Set the state of the Scroll lock LED to off.

• PreviousConsole Switch to the previous virtual console (by default Ctrl+Alt+Left on Linux).
• NextConsole Switch to the next virtual console (by default Ctrl+Alt+Right on Linux).
• SwitchConsoleFirst Switch to the first virtual console (0).
• SwitchConsoleLast Switch to the last virtual console (255).
• SwitchConsoleMask If the KeyAction value is between SwitchConsoleFirst and SwitchConsoleLast, you can use this mask to get the specific virtual console number to switch to.

• Reboot Reboot the machine - this is ignored in both the TTY and LinuxInput handlers though (by default Ctrl+Alt+Del on Linux).

See also

processKeycode()

Enumerator
None
CapsLockOff
CapsLockOn
NumLockOff
NumLockOn
ScrollLockOff
ScrollLockOn
Reboot
PreviousConsole
NextConsole
SwitchConsoleFirst
SwitchConsoleLast
SwitchConsoleMask

Definition at line 67 of file qkbd_qws.h.

                       {
        None               = 0,

        CapsLockOff        = 0x01000000,
        CapsLockOn         = 0x01000001,
        NumLockOff         = 0x02000000,
        NumLockOn          = 0x02000001,
        ScrollLockOff      = 0x03000000,
        ScrollLockOn       = 0x03000001,

        Reboot             = 0x04000000,

        PreviousConsole    = 0x05000000,
        NextConsole        = 0x05000001,
        SwitchConsoleFirst = 0x06000000,
        SwitchConsoleLast  = 0x0600007f,
        SwitchConsoleMask  = 0x0000007f,
    };

Constructors and Destructors

QWSKeyboardHandler() [1/2]

QWSKeyboardHandler::QWSKeyboardHandler

(

)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 323 of file qkbd_qws.cpp.

{
    d = new QWSKbPrivate(this, QString());
}

QWSKeyboardHandler() [2/2]

QWSKeyboardHandler::QWSKeyboardHandler

(

const QString &

device

)

Constructs a keyboard driver.

The device argument is passed by the QWS_KEYBOARD environment variable.

Call the QWSServer::setKeyboardHandler() function to make the newly created keyboard driver, the primary driver. Note that the primary driver is controlled by the system, i.e., the system will delete it upon exit.

Definition at line 315 of file qkbd_qws.cpp.

{
    d = new QWSKbPrivate(this, device);
}

~QWSKeyboardHandler()

QWSKeyboardHandler::~QWSKeyboardHandler ( )

virtual

Destroys this keyboard driver.

Do not call this function if this driver is the primary keyboard handler, i.e., if QWSServer::setKeyboardHandler() function has been called passing this driver as argument. The primary keyboard driver is deleted by the system.

Definition at line 338 of file qkbd_qws.cpp.

{
    delete d;
}

Functions

beginAutoRepeat()

void QWSKeyboardHandler::beginAutoRepeat ( int  unicode, int  keycode, Qt::KeyboardModifiers  modifier  )

protected

Begins auto-repeating the specified key press; after a short delay the key press is sent periodically until the endAutoRepeat() function is called.

The key press is specified by its unicode, keycode and modifier state.

See also

endAutoRepeat(), processKeyEvent()

Definition at line 433 of file qkbd_qws.cpp.

{
    d->beginAutoRepeat(uni, code, mod);
}

endAutoRepeat()

void QWSKeyboardHandler::endAutoRepeat ( )

protected

Stops auto-repeating a key press.

See also

beginAutoRepeat(), processKeyEvent()

Definition at line 443 of file qkbd_qws.cpp.

{
    d->endAutoRepeat();
}

processKeycode()

QWSKeyboardHandler::KeycodeAction QWSKeyboardHandler::processKeycode	(	quint16	keycode,
		bool	isPress,
		bool	autoRepeat
	)

Maps keycode according to a keymap and sends that key event to the Qt for Embedded Linux server application.

Since

4.6

Please see the Qt for Embedded Linux Character Input and the kmap2qmap documentations for a description on how to create and use keymap files.

The key event is identified by its keycode value and the isPress and autoRepeat parameters.

The keycode parameter is NOT the Qt keycode value as defined by the Qt::Key enum. This functions expects a standard Linux 16 bit kernel keycode as it is used in the Linux Input Event sub-system. This keycode is transformed to a Qt::Key code by using either a compiled-in US keyboard layout or by dynamically loading a keymap at startup which can be specified via the QWS_KEYBOARD environment variable.

The isPress parameter is true if the event is a key press event and autoRepeat is true if the event is caused by an auto-repeat mechanism and not an actual key press.

The return value indicates if the actual QWSKeyboardHandler implementation needs to take care of a special action, like console switching or LED handling.

If standard Linux console keymaps are used, keycode must be one of the standardized values defined in /usr/include/linux/input.h

See also

processKeyEvent(), KeycodeAction

Definition at line 521 of file qkbd_qws.cpp.

Referenced by QWSLinuxInputKbPrivate::readKeycode(), QWSTtyKbPrivate::readKeycode(), and QLinuxInputKeyboardHandler::readKeycode().

{
    KeycodeAction result = None;
    bool first_press = pressed && !autorepeat;

    const QWSKeyboard::Mapping *map_plain = 0;
    const QWSKeyboard::Mapping *map_withmod = 0;

    // get a specific and plain mapping for the keycode and the current modifiers
    for (int i = 0; i < d->m_keymap_size && !(map_plain && map_withmod); ++i) {
        const QWSKeyboard::Mapping *m = d->m_keymap + i;
        if (m->keycode == keycode) {
            if (m->modifiers == 0)
                map_plain = m;

            quint8 testmods = d->m_modifiers;
            if (d->m_locks[0] /*CapsLock*/ && (m->flags & QWSKeyboard::IsLetter))
                testmods ^= QWSKeyboard::ModShift;
            if (m->modifiers == testmods)
                map_withmod = m;
        }
    }

#ifdef QT_DEBUG_KEYMAP
    qWarning("Processing key event: keycode=%3d, modifiers=%02x pressed=%d, autorepeat=%d  |  plain=%d, withmod=%d, size=%d", \
             keycode, d->m_modifiers, pressed ? 1 : 0, autorepeat ? 1 : 0, \
             map_plain ? map_plain - d->m_keymap : -1, \
             map_withmod ? map_withmod - d->m_keymap : -1, \
             d->m_keymap_size);
#endif

    const QWSKeyboard::Mapping *it = map_withmod ? map_withmod : map_plain;

    if (!it) {
#ifdef QT_DEBUG_KEYMAP
        // we couldn't even find a plain mapping
        qWarning("Could not find a suitable mapping for keycode: %3d, modifiers: %02x", keycode, d->m_modifiers);
#endif
        return result;
    }

    bool skip = false;
    quint16 unicode = it->unicode;
    quint32 qtcode = it->qtcode;

    if ((it->flags & QWSKeyboard::IsModifier) && it->special) {
        // this is a modifier, i.e. Shift, Alt, ...
        if (pressed)
            d->m_modifiers |= quint8(it->special);
        else
            d->m_modifiers &= ~quint8(it->special);
    } else if (qtcode >= Qt::Key_CapsLock && qtcode <= Qt::Key_ScrollLock) {
        // (Caps|Num|Scroll)Lock
        if (first_press) {
            quint8 &lock = d->m_locks[qtcode - Qt::Key_CapsLock];
            lock ^= 1;

            switch (qtcode) {
            case Qt::Key_CapsLock  : result = lock ? CapsLockOn : CapsLockOff; break;
            case Qt::Key_NumLock   : result = lock ? NumLockOn : NumLockOff; break;
            case Qt::Key_ScrollLock: result = lock ? ScrollLockOn : ScrollLockOff; break;
            default                : break;
            }
        }
    } else if ((it->flags & QWSKeyboard::IsSystem) && it->special && first_press) {
        switch (it->special) {
        case QWSKeyboard::SystemReboot:
            result = Reboot;
            break;

        case QWSKeyboard::SystemZap:
            if (!d->m_no_zap)
                qApp->quit();
            break;

        case QWSKeyboard::SystemConsolePrevious:
            result = PreviousConsole;
            break;

        case QWSKeyboard::SystemConsoleNext:
            result = NextConsole;
            break;

        default:
            if (it->special >= QWSKeyboard::SystemConsoleFirst &&
                it->special <= QWSKeyboard::SystemConsoleLast) {
                result = KeycodeAction(SwitchConsoleFirst + ((it->special & QWSKeyboard::SystemConsoleMask) & SwitchConsoleMask));
            }
            break;
        }

        skip = true; // no need to tell QWS about it
    } else if ((qtcode == Qt::Key_Multi_key) && d->m_do_compose) {
        // the Compose key was pressed
        if (first_press)
            d->m_composing = 2;
        skip = true;
    } else if ((it->flags & QWSKeyboard::IsDead) && d->m_do_compose) {
        // a Dead key was pressed
        if (first_press && d->m_composing == 1 && d->m_dead_unicode == unicode) { // twice
            d->m_composing = 0;
            qtcode = Qt::Key_unknown; // otherwise it would be Qt::Key_Dead...
        } else if (first_press && unicode != 0xffff) {
            d->m_dead_unicode = unicode;
            d->m_composing = 1;
            skip = true;
        } else {
            skip = true;
        }
    }

    if (!skip) {
        // a normal key was pressed
        const int modmask = Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier | Qt::KeypadModifier;

        // we couldn't find a specific mapping for the current modifiers,
        // or that mapping didn't have special modifiers:
        // so just report the plain mapping with additional modifiers.
        if ((it == map_plain && it != map_withmod) ||
            (map_withmod && !(map_withmod->qtcode & modmask))) {
            qtcode |= QWSKbPrivate::toQtModifiers(d->m_modifiers);
        }

        if (d->m_composing == 2 && first_press && !(it->flags & QWSKeyboard::IsModifier)) {
            // the last key press was the Compose key
            if (unicode != 0xffff) {
                int idx = 0;
                // check if this code is in the compose table at all
                for ( ; idx < d->m_keycompose_size; ++idx) {
                    if (d->m_keycompose[idx].first == unicode)
                        break;
                }
                if (idx < d->m_keycompose_size) {
                    // found it -> simulate a Dead key press
                    d->m_dead_unicode = unicode;
                    unicode = 0xffff;
                    d->m_composing = 1;
                    skip = true;
                } else {
                    d->m_composing = 0;
                }
            } else {
                d->m_composing = 0;
            }
        } else if (d->m_composing == 1 && first_press && !(it->flags & QWSKeyboard::IsModifier)) {
            // the last key press was a Dead key
            bool valid = false;
            if (unicode != 0xffff) {
                int idx = 0;
                // check if this code is in the compose table at all
                for ( ; idx < d->m_keycompose_size; ++idx) {
                    if (d->m_keycompose[idx].first == d->m_dead_unicode && d->m_keycompose[idx].second == unicode)
                        break;
                }
                if (idx < d->m_keycompose_size) {
                    quint16 composed = d->m_keycompose[idx].result;
                    if (composed != 0xffff) {
                        unicode = composed;
                        qtcode = Qt::Key_unknown;
                        valid = true;
                    }
                }
            }
            if (!valid) {
                unicode = d->m_dead_unicode;
                qtcode = Qt::Key_unknown;
            }
            d->m_composing = 0;
        }

        if (!skip) {
#ifdef QT_DEBUG_KEYMAP
            qWarning("Processing: uni=%04x, qt=%08x, qtmod=%08x", unicode, qtcode & ~modmask, (qtcode & modmask));
#endif

            // send the result to the QWS server
            processKeyEvent(unicode, qtcode & ~modmask, Qt::KeyboardModifiers(qtcode & modmask), pressed, autorepeat);
        }
    }
    return result;
}

processKeyEvent()

void QWSKeyboardHandler::processKeyEvent ( int  unicode, int  keycode, Qt::KeyboardModifiers  modifiers, bool  isPress, bool  autoRepeat  )

virtual

Sends a key event to the Qt for Embedded Linux server application.

The key event is identified by its unicode value and the keycode, modifiers, isPress and autoRepeat parameters.

The keycode parameter is the Qt keycode value as defined by the Qt::Key enum. The modifiers is an OR combination of Qt::KeyboardModifier values, indicating whether Shift/Alt/Ctrl keys are pressed. The isPress parameter is true if the event is a key press event and autoRepeat is true if the event is caused by an auto-repeat mechanism and not an actual key press.

Note that this function does not handle key mapping. Please use processKeycode() if you need that functionality.

See also

processKeycode(), beginAutoRepeat(), endAutoRepeat(), transformDirKey()

Definition at line 363 of file qkbd_qws.cpp.

Referenced by QWSKbPrivate::autoRepeat(), processKeycode(), QDirectFBKeyboardHandlerPrivate::readKeyboardData(), and QWSQnxKeyboardHandler::socketActivated().

{
#if defined(Q_WS_QWS)
    qwsServer->processKeyEvent(unicode, keycode, modifiers, isPress, autoRepeat);
#elif defined(Q_WS_QPA)
    QEvent::Type type = isPress ? QEvent::KeyPress : QEvent::KeyRelease;
    QString str;
    if (unicode != 0xffff)
        str = QString(unicode);
    QWindowSystemInterface::handleKeyEvent(0, type, keycode, modifiers, str, autoRepeat);
#endif
}

transformDirKey()

int QWSKeyboardHandler::transformDirKey ( int  keycode )

protected

Transforms the arrow key specified by the given keycode, to the orientation of the display and returns the transformed keycode.

The keycode is a Qt::Key value. The values identifying arrow keys are:

• Qt::Key_Left
• Qt::Key_Up
• Qt::Key_Right
• Qt::Key_Down

See also

processKeyEvent()

Definition at line 398 of file qkbd_qws.cpp.

{
#ifdef Q_WS_QWS
    static int dir_keyrot = -1;
    if (dir_keyrot < 0) {
        // get the rotation
        switch (qgetenv("QWS_CURSOR_ROTATION").toInt()) {
        case 90: dir_keyrot = 1; break;
        case 180: dir_keyrot = 2; break;
        case 270: dir_keyrot = 3; break;
        default: dir_keyrot = 0; break;
        }
    }
    int xf = qt_screen->transformOrientation() + dir_keyrot;
    return (key-Qt::Key_Left+xf)%4+Qt::Key_Left;
#else
    return 0;
#endif
}

Properties

d

QWSKbPrivate* QWSKeyboardHandler::d

private

Definition at line 94 of file qkbd_qws.h.

---

The documentation for this class was generated from the following files:

• /src/gui/embedded/qkbd_qws.h
• /src/gui/embedded/qkbd_qws.cpp