Keymap support for QWS.

This patch adds support for keymaps to the QWSKeyboardHandler. The keymaps
can be generated by the kmap2qmap tool (see tools/ directory). The source
keymaps can be standard Linux .kmap files.

Changes to Qt:
 * completely refactored the Tty and Usb (now known as LinuxInput) handlers
 * removed the LinuxIS plugin (handled by LinuxInput now)
 * removed support for iPAQ, EBX and Zylonite keypads (obsolete hardware)
 * removed support for RAW tty mode. This could be re-added, for non-Linux
   systems by implementing a PC/AT scan-code to Linux keycode converter.

New features for Tty and LinuxInput (ex Usb) handlers:
 * support for keymaps
   QWS_KEYBOARD=..:keymap=/path/to/x.qmap:..
 * support for dead keys and the compose key
 * support for lock LEDs
 * support for key repeat rates (in ms):
   QWS_KEYBOARD=..:repeat-delay=x:repear-rate=y:..
 * the default keymap supports latin1 composing via AltGr:
   QWS_KEYBOARD=..:enable-compose:..
 * ctrl+alt+backspace application zapping can be disabled:
   QWS_KEYBOARD=..:disable-zap:..
 * added virtual filter functions to both the Tty and the LinuxInput
   handlers. (QWSKeyboardHandler::processKeycode should be virtual in the
   first place, but that would be BIC)

Still missing:
 * extended documentation for QWS_KEYBOARD

Reviewed-By: Paul Olav Tvete
Reviewed-By: Harald Fernengel

1 files changed, 193 insertions, 108 deletions

diff --git a/src/gui/embedded/qkbdtty_qws.cpp b/src/gui/embedded/qkbdtty_qws.cpp
index b588e55..37ed510 100644
--- a/src/gui/embedded/qkbdtty_qws.cpp
+++ b/src/gui/embedded/qkbdtty_qws.cpp
@@ -43,64 +43,57 @@
 
 #if !defined(QT_NO_QWS_KEYBOARD) && !defined(QT_NO_QWS_KBD_TTY)
 
-#include "qscreen_qws.h"
-
-#include "qwindowsystem_qws.h"
-#include "qapplication.h"
-#include "qsocketnotifier.h"
-#include "qnamespace.h"
-#include "qtimer.h"
-#include <private/qwssignalhandler_p.h>
-#include <private/qwindowsurface_qws_p.h>
-
-#include <unistd.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <signal.h>
-#include <termios.h>
+#include <QSocketNotifier>
+#include <QStringList>
 
-#include <qeventloop.h>
+#include <qplatformdefs.h>
 
-#ifdef Q_OS_LINUX
-#include <sys/kd.h>
-#include <sys/vt.h>
-#endif
+#include <errno.h>
+#include <termios.h>
 
-QT_BEGIN_NAMESPACE
+#if defined Q_OS_LINUX
+#  include <linux/kd.h>
+#  include <linux/vt.h> //TODO: move vt handling somewhere else (QLinuxFbScreen?)
 
-#define VTACQSIG SIGUSR1
-#define VTRELSIG SIGUSR2
+#  include "qscreen_qws.h"
+#  include "qwindowsystem_qws.h"
+#  include "qapplication.h"
+#  include "private/qwindowsurface_qws_p.h"
+#  include "private/qwssignalhandler_p.h"
 
-static int  vtQws = 0;
-static int  kbdFD = -1;
+#  define VTACQSIG SIGUSR1
+#  define VTRELSIG SIGUSR2
+#endif
 
-//===========================================================================
 
-//
-// Tty keyboard
-//
+QT_BEGIN_NAMESPACE
 
 class QWSTtyKbPrivate : public QObject
 {
     Q_OBJECT
 public:
-    QWSTtyKbPrivate(QWSPC101KeyboardHandler *, const QString &device);
+    QWSTtyKbPrivate(QWSTtyKeyboardHandler *handler, const QString &device);
     ~QWSTtyKbPrivate();
 
-private slots:
-    void readKeyboardData();
-    void handleTtySwitch(int);
+private:
+    void switchLed(char, bool);
+    void switchConsole(int vt);
+
+private Q_SLOTS:
+    void readKeycode();
+    void handleConsoleSwitch(int sig);
 
 private:
-    QWSPC101KeyboardHandler *handler;
-    struct termios origTermData;
+    QWSTtyKeyboardHandler *m_handler;
+    int                    m_tty_fd;
+    struct termios         m_tty_attr;
+    char                   m_last_keycode;
+    int                    m_vt_qws;
 };
 
+
 QWSTtyKeyboardHandler::QWSTtyKeyboardHandler(const QString &device)
-    : QWSPC101KeyboardHandler(device)
+    : QWSKeyboardHandler(device)
 {
     d = new QWSTtyKbPrivate(this, device);
 }
@@ -110,59 +103,63 @@ QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler()
     delete d;
 }
 
-void QWSTtyKeyboardHandler::processKeyEvent(int unicode, int keycode,
-                                            Qt::KeyboardModifiers modifiers, bool isPress,
-                                            bool autoRepeat)
+bool QWSTtyKeyboardHandler::filterKeycode(char &)
 {
-#if defined(Q_OS_LINUX)
-    // Virtual console switching
-    int term = 0;
-    bool ctrl = modifiers & Qt::ControlModifier;
-    bool alt = modifiers & Qt::AltModifier;
-    if (ctrl && alt && keycode >= Qt::Key_F1 && keycode <= Qt::Key_F10)
-        term = keycode - Qt::Key_F1 + 1;
-    else if (ctrl && alt && keycode == Qt::Key_Left)
-        term = qMax(vtQws - 1, 1);
-    else if (ctrl && alt && keycode == Qt::Key_Right)
-        term = qMin(vtQws + 1, 10);
-    if (term && isPress) {
-        ioctl(kbdFD, VT_ACTIVATE, term);
-        return;
-    }
-#endif
-
-    QWSPC101KeyboardHandler::processKeyEvent(unicode, keycode, modifiers,
-        isPress, autoRepeat);
+    return false;
 }
 
-
-QWSTtyKbPrivate::QWSTtyKbPrivate(QWSPC101KeyboardHandler *h, const QString &device) : handler(h)
+QWSTtyKbPrivate::QWSTtyKbPrivate(QWSTtyKeyboardHandler *h, const QString &device)
+    : m_handler(h), m_tty_fd(-1), m_last_keycode(0), m_vt_qws(0)
 {
-    kbdFD = ::open(device.isEmpty()?"/dev/tty0":device.toLatin1().constData(), O_RDWR|O_NDELAY, 0);
+    setObjectName(QLatin1String("TTY Keyboard Handler"));
 #ifndef QT_NO_QWS_SIGNALHANDLER
     QWSSignalHandler::instance()->addObject(this);
 #endif
 
-    if (kbdFD >= 0) {
+    QString dev = QLatin1String("/dev/tty0");
+    int repeat_delay = -1;
+    int repeat_rate = -1;
+
+    QStringList args = device.split(QLatin1Char(':'));
+    foreach (const QString &arg, args) {
+        if (arg.startsWith(QLatin1String("repeat_delay=")))
+            repeat_delay = arg.mid(13).toInt();
+        else if (arg.startsWith(QLatin1String("repeat_rate=")))
+            repeat_rate = arg.mid(12).toInt();
+        else if (arg.startsWith(QLatin1String("/dev/")))
+            dev = arg;
+    }
+
+    m_tty_fd = QT_OPEN(dev.toLocal8Bit().constData(), O_RDWR, 0);
+    if (m_tty_fd >= 0) {
+        if (repeat_delay > 0 && repeat_rate > 0) {
+#if defined(Q_OS_LINUX)
+            struct ::kbd_repeat kbdrep = { repeat_delay, repeat_rate };
+            ::ioctl(m_tty_fd, KDKBDREP, &kbdrep);
+#endif
+        }
+
         QSocketNotifier *notifier;
-        notifier = new QSocketNotifier(kbdFD, QSocketNotifier::Read, this);
-        connect(notifier, SIGNAL(activated(int)),this,
-                 SLOT(readKeyboardData()));
+        notifier = new QSocketNotifier(m_tty_fd, QSocketNotifier::Read, this);
+        connect(notifier, SIGNAL(activated(int)), this, SLOT(readKeycode()));
 
-        // save for restore.
-        tcgetattr(kbdFD, &origTermData);
+        // save tty config for restore.
+        tcgetattr(m_tty_fd, &m_tty_attr);
 
-        struct termios termdata;
-        tcgetattr(kbdFD, &termdata);
+        struct ::termios termdata;
+        tcgetattr(m_tty_fd, &termdata);
 
 #if defined(Q_OS_LINUX)
-# ifdef QT_QWS_USE_KEYCODES
-        ioctl(kbdFD, KDSKBMODE, K_MEDIUMRAW);
-# else
-        ioctl(kbdFD, KDSKBMODE, K_RAW);
-# endif
+        // PLEASE NOTE:
+        // The tty keycode interface can only report keycodes 0x01 .. 0x7f
+        // KEY_MAX is however defined to 0x1ff. In practice this is sufficient
+        // for a PC style keyboard though.
+        // we don't support K_RAW anymore - if you need, you habe to add a
+        // scan- to keycode converter.
+        ::ioctl(m_tty_fd, KDSKBMODE, K_MEDIUMRAW);
 #endif
 
+        // set the tty layer to pass-through
         termdata.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
         termdata.c_oflag = 0;
         termdata.c_cflag = CREAD | CS8;
@@ -171,50 +168,146 @@ QWSTtyKbPrivate::QWSTtyKbPrivate(QWSPC101KeyboardHandler *h, const QString &devi
         termdata.c_cc[VMIN]=1;
         cfsetispeed(&termdata, 9600);
         cfsetospeed(&termdata, 9600);
-        tcsetattr(kbdFD, TCSANOW, &termdata);
+        tcsetattr(m_tty_fd, TCSANOW, &termdata);
 
 #if defined(Q_OS_LINUX)
-
-        connect(QApplication::instance(), SIGNAL(unixSignal(int)), this, SLOT(handleTtySwitch(int)));
+        // VT switching is handled via unix signals
+        connect(QApplication::instance(), SIGNAL(unixSignal(int)), this, SLOT(handleConsoleSwitch(int)));
         QApplication::instance()->watchUnixSignal(VTACQSIG, true);
         QApplication::instance()->watchUnixSignal(VTRELSIG, true);
 
-        struct vt_mode vtMode;
-        ioctl(kbdFD, VT_GETMODE, &vtMode);
+        struct ::vt_mode vtMode;
+        if (::ioctl(m_tty_fd, VT_GETMODE, &vtMode) == 0) {
+            vtMode.mode = VT_PROCESS;
+            vtMode.relsig = VTRELSIG;
+            vtMode.acqsig = VTACQSIG;
 
-        // let us control VT switching
-        vtMode.mode = VT_PROCESS;
-        vtMode.relsig = VTRELSIG;
-        vtMode.acqsig = VTACQSIG;
-        ioctl(kbdFD, VT_SETMODE, &vtMode);
+            if (::ioctl(m_tty_fd, VT_SETMODE, &vtMode) == 0) {
+                struct ::vt_stat vtStat;
+                ::memset(&vtStat, 0, sizeof(vtStat));
 
-        struct vt_stat vtStat;
-        ioctl(kbdFD, VT_GETSTATE, &vtStat);
-        vtQws = vtStat.v_active;
+                if (::ioctl(m_tty_fd, VT_GETSTATE, &vtStat) == 0 ) {
+                    m_vt_qws = vtStat.v_active;
+                }
+            }
+        }
+
+        if (!m_vt_qws)
+            qWarning("Could not initialize virtual console switching");
 #endif
     } else {
-        qCritical("Cannot open keyboard: %s", strerror(errno));
+        qWarning("Cannot open input device '%s': %s", qPrintable(dev), strerror(errno));
+        return;
     }
 
 }
 
 QWSTtyKbPrivate::~QWSTtyKbPrivate()
 {
-    if (kbdFD >= 0) {
+    if (m_tty_fd >= 0) {
 #if defined(Q_OS_LINUX)
-        ioctl(kbdFD, KDSKBMODE, K_XLATE);
+        ::ioctl(m_tty_fd, KDSKBMODE, K_XLATE);
 #endif
-        tcsetattr(kbdFD, TCSANOW, &origTermData);
-        ::close(kbdFD);
-        kbdFD = -1;
+        tcsetattr(m_tty_fd, TCSANOW, &m_tty_attr);
     }
 }
 
-void QWSTtyKbPrivate::handleTtySwitch(int sig)
+
+
+void QWSTtyKbPrivate::switchLed(char led, bool state)
 {
 #if defined(Q_OS_LINUX)
+    char ledstate;
+
+    ::ioctl(m_tty_fd, KDGETLED, &ledstate);
+    if (state)
+        ledstate |= led;
+    else
+        ledstate &= ~led;
+    ::ioctl(m_tty_fd, KDSETLED, ledstate);
+#endif
+}
+
+void QWSTtyKbPrivate::readKeycode()
+{
+    char buffer[32];
+    int n = 0;
+
+    forever {
+        n = QT_READ(m_tty_fd, buffer + n, 32 - n);
+
+        if (n == 0) {
+            qWarning("Got EOF from the input device.");
+            return;
+        } else if (n < 0 && (errno != EINTR && errno != EAGAIN)) {
+            qWarning("Could not read from input device: %s", strerror(errno));
+            return;
+        } else {
+            break;
+        }
+    }
+
+    for (int i = 0; i < n; ++i) {
+        if (m_handler->filterKeycode(buffer[i]))
+            continue;
+
+        QWSKeyboardHandler::KeycodeAction ka;
+        ka = m_handler->processKeycode(buffer[i] & 0x7f, (buffer[i] & 0x80) == 0x00, buffer[i] == m_last_keycode);
+        m_last_keycode = buffer[i];
+
+qWarning("Special: %08x", ka);
+        switch (ka) {
+        case QWSKeyboardHandler::CapsLockOn:
+        case QWSKeyboardHandler::CapsLockOff:
+            switchLed(LED_CAP, ka == QWSKeyboardHandler::CapsLockOn);
+            break;
+
+        case QWSKeyboardHandler::NumLockOn:
+        case QWSKeyboardHandler::NumLockOff:
+            switchLed(LED_NUM, ka == QWSKeyboardHandler::NumLockOn);
+            break;
+
+        case QWSKeyboardHandler::ScrollLockOn:
+        case QWSKeyboardHandler::ScrollLockOff:
+            switchLed(LED_SCR, ka == QWSKeyboardHandler::ScrollLockOn);
+            break;
+
+        case QWSKeyboardHandler::PreviousConsole:
+            switchConsole(qBound(1, m_vt_qws - 1, 10));
+            break;
+
+        case QWSKeyboardHandler::NextConsole:
+            switchConsole(qBound(1, m_vt_qws + 1, 10));
+            break;
+
+        default:
+            if (ka >= QWSKeyboardHandler::SwitchConsoleFirst &&
+                ka <= QWSKeyboardHandler::SwitchConsoleLast) {
+                switchConsole(1 + (ka & QWSKeyboardHandler::SwitchConsoleMask));
+            }
+            //ignore reboot
+            break;
+        }
+    }
+}
+
+
+void QWSTtyKbPrivate::switchConsole(int vt)
+{
+#if defined(Q_OS_LINUX)
+    if (m_vt_qws && vt && (m_tty_fd >= 0 ))
+        ::ioctl(m_tty_fd, VT_ACTIVATE, vt);
+#endif
+}
+
+void QWSTtyKbPrivate::handleConsoleSwitch(int sig)
+{
+#if defined(Q_OS_LINUX)
+    // received a notification from the kernel that the current VT is
+    // changing: either enable or disable QWS painting accordingly.
+
     if (sig == VTACQSIG) {
-        if (ioctl(kbdFD, VT_RELDISP, VT_ACKACQ) == 0) {
+        if (::ioctl(m_tty_fd, VT_RELDISP, VT_ACKACQ) == 0) {
             qwsServer->enablePainting(true);
             qt_screen->restore();
             qwsServer->resumeMouse();
@@ -236,9 +329,9 @@ void QWSTtyKbPrivate::handleTtySwitch(int sig)
         }
 
         if (!allWindowsHidden) {
-            ioctl(kbdFD, VT_RELDISP, 0); // abort console switch
+            ::ioctl(m_tty_fd, VT_RELDISP, 0); // abort console switch
             qwsServer->enablePainting(true);
-        } else if (ioctl(kbdFD, VT_RELDISP, 1) == 0) {
+        } else if (::ioctl(m_tty_fd, VT_RELDISP, 1) == 0) {
             qt_screen->save();
             qwsServer->suspendMouse();
         } else {
@@ -248,14 +341,6 @@ void QWSTtyKbPrivate::handleTtySwitch(int sig)
 #endif
 }
 
-void QWSTtyKbPrivate::readKeyboardData()
-{
-    unsigned char buf[81];
-    int n = read(kbdFD, buf, 80);
-    for (int loop = 0; loop < n; loop++)
-        handler->doKey(buf[loop]);
-}
-
 QT_END_NAMESPACE
 
 #include "qkbdtty_qws.moc"