add easier support for key codes in JS by adding text property and auto-detecting isShifted

examples/controllerExample.js

@@ -48,6 +48,15 @@ function checkController() {
 
 function keyPressEvent(event) {
     print("keyPressEvent event.key=" + event.key);
+    print("keyPressEvent event.text=" + event.text);
+
+    print("keyPressEvent event.isShifted=" + event.isShifted);
+    print("keyPressEvent event.isControl=" + event.isControl);
+    print("keyPressEvent event.isMeta=" + event.isMeta);
+    print("keyPressEvent event.isAlt=" + event.isAlt);
+    print("keyPressEvent event.isKeypad=" + event.isKeypad);
+
+
     if (event.key == "A".charCodeAt(0)) {
         print("the A key was pressed");
     }
@@ -77,14 +86,102 @@ Agent.willSendVisualDataCallback.connect(checkController);
 
 // Map keyPress and mouse move events to our callbacks
 Controller.keyPressEvent.connect(keyPressEvent);
-var AKeyEvent = {
+var KeyEvent_A = {
     key: "A".charCodeAt(0),
+    text: "A",
     isShifted: false,
     isMeta: false
 };
 
+var KeyEvent_a = {
+    text: "a",
+    isShifted: false,
+    isMeta: false
+};
+
+var KeyEvent_a2 = {
+    key: "a".charCodeAt(0),
+    isShifted: false,
+    isMeta: false
+};
+
+var KeyEvent_a3 = {
+    text: "a"
+};
+
+var KeyEvent_A2 = {
+    text: "A"
+};
+
+
+var KeyEvent_9 = {
+    text: "9"
+};
+
+var KeyEvent_Num = {
+    text: "#"
+};
+
+var KeyEvent_At = {
+    text: "@"
+};
+
+var KeyEvent_MetaAt = {
+    text: "@",
+    isMeta: true
+};
+
+var KeyEvent_Up = {
+    text: "up"
+};
+var KeyEvent_Down = {
+    text: "down"
+};
+var KeyEvent_Left = {
+    text: "left"
+};
+var KeyEvent_Right = {
+    text: "right"
+};
+
 // prevent the A key from going through to the application
-Controller.captureKeyEvents(AKeyEvent);
+print("KeyEvent_A");
+Controller.captureKeyEvents(KeyEvent_A);
+
+print("KeyEvent_A2");
+Controller.captureKeyEvents(KeyEvent_A2);
+
+print("KeyEvent_a");
+Controller.captureKeyEvents(KeyEvent_a);
+
+print("KeyEvent_a2");
+Controller.captureKeyEvents(KeyEvent_a2);
+
+print("KeyEvent_a3");
+Controller.captureKeyEvents(KeyEvent_a3);
+
+print("KeyEvent_9");
+Controller.captureKeyEvents(KeyEvent_9);
+
+print("KeyEvent_Num");
+Controller.captureKeyEvents(KeyEvent_Num);
+
+print("KeyEvent_At");
+Controller.captureKeyEvents(KeyEvent_At);
+
+print("KeyEvent_MetaAt");
+Controller.captureKeyEvents(KeyEvent_MetaAt);
+
+print("KeyEvent_Up");
+Controller.captureKeyEvents(KeyEvent_Up);
+print("KeyEvent_Down");
+Controller.captureKeyEvents(KeyEvent_Down);
+print("KeyEvent_Left");
+Controller.captureKeyEvents(KeyEvent_Left);
+print("KeyEvent_Right");
+Controller.captureKeyEvents(KeyEvent_Right);
+
+
 
 
 Controller.mouseMoveEvent.connect(mouseMoveEvent);

libraries/script-engine/src/EventTypes.cpp

@@ -8,22 +8,72 @@
 //  Used to register meta-types with Qt for very various event types so that they can be exposed to our
 //  scripting engine
 
+#include <QDebug>
 #include "EventTypes.h"
 
 
 KeyEvent::KeyEvent() {
     key = 0;
+    text = QString("");
     isShifted = false;
     isMeta = false;
+    isControl = false;
     isValid = false;
 }
 
 
 KeyEvent::KeyEvent(const QKeyEvent& event) {
     key = event.key();
+    text = event.text();
     isShifted = event.modifiers().testFlag(Qt::ShiftModifier);
-    isMeta = event.modifiers().testFlag(Qt::ControlModifier);
+    isMeta = event.modifiers().testFlag(Qt::MetaModifier);
+    isControl = event.modifiers().testFlag(Qt::ControlModifier);
+    isAlt = event.modifiers().testFlag(Qt::AltModifier);
+    isKeypad = event.modifiers().testFlag(Qt::KeypadModifier);
     isValid = true;
+
+    // handle special text for special characters...
+    if (key == Qt::Key_F1) {
+        text = "F1";
+    } else if (key == Qt::Key_F2) {
+        text = "F2";
+    } else if (key == Qt::Key_F3) {
+        text = "F3";
+    } else if (key == Qt::Key_F4) {
+        text = "F4";
+    } else if (key == Qt::Key_F5) {
+        text = "F5";
+    } else if (key == Qt::Key_F6) {
+        text = "F6";
+    } else if (key == Qt::Key_F7) {
+        text = "F7";
+    } else if (key == Qt::Key_F8) {
+        text = "F8";
+    } else if (key == Qt::Key_F9) {
+        text = "F9";
+    } else if (key == Qt::Key_F10) {
+        text = "F10";
+    } else if (key == Qt::Key_F11) {
+        text = "F11";
+    } else if (key == Qt::Key_F12) {
+        text = "F12";
+    } else if (key == Qt::Key_Up) {
+        text = "UP";
+    } else if (key == Qt::Key_Down) {
+        text = "DOWN";
+    } else if (key == Qt::Key_Left) {
+        text = "LEFT";
+    } else if (key == Qt::Key_Right) {
+        text = "RIGHT";
+    } else if (key == Qt::Key_Escape) {
+        text = "ESC";
+    } else if (key == Qt::Key_Tab) {
+        text = "TAB";
+    } else if (key == Qt::Key_Delete) {
+        text = "DELETE";
+    } else if (key == Qt::Key_Backspace) {
+        text = "BACKSPACE";
+    }
 }
 
 MouseEvent::MouseEvent(const QMouseEvent& event) {
@@ -65,16 +115,113 @@ void registerEventTypes(QScriptEngine* engine) {
 QScriptValue keyEventToScriptValue(QScriptEngine* engine, const KeyEvent& event) {
     QScriptValue obj = engine->newObject();
     obj.setProperty("key", event.key);
+    obj.setProperty("text", event.text);
     obj.setProperty("isShifted", event.isShifted);
     obj.setProperty("isMeta", event.isMeta);
+    obj.setProperty("isControl", event.isControl);
+    obj.setProperty("isAlt", event.isAlt);
+    obj.setProperty("isKeypad", event.isKeypad);
     return obj;
 }
 
 void keyEventFromScriptValue(const QScriptValue &object, KeyEvent& event) {
-    event.key = object.property("key").toVariant().toInt();
+
-    event.isShifted = object.property("isShifted").toVariant().toBool();
+    event.isValid = false; // assume the worst
     event.isMeta = object.property("isMeta").toVariant().toBool();
-    event.isValid = object.property("key").isValid();
+    event.isControl = object.property("isControl").toVariant().toBool();
+    event.isAlt = object.property("isAlt").toVariant().toBool();
+    event.isKeypad = object.property("isKeypad").toVariant().toBool();
+
+    QScriptValue key = object.property("key");
+    if (key.isValid()) {
+        event.key = key.toVariant().toInt();
+        event.text = QString(QChar(event.key));
+        event.isValid = true;
+    } else {
+        QScriptValue text = object.property("text");
+        if (text.isValid()) {
+            event.text = object.property("text").toVariant().toString();
+            
+            // if the text is a special command, then map it here...
+            // TODO: come up with more elegant solution here, a map? is there a Qt function that gives nice names for keys?
+            if (event.text.toUpper() == "F1") {
+                event.key = Qt::Key_F1;
+            } else if (event.text.toUpper() == "F2") {
+                event.key = Qt::Key_F2;
+            } else if (event.text.toUpper() == "F3") {
+                event.key = Qt::Key_F3;
+            } else if (event.text.toUpper() == "F4") {
+                event.key = Qt::Key_F4;
+            } else if (event.text.toUpper() == "F5") {
+                event.key = Qt::Key_F5;
+            } else if (event.text.toUpper() == "F6") {
+                event.key = Qt::Key_F6;
+            } else if (event.text.toUpper() == "F7") {
+                event.key = Qt::Key_F7;
+            } else if (event.text.toUpper() == "F8") {
+                event.key = Qt::Key_F8;
+            } else if (event.text.toUpper() == "F9") {
+                event.key = Qt::Key_F9;
+            } else if (event.text.toUpper() == "F10") {
+                event.key = Qt::Key_F10;
+            } else if (event.text.toUpper() == "F11") {
+                event.key = Qt::Key_F11;
+            } else if (event.text.toUpper() == "F12") {
+                event.key = Qt::Key_F12;
+            } else if (event.text.toUpper() == "UP") {
+                event.key = Qt::Key_Up;
+                event.isKeypad = true;
+            } else if (event.text.toUpper() == "DOWN") {
+                event.key = Qt::Key_Down;
+                event.isKeypad = true;
+            } else if (event.text.toUpper() == "LEFT") {
+                event.key = Qt::Key_Left;
+                event.isKeypad = true;
+            } else if (event.text.toUpper() == "RIGHT") {
+                event.key = Qt::Key_Right;
+                event.isKeypad = true;
+            } else if (event.text.toUpper() == "ESC") {
+                event.key = Qt::Key_Escape;
+            } else if (event.text.toUpper() == "TAB") {
+                event.key = Qt::Key_Tab;
+            } else if (event.text.toUpper() == "DELETE") {
+                event.key = Qt::Key_Delete;
+            } else if (event.text.toUpper() == "BACKSPACE") {
+                event.key = Qt::Key_Backspace;
+            } else {
+                event.key = event.text.at(0).unicode();
+            }
+            event.isValid = true;
+        }
+    }
+
+    QScriptValue isShifted = object.property("isShifted");
+    if (isShifted.isValid()) {
+        event.isShifted = isShifted.toVariant().toBool();
+    } else {
+        // if no isShifted was included, get it from the text
+        QChar character = event.text.at(0);
+        if (character.isLetter() && character.isUpper()) {
+            event.isShifted = true;
+        } else {
+            // if it's a symbol, then attempt to detect shifted-ness
+            if (QString("~!@#$%^&*()_+{}|:\"<>?").contains(character)) {
+                event.isShifted = true;
+            }
+        }
+    }
+    
+
+    const bool wantDebug = false;
+    if (wantDebug) {    
+        qDebug() << "event.key=" << event.key
+            << " event.text=" << event.text
+            << " event.isShifted=" << event.isShifted
+            << " event.isControl=" << event.isControl
+            << " event.isMeta=" << event.isMeta
+            << " event.isAlt=" << event.isAlt
+            << " event.isKeypad=" << event.isKeypad;
+    }
 }
 
 QScriptValue mouseEventToScriptValue(QScriptEngine* engine, const MouseEvent& event) {

libraries/script-engine/src/EventTypes.h

@@ -24,10 +24,19 @@ public:
     KeyEvent();
     KeyEvent(const QKeyEvent& event);
     inline bool operator==(const KeyEvent& other) const { 
-                            return other.key == key && other.isShifted == isShifted && other.isMeta == isMeta; }
+                            return other.key == key 
+                                && other.isShifted == isShifted 
+                                && other.isControl == isControl
+                                && other.isMeta == isMeta
+                                && other.isAlt == isAlt
+                                && other.isKeypad == isKeypad; }
     int key;
+    QString text;
     bool isShifted;
+    bool isControl;
     bool isMeta;
+    bool isAlt;
+    bool isKeypad;
     bool isValid;
 };