Changeset 45:72d5105fcb72 in xplra

Timestamp:

02/16/13 09:02:30 (12 years ago)

Author:

István Váradi <ivaradi@…>

Branch:

default

Phase:

public

Message:

Implemented hotkey handling

Files:

• misc/client.py (modified) (1 diff)
• src/plugin/src/xplra/Globals.h (modified) (4 diffs)
• src/plugin/src/xplra/HotkeyHandler.cc (added)
• src/plugin/src/xplra/HotkeyHandler.h (added)
• src/plugin/src/xplra/Makefile.am (modified) (2 diffs)
• src/plugin/src/xplra/Protocol.h (modified) (3 diffs)
• src/plugin/src/xplra/ServerThread.cc (modified) (5 diffs)
• src/plugin/src/xplra/ServerThread.h (modified) (3 diffs)

misc/client.py

@@ -443 +443 @@
             print >> sys.stderr, "Error code:", result
 
+    def do_register_hotkeys(self, args):
+        words = self._splitArgs(args)
+        if not words:
+            print >> sys.stderr, "Missing parameters"
+            return False
+
+        self._writeU8(0x51)
+        self._writeU32(len(words))
+        for word in words:
+            self._writeU16(int(word, 16))
+        self._flush()
+
+        result = self._readU8()
+        if result!=0:
+            print >> sys.stderr, "Error code:", result
+
+    def do_query_hotkeys(self, args):
+        self._writeU8(0x52)
+        self._flush()
+
+        result = self._readU8()
+        if result==0:
+            length = self._readU32()
+            values = []
+            for i in range(0, length):
+                values.append(self._readU8())
+            print values
+        else:
+            print >> sys.stderr, "Error code:", result
+
+    def do_unregister_hotkeys(self, args):
+        self._writeU8(0x53)
+        self._flush()
+
+        result = self._readU8()
+        if result!=0:
+            print >> sys.stderr, "Error code:", result
+
     def _writeU8(self, x):
         """Write the given value as an unsigned, 8-bit value."""
         self._stream.write(struct.pack("B", x))
+
+    def _writeU16(self, x):
+        """Write the given value as an unsigned, 16-bit value."""
+        self._stream.write(struct.pack("H", x))
 
     def _writeS32(self, x):

src/plugin/src/xplra/Globals.h

@@ -33 +33 @@
 #include "MessageWindow.h"
 #include "Menu.h"
+#include "HotkeyHandler.h"
 
 //------------------------------------------------------------------------------
@@ -67 +68 @@
     Menu menu;
 
+    /**
+     * The hotkey handler.
+     */
+    HotkeyHandler hotkeyHandler;
+
 public:
     /**
@@ -82 +88 @@
      */
     MessageWindow& getMessageWindow();
+
+    /**
+     * Get the hotkey handler.
+     */
+    HotkeyHandler& getHotkeyHandler();
 };
 
 //------------------------------------------------------------------------------
 // Inline definitions
+//------------------------------------------------------------------------------
+
+inline void Globals::getVersions(int& xplaneV, int& xplmV) const
+{
+    xplaneV = xplaneVersion;
+    xplmV = xplmVersion;
+}
+
 //------------------------------------------------------------------------------
 
@@ -95 +114 @@
 //------------------------------------------------------------------------------
 
-inline void Globals::getVersions(int& xplaneV, int& xplmV) const
+inline HotkeyHandler& Globals::getHotkeyHandler()
 {
-    xplaneV = xplaneVersion;
-    xplmV = xplmVersion;
+    return hotkeyHandler;
 }
 

src/plugin/src/xplra/Makefile.am

@@ -21 +21 @@
         MessageWindow.cc                \
         MessageRequest.cc               \
-        Menu.cc
+        Menu.cc                         \
+        HotkeyHandler.cc
 
 noinst_HEADERS= \
@@ -41 +42 @@
         MessageWindow.h                 \
         MessageRequest.h                \
-        Menu.h
+        Menu.h                          \
+        HotkeyHandler.h
 
 if TARGET_API_POSIX

src/plugin/src/xplra/Protocol.h

@@ -107 +107 @@
 
     /**
+     * Command: register a set of hotkeys for the client. Old hotkeys,
+     * if any, are forgotten.
+     *
+     * The command is followed by the following data:
+     * - The number of the hotkeys defined (U32).
+     * - The code of the hotkeys (U16*number of the hotkeys).
+     *   The lower byte is the same as the X-Plane virtual key code
+     *   (the same as the ASCII code for numbers and upper-case letters),
+     *   the upper one is a logical OR of the HOTKEY_MODIFIER_XXX
+     *   codes.
+     *
+     * The reply consists of a result code only. It may fail with an
+     * invalid length code if the number of hotkeys is too large.
+     */
+    static const uint8_t COMMAND_REGISTER_HOTKEYS = 0x51;
+
+    /**
+     * Command: query the hotkeys.
+     *
+     * The reply consists of a result code, followed by the following
+     * data, if the result code is RESULT_OK:
+     * - The number of hotkeys defined (U32).
+     * - An array of U8 values each being 0 or 1 depending on whether
+     *   the corresponding hotkey has been pressed since the last
+     *   query (or the registration, whichever is later). The value at
+     *   index i corresponds to the hotkey code at index i in the
+     *   array passed with COMMAND_REGISTER_HOTKEYS.
+     *
+     * If not hotkey has been registered, the number of hotkeys is
+     * returned as 0.
+     */
+    static const uint8_t COMMAND_QUERY_HOTKEYS = 0x52;
+
+    /**
+     * Command: unregister the previously registered hotkeys.
+     *
+     * The reply is a result code.
+     */
+    static const uint8_t COMMAND_UNREGISTER_HOTKEYS = 0x53;
+
+    /**
      * Data type: int
      */
@@ -185 +226 @@
      */
     static const uint8_t RESULT_OTHER_ERROR = 0xff;
+
+    /**
+     * Hotkey modifier: shift
+     */
+    static const uint16_t HOTKEY_MODIFIER_SHIFT = 0x0100;
+
+    /**
+     * Hotkey modifier: control
+     */
+    static const uint16_t HOTKEY_MODIFIER_CONTROL = 0x0200;
 
     /**
@@ -201 +252 @@
      */
     static const float MAX_MESSAGE_DURATION = 5*60;
+
+    /**
+     * The maximal number of hotkeys that can be registered for a
+     * client.
+     */
+    static const size_t MAX_HOTKEY_COUNT = 128;
 
     /**

src/plugin/src/xplra/ServerThread.cc

@@ -76 +76 @@
 //------------------------------------------------------------------------------
 
+inline bool ServerThread::destroyHotkeys()
+{
+    if (hotkeys!=0) {
+        listenThread.getGlobals().getHotkeyHandler().unregisterHotkeys(hotkeys);
+        delete hotkeys; hotkeys = 0;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+//------------------------------------------------------------------------------
+
 ServerThread::ServerThread(ListenThread& listenThread,
                            RequestQueue& requestQueue, LocalAcceptor& acceptor) :
@@ -84 +97 @@
     stream(*bufferedStream),
     nextGetMultiRequestID(1),
-    nextSetMultiRequestID(1)
+    nextSetMultiRequestID(1),
+    hotkeys(0)
 {
     instancesMutex.lock();
@@ -159 +173 @@
         } else if (command==Protocol::COMMAND_SHOW_MESSAGE) {
             if (!handleShowMessage()) break;
+        } else if (command==Protocol::COMMAND_REGISTER_HOTKEYS) {
+            if (!handleRegisterHotkeys()) break;
+        } else if (command==Protocol::COMMAND_QUERY_HOTKEYS) {
+            if (!handleQueryHotkeys()) break;
+        } else if (command==Protocol::COMMAND_UNREGISTER_HOTKEYS) {
+            if (!handleUnregisterHotkeys()) break;
         } else {
             stream.writeU8(Protocol::RESULT_INVALID_COMMAND);
@@ -164 +184 @@
         stream.flush();
     }
+
+    destroyHotkeys();
 
     Util::debug("hu.varadiistvan.xplra.ServerThread[%p]::run: quitting\n", this);
@@ -446 +468 @@
 //------------------------------------------------------------------------------
 
+bool ServerThread::handleRegisterHotkeys()
+{
+    size_t numHotkeys = stream.readU32();
+    if (!stream) return false;
+
+    if (numHotkeys>Protocol::MAX_HOTKEY_COUNT) {
+        stream.writeU8(Protocol::RESULT_INVALID_LENGTH);
+    } else {
+        HotkeyHandler::Hotkeys* newHotkeys =
+            new HotkeyHandler::Hotkeys(numHotkeys, stream);
+        if (newHotkeys->isValid()) {
+            destroyHotkeys();
+            hotkeys = newHotkeys;
+            listenThread.getGlobals().getHotkeyHandler().registerHotkeys(hotkeys);
+            stream.writeU8(Protocol::RESULT_OK);
+        } else {
+            delete newHotkeys;
+            return false;
+        }
+    }
+
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+bool ServerThread::handleQueryHotkeys()
+{
+    stream.writeU8(Protocol::RESULT_OK);
+    if (hotkeys==0) {
+        stream.writeU32(0);
+    } else {
+        hotkeys->writePressed(stream);
+    }
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
+bool ServerThread::handleUnregisterHotkeys()
+{
+    destroyHotkeys();
+    stream.writeU8(Protocol::RESULT_OK);
+    return true;
+}
+
+//------------------------------------------------------------------------------
+
 // Local Variables:
 // mode: C++

src/plugin/src/xplra/ServerThread.h

@@ -31 +31 @@
 //------------------------------------------------------------------------------
 
+#include "HotkeyHandler.h"
+
 #include <hu/varadiistvan/scpl/Thread.h>
 
@@ -141 +143 @@
     setMultiRequests_t setMultiRequests;
 
+    /**
+     * The set of hotkeys currently being handled.
+     */
+    HotkeyHandler::Hotkeys* hotkeys;
+
 public:
     /**
@@ -255 +262 @@
      */
     bool handleShowMessage();
+
+    /**
+     * Handle the COMMAND_REGISTER_HOTKEYS command.
+     *
+     * @return true if we can continue, false if the thread should
+     * quit.
+     */
+    bool handleRegisterHotkeys();
+
+    /**
+     * Handle the COMMAND_QUERY_HOTKEYS command.
+     *
+     * @return true if we can continue, false if the thread should
+     * quit.
+     */
+    bool handleQueryHotkeys();
+
+    /**
+     * Handle the COMMAND_UNREGISTER_HOTKEYS command.
+     *
+     * @return true if we can continue, false if the thread should
+     * quit.
+     */
+    bool handleUnregisterHotkeys();
+
+private:
+    /**
+     * Destroy the current set of hotkeys, if any.
+     *
+     * @return whether there were any hotkeys or not.
+     */
+    bool destroyHotkeys();
 };