- added FG_MOD_UP to use key-up or button-up as a command modifier;

  this way, keyboard buttons can work the same way as joystick buttons
- added declaration for FGBinding::fire(double); this adds a setting
  property to the arguments passed to the command, so that it can use
  the current axis position as part of its calculations
- added data structures from joystick.cxx

diff --git a/src/Input/input.hxx b/src/Input/input.hxx
index 8358412da4130775b234359b0c501090338b926f..4ee5e0dddfe3b965fb455765f5436bc49ecf9b44 100644 (file)
--- a/src/Input/input.hxx
+++ b/src/Input/input.hxx
@@ -28,6 +28,8 @@
 # error This library requires C++
 #endif
 
+#include <plib/js.h>
+
 #include <simgear/compiler.h>
 
 #include <simgear/misc/commands.hxx>
@@ -53,21 +55,78 @@ class FGBinding
 {
 public:
 
+  /**
+   * Default constructor.
+   */
   FGBinding ();
+
+
+  /**
+   * Convenience constructor.
+   *
+   * @param node The binding will be built from this node.
+   */
   FGBinding (const SGPropertyNode * node);
+
+
+  /**
+   * Destructor.
+   */
   virtual ~FGBinding ();
 
+
+  /**
+   * Get the command name.
+   *
+   * @return The string name of the command for this binding.
+   */
   virtual const string &getCommandName () const { return _command_name; }
+
+
+  /**
+   * Get the command itself.
+   *
+   * @return The command associated with this binding, or 0 if none
+   * is present.
+   */
   virtual SGCommandMgr::command_t getCommand () const { return _command; }
+
+
+  /**
+   * Get the argument that will be passed to the command.
+   *
+   * @return A property node that will be passed to the command as its
+   * argument, or 0 if none was supplied.
+   */
   virtual const SGPropertyNode * getArg () { return _arg; }
   
+
+  /**
+   * Read a binding from a property node.
+   *
+   * @param node The property node containing the binding.
+   */
   virtual void read (const SGPropertyNode * node);
 
+
+  /**
+   * Fire a binding.
+   */
   virtual void fire () const;
-//   virtual void fire (double value);
-//   virtual void fire (int xdelta, int ydelta);
+
+
+  /**
+   * Fire a binding with a setting (i.e. joystick axis).
+   *
+   * A double 'setting' property will be added to the arguments.
+   *
+   * @param setting The input setting, usually between -1.0 and 1.0.
+   */
+  virtual void fire (double setting) const;
+
 
 private:
+  void _fire (const SGPropertyNode *arg) const;
   string _command_name;
   SGCommandMgr::command_t _command;
   const SGPropertyNode * _arg;
@@ -87,10 +146,11 @@ public:
 
   enum {
     FG_MOD_NONE = 0,
-    FG_MOD_SHIFT = 1,
-    FG_MOD_CTRL = 2,
-    FG_MOD_ALT = 4,
-    FG_MOD_MAX = 8                     // one past all modifiers
+    FG_MOD_UP = 1,             // key- or button-up
+    FG_MOD_SHIFT = 2,
+    FG_MOD_CTRL = 4,
+    FG_MOD_ALT = 8,
+    FG_MOD_MAX = 16            // enough to handle all combinations
   };
 
   FGInput();
@@ -124,13 +184,102 @@ public:
 
 private:
 
+  typedef vector<FGBinding> binding_list_t;
+
+                               // Constants
+  static const int MAX_KEYS = 1024;
+  #ifdef WIN32
+  static const int MAX_JOYSTICKS = 2;
+  #else
+  static const int MAX_JOYSTICKS = 10;
+  #endif
+  static const int MAX_AXES = _JS_MAX_AXES;
+  static const int MAX_BUTTONS = 32;
+
+
+  /**
+   * Settings for a key or button.
+   */
+  struct button {
+    button ()
+      : is_repeatable(true),
+       last_state(-1)
+    {}
+    bool is_repeatable;
+    int last_state;
+    binding_list_t bindings[FG_MOD_MAX];
+  };
+
+
+  /**
+   * Settings for a single joystick axis.
+   */
+  struct axis {
+    axis ()
+      : last_value(9999999),
+       tolerance(0.002)
+    {}
+    float last_value;
+    float tolerance;
+    binding_list_t bindings[FG_MOD_MAX];
+  };
+
+
+  /**
+   * Settings for a joystick.
+   */
+  struct joystick {
+    virtual ~joystick () {
+      delete js;
+      delete[] axes;
+      delete[] buttons;
+    }
+    int naxes;
+    int nbuttons;
+    jsJoystick * js;
+    axis * axes;
+    button * buttons;
+  };
+
+
+  /**
+   * Initialize key bindings.
+   */
+  void _init_keyboard ();
+
+
+  /**
+   * Initialize joystick bindings.
+   */
+  void _init_joystick ();
+
+
+  /**
+   * Update the keyboard.
+   */
+  void _update_keyboard ();
+
+
+  /**
+   * Update the joystick.
+   */
+  void _update_joystick ();
+
+
+  /**
+   * Read bindings and modifiers.
+   */
+  void _read_bindings (const SGPropertyNode * node,
+                      binding_list_t * binding_list,
+                      int modifiers);
+
   /**
    * Look up the bindings for a key code.
    */
-  const vector<FGBinding> * _find_bindings (int k, int modifiers);
+  const vector<FGBinding> &_find_key_bindings (unsigned int k, int modifiers);
 
-  typedef map<int,vector<FGBinding> > keyboard_map;
-  keyboard_map _key_bindings[FG_MOD_MAX];
+  button _key_bindings[MAX_KEYS];
+  joystick _joystick_bindings[MAX_JOYSTICKS];
 
 };