Qt 4.8
Public Functions | Private Slots | Properties | List of all members
QWSQnxKeyboardHandler Class Reference

The QWSQnxKeyboardHandler class implements a keyboard driver for the QNX devi-hid input manager. More...

#include <qkbdqnx_qws.h>

Inheritance diagram for QWSQnxKeyboardHandler:
QObject QWSKeyboardHandler

Public Functions

 QWSQnxKeyboardHandler (const QString &device)
 Constructs a keyboard handler for the specified device, defaulting to /dev/devi/keyboard0. More...
 
 ~QWSQnxKeyboardHandler ()
 Destroys this keyboard handler and closes the connection to the keyboard device. More...
 
- Public Functions inherited from QObject
bool blockSignals (bool b)
 If block is true, signals emitted by this object are blocked (i.e., emitting a signal will not invoke anything connected to it). More...
 
const QObjectListchildren () const
 Returns a list of child objects. More...
 
bool connect (const QObject *sender, const char *signal, const char *member, Qt::ConnectionType type=Qt::AutoConnection) const
 
bool disconnect (const char *signal=0, const QObject *receiver=0, const char *member=0)
 
bool disconnect (const QObject *receiver, const char *member=0)
 
void dumpObjectInfo ()
 Dumps information about signal connections, etc. More...
 
void dumpObjectTree ()
 Dumps a tree of children to the debug output. More...
 
QList< QByteArraydynamicPropertyNames () const
 Returns the names of all properties that were dynamically added to the object using setProperty(). More...
 
virtual bool event (QEvent *)
 This virtual function receives events to an object and should return true if the event e was recognized and processed. More...
 
virtual bool eventFilter (QObject *, QEvent *)
 Filters events if this object has been installed as an event filter for the watched object. More...
 
template<typename T >
findChild (const QString &aName=QString()) const
 Returns the child of this object that can be cast into type T and that is called name, or 0 if there is no such object. More...
 
template<typename T >
QList< T > findChildren (const QString &aName=QString()) const
 Returns all children of this object with the given name that can be cast to type T, or an empty list if there are no such objects. More...
 
template<typename T >
QList< T > findChildren (const QRegExp &re) const
 
bool inherits (const char *classname) const
 Returns true if this object is an instance of a class that inherits className or a QObject subclass that inherits className; otherwise returns false. More...
 
void installEventFilter (QObject *)
 Installs an event filter filterObj on this object. More...
 
bool isWidgetType () const
 Returns true if the object is a widget; otherwise returns false. More...
 
void killTimer (int id)
 Kills the timer with timer identifier, id. More...
 
virtual const QMetaObjectmetaObject () const
 Returns a pointer to the meta-object of this object. More...
 
void moveToThread (QThread *thread)
 Changes the thread affinity for this object and its children. More...
 
QString objectName () const
 
QObjectparent () const
 Returns a pointer to the parent object. More...
 
QVariant property (const char *name) const
 Returns the value of the object's name property. More...
 
Q_INVOKABLE QObject (QObject *parent=0)
 Constructs an object with parent object parent. More...
 
void removeEventFilter (QObject *)
 Removes an event filter object obj from this object. More...
 
void setObjectName (const QString &name)
 
void setParent (QObject *)
 Makes the object a child of parent. More...
 
bool setProperty (const char *name, const QVariant &value)
 Sets the value of the object's name property to value. More...
 
void setUserData (uint id, QObjectUserData *data)
 
bool signalsBlocked () const
 Returns true if signals are blocked; otherwise returns false. More...
 
int startTimer (int interval)
 Starts a timer and returns a timer identifier, or returns zero if it could not start a timer. More...
 
QThreadthread () const
 Returns the thread in which the object lives. More...
 
QObjectUserDatauserData (uint id) const
 
virtual ~QObject ()
 Destroys the object, deleting all its child objects. More...
 
- Public Functions inherited from QWSKeyboardHandler
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...
 

Private Slots

void socketActivated ()
 

Properties

int keyboardFD
 

Additional Inherited Members

- Public Types inherited from QWSKeyboardHandler
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 Slots inherited from QObject
void deleteLater ()
 Schedules this object for deletion. More...
 
- Signals inherited from QObject
void destroyed (QObject *=0)
 This signal is emitted immediately before the object obj is destroyed, and can not be blocked. More...
 
- Static Public Functions inherited from QObject
static bool connect (const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
 Creates a connection of the given type from the signal in the sender object to the method in the receiver object. More...
 
static bool connect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type=Qt::AutoConnection)
 
static bool disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *member)
 Disconnects signal in object sender from method in object receiver. More...
 
static bool disconnect (const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &member)
 
static uint registerUserData ()
 
static QString tr (const char *sourceText, const char *comment=0, int n=-1)
 
static QString trUtf8 (const char *sourceText, const char *comment=0, int n=-1)
 
- Static Public Variables inherited from QObject
static const QMetaObject staticMetaObject
 This variable stores the meta-object for the class. More...
 
- Protected Functions inherited from QObject
virtual void childEvent (QChildEvent *)
 This event handler can be reimplemented in a subclass to receive child events. More...
 
virtual void connectNotify (const char *signal)
 This virtual function is called when something has been connected to signal in this object. More...
 
virtual void customEvent (QEvent *)
 This event handler can be reimplemented in a subclass to receive custom events. More...
 
virtual void disconnectNotify (const char *signal)
 This virtual function is called when something has been disconnected from signal in this object. More...
 
 QObject (QObjectPrivate &dd, QObject *parent=0)
 
int receivers (const char *signal) const
 Returns the number of receivers connected to the signal. More...
 
QObjectsender () const
 Returns a pointer to the object that sent the signal, if called in a slot activated by a signal; otherwise it returns 0. More...
 
int senderSignalIndex () const
 
virtual void timerEvent (QTimerEvent *)
 This event handler can be reimplemented in a subclass to receive timer events for the object. More...
 
- Protected Functions inherited from QWSKeyboardHandler
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...
 
- Protected Variables inherited from QObject
QScopedPointer< QObjectDatad_ptr
 
- Static Protected Variables inherited from QObject
static const QMetaObject staticQtMetaObject
 

Detailed Description

The QWSQnxKeyboardHandler class implements a keyboard driver for the QNX devi-hid input manager.

This function is under development and subject to change.

Since
4.6
Warning
This function is not part of the public interface.

To be able to compile this mouse handler, Qt for Embedded Linux must be configured with the -qt-kbd-qnx option, see the Qt for Embedded Linux Character Input documentation for details.

In order to use this keyboard handler, the devi-hid input manager must be set up and run with the resource manager interface (option -r). Also, Photon must not be running.

Example invocation from command line: /usr/photon/bin/devi-hid -Pr kbd mouse Note that after running devi-hid, you will not be able to use the local shell anymore. It is suggested to run the command in a shell script, that launches a Qt application after invocation of devi-hid.

To make Qt for Embedded Linux explicitly choose the qnx keyboard handler, set the QWS_KEYBOARD environment variable to qnx. By default, the first keyboard device (/dev/devi/keyboard0) is used. To override, pass a device name as the first and only parameter, for example QWS_KEYBOARD=qnx:/dev/devi/keyboard1; export QWS_KEYBOARD.

See also
{Qt for Embedded Linux Character Input}, {Qt for Embedded Linux}

Definition at line 56 of file qkbdqnx_qws.h.

Constructors and Destructors

◆ QWSQnxKeyboardHandler()

QWSQnxKeyboardHandler::QWSQnxKeyboardHandler ( const QString device)

Constructs a keyboard handler for the specified device, defaulting to /dev/devi/keyboard0.

Note that you should never instanciate this class, instead let QKbdDriverFactory handle the keyboard handlers.

See also
QKbdDriverFactory

Definition at line 99 of file qkbdqnx_qws.cpp.

100 {
101  // open the keyboard device
102  keyboardFD = QT_OPEN(device.isEmpty() ? "/dev/devi/keyboard0" : device.toLatin1().constData(),
103  QT_OPEN_RDONLY);
104  if (keyboardFD == -1) {
105  qErrnoWarning(errno, "QWSQnxKeyboardHandler: Unable to open device");
106  } else {
107  // create a socket notifier so we'll wake up whenever keyboard input is detected.
109  connect(notifier, SIGNAL(activated(int)), SLOT(socketActivated()));
110 
111  qDebug("QWSQnxKeyboardHandler: connected.");
112  }
113 }
#define SLOT(a)
Definition: qobjectdefs.h:226
The QSocketNotifier class provides support for monitoring activity on a file descriptor.
Q_CORE_EXPORT void qDebug(const char *,...)
#define SIGNAL(a)
Definition: qobjectdefs.h:227
static bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *member, Qt::ConnectionType=Qt::AutoConnection)
Creates a connection of the given type from the signal in the sender object to the method in the rece...
Definition: qobject.cpp:2580
bool isEmpty() const
Returns true if the string has no characters; otherwise returns false.
Definition: qstring.h:704
QByteArray toLatin1() const Q_REQUIRED_RESULT
Returns a Latin-1 representation of the string as a QByteArray.
Definition: qstring.cpp:3993
const char * constData() const
Returns a pointer to the data stored in the byte array.
Definition: qbytearray.h:433
#define QT_OPEN
Definition: qcore_unix_p.h:186
int errno
void qErrnoWarning(const char *msg,...)
Definition: qglobal.cpp:2954

◆ ~QWSQnxKeyboardHandler()

QWSQnxKeyboardHandler::~QWSQnxKeyboardHandler ( )

Destroys this keyboard handler and closes the connection to the keyboard device.

Definition at line 118 of file qkbdqnx_qws.cpp.

119 {
120  if (keyboardFD != -1)
122 }
#define QT_CLOSE
Definition: qcore_unix_p.h:304

Functions

◆ socketActivated

void QWSQnxKeyboardHandler::socketActivated ( )
privateslot
Warning
This function is not part of the public interface. Translates the QNX keyboard events to Qt keyboard events

Definition at line 135 of file qkbdqnx_qws.cpp.

Referenced by QWSQnxKeyboardHandler().

136 {
137  _keyboard_packet packet;
138 
139  // read one keyboard event
140  int bytesRead = QT_READ(keyboardFD, &packet, sizeof(_keyboard_packet));
141  if (bytesRead == -1) {
142  qErrnoWarning(errno, "QWSQnxKeyboardHandler::socketActivated(): Unable to read data.");
143  return;
144  }
145 
146  // the bytes read must be the size of a keyboard packet
147  Q_ASSERT(bytesRead == sizeof(_keyboard_packet));
148 
149  if (packet.data.flags & KEY_SYM_VALID_EX)
150  packet.data.flags |= KEY_SYM_VALID;
151  else if (!(packet.data.flags & (KEY_SYM_VALID | KEY_CAP_VALID)))
152  return;
153 
154 #if 0
155  qDebug() << "keyboard got scancode"
156  << hex << packet.data.modifiers
157  << packet.data.flags
158  << packet.data.key_cap
159  << packet.data.key_sym
160  << packet.data.key_scan;
161 #endif
162 
163  // QNX is nice enough to translate the raw keyboard data into generic format for us.
164  // Now we just have to translate it into a format Qt understands.
165 
166  // figure out the modifiers that are currently pressed
167  Qt::KeyboardModifiers modifiers = Qt::NoModifier;
168  if (packet.data.modifiers & KEYMOD_SHIFT)
169  modifiers |= Qt::ShiftModifier;
170  if (packet.data.modifiers & KEYMOD_CTRL)
171  modifiers |= Qt::ControlModifier;
172  if (packet.data.modifiers & KEYMOD_ALT)
173  modifiers |= Qt::AltModifier;
174  if (packet.data.modifiers & KEYMOD_NUM_LOCK)
175  modifiers |= Qt::KeypadModifier;
176 #if 0
177  // special case for AltGr
178  if (packet.data.modifiers & KEYMOD_ALTGR)
179  key = Qt::Key_AltGr;
180 #endif
181 
182  // figure out whether it's a press
183  bool isPress = packet.data.flags & KEY_DOWN;
184  // figure out whether the key is still pressed and the key event is repeated
185  bool isRepeat = packet.data.flags & KEY_REPEAT;
186 
187  int key = Qt::Key_unknown;
188  int unicode = 0;
189 
190  if (((packet.data.flags & KEY_SYM_VALID) && key_sym_displayable(unicode = packet.data.key_sym))
191  || ((packet.data.flags & KEY_CAP_VALID) && key_sym_displayable(unicode = packet.data.key_cap))) {
192  if (unicode <= 0x0ff) {
193  if (unicode >= 'a' && unicode <= 'z')
194  key = Qt::Key_A + unicode - 'a';
195  else
196  key = unicode;
197  }
198  // Ctrl<something> or Alt<something> is not a displayable character
199  if (modifiers & (Qt::ControlModifier | Qt::AltModifier))
200  unicode = 0;
201  } else {
202  unicode = 0;
203 
204  unsigned long sym = 0;
205  if (packet.data.flags & KEY_SYM_VALID)
206  sym = packet.data.key_sym;
207  else if (packet.data.flags & KEY_CAP_VALID)
208  sym = packet.data.key_cap;
209 
210  switch (sym) {
211  case KEYCODE_ESCAPE: key = Qt::Key_Escape; unicode = 27; break;
212  case KEYCODE_TAB: key = Qt::Key_Tab; unicode = 9; break;
213  case KEYCODE_BACK_TAB: key = Qt::Key_Backtab; break;
214  case KEYCODE_BACKSPACE: key = Qt::Key_Backspace; unicode = 127; break;
215  case KEYCODE_RETURN: key = Qt::Key_Return; break;
216  case KEYCODE_KP_ENTER: key = Qt::Key_Enter; break;
217  case KEYCODE_INSERT:
218  case KEYCODE_KP_INSERT:
219  key = Qt::Key_Insert; break;
220  case KEYCODE_KP_DELETE:
221  if (modifiers & Qt::KeypadModifier) {
222  key = Qt::Key_Comma;
223  break;
224  }
225  // fall through
226  case KEYCODE_DELETE:
227  key = Qt::Key_Delete; break;
228  case KEYCODE_PAUSE:
229  case KEYCODE_BREAK:
230  if (modifiers & (Qt::ControlModifier | Qt::AltModifier))
231  return; // sometimes occurs at the middle of a key sequence
232  key = Qt::Key_Pause; break;
233  case KEYCODE_PRINT:
234  if (modifiers & (Qt::ControlModifier | Qt::AltModifier))
235  return; // sometimes occurs at the middle of a key sequence
236  key = Qt::Key_Print; break;
237  case KEYCODE_SYSREQ:
238  key = Qt::Key_SysReq; break;
239  case KEYCODE_HOME:
240  case KEYCODE_KP_HOME:
241  key = Qt::Key_Home; break;
242  case KEYCODE_END:
243  case KEYCODE_KP_END:
244  key = Qt::Key_End; break;
245  case KEYCODE_LEFT:
246  case KEYCODE_KP_LEFT:
247  key = Qt::Key_Left; break;
248  case KEYCODE_UP:
249  case KEYCODE_KP_UP:
250  key = Qt::Key_Up; break;
251  case KEYCODE_RIGHT:
252  case KEYCODE_KP_RIGHT:
253  key = Qt::Key_Right; break;
254  case KEYCODE_DOWN:
255  case KEYCODE_KP_DOWN:
256  key = Qt::Key_Down; break;
257  case KEYCODE_PG_UP:
258  case KEYCODE_KP_PG_UP:
259  key = Qt::Key_PageUp; break;
260  case KEYCODE_PG_DOWN:
261  case KEYCODE_KP_PG_DOWN:
262  key = Qt::Key_PageDown; break;
263 
264  case KEYCODE_LEFT_SHIFT:
265  case KEYCODE_RIGHT_SHIFT:
266  key = Qt::Key_Shift; break;
267  case KEYCODE_LEFT_CTRL:
268  case KEYCODE_RIGHT_CTRL:
269  key = Qt::Key_Control; break;
270  case KEYCODE_LEFT_ALT:
271  case KEYCODE_RIGHT_ALT:
272  key = Qt::Key_Alt; break;
273  case KEYCODE_CAPS_LOCK:
274  key = Qt::Key_CapsLock; break;
275  case KEYCODE_NUM_LOCK:
276  key = Qt::Key_NumLock; break;
277  case KEYCODE_SCROLL_LOCK:
278  key = Qt::Key_ScrollLock; break;
279 
280  case KEYCODE_F1:
281  case KEYCODE_F2:
282  case KEYCODE_F3:
283  case KEYCODE_F4:
284  case KEYCODE_F5:
285  case KEYCODE_F6:
286  case KEYCODE_F7:
287  case KEYCODE_F8:
288  case KEYCODE_F9:
289  case KEYCODE_F10:
290  case KEYCODE_F11:
291  case KEYCODE_F12:
292  key = Qt::Key_F1 + sym - KEYCODE_F1; break;
293 
294  case KEYCODE_MENU: key = Qt::Key_Menu; break;
295  case KEYCODE_LEFT_HYPER: key = Qt::Key_Hyper_L; break;
296  case KEYCODE_RIGHT_HYPER: key = Qt::Key_Hyper_R; break;
297 
298  case KEYCODE_KP_PLUS: key = Qt::Key_Plus; break;
299  case KEYCODE_KP_MINUS: key = Qt::Key_Minus; break;
300  case KEYCODE_KP_MULTIPLY: key = Qt::Key_multiply; break;
301  case KEYCODE_KP_DIVIDE: key = Qt::Key_Slash; break;
302  case KEYCODE_KP_FIVE:
303  if (!(modifiers & Qt::KeypadModifier))
304  key = Qt::Key_5;
305  break;
306 
307  default: // none of the above
308  break;
309  }
310  }
311 
312  if (key == Qt::Key_unknown && unicode == 0)
313  return;
314 
315  // call processKeyEvent. This is where all the magic happens to insert a
316  // key event into Qt's event loop.
317  // Note that for repeated key events, isPress must be true
318  // (on QNX, isPress is not set when the key event is repeated).
319  processKeyEvent(unicode, key, modifiers, isPress || isRepeat, isRepeat);
320 }
#define Q_ASSERT(cond)
Definition: qglobal.h:1823
Q_CORE_EXPORT QTextStream & hex(QTextStream &s)
#define QT_READ
Definition: qcore_unix_p.h:280
Q_CORE_EXPORT void qDebug(const char *,...)
static bool key_sym_displayable(unsigned long sym)
int key
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.
Definition: qkbd_qws.cpp:363
int errno
void qErrnoWarning(const char *msg,...)
Definition: qglobal.cpp:2954

Properties

◆ keyboardFD

int QWSQnxKeyboardHandler::keyboardFD
private

Definition at line 67 of file qkbdqnx_qws.h.

Referenced by QWSQnxKeyboardHandler(), socketActivated(), and ~QWSQnxKeyboardHandler().


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