keyboard.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_KEYBOARD_H
#define ARCHON_UTILITIES_KEYBOARD_H

#include <string>

#include <archon/util/window.H>

#include <archon/util/exception.H>

namespace Archon
{
  namespace Utilities
  {
    namespace KeyboardEvents
    {
      using namespace std;

      struct Handler
      {
        virtual void press() = 0;
        virtual void release() = 0;
        virtual ~Handler() {}
      };

      struct FuncCall: Handler
      {
        FuncCall(void (*pressFunc)(), void (*releaseFunc)()):
          p(pressFunc), r(releaseFunc) {}

      private:
        void (*p)();
        void (*r)();
        virtual void press()   { if(p) (*p)(); }
        virtual void release() { if(r) (*r)(); }

      };

      template<class T> struct MethodCall: Handler
      {
        MethodCall(T *object,
                   void (T::*pressMethod)(),
                   void (T::*releaseMethod)()):
          o(object), p(pressMethod), r(releaseMethod) {}

      private:
        T *o;
        void (T::*p)();
        void (T::*r)();
        virtual void press()   { if(p) (o->*p)(); }
        virtual void release() { if(r) (o->*r)(); }
      };

      struct Toggle: Handler
      {
        Toggle(bool &var): var(var) {}

      private:
        bool &var;
        virtual void press()   { var = !var; }
        virtual void release() {}
      };

      template<class T> struct VarAssign: Handler
      {
        VarAssign(T &variable, T pressValue, T releaseValue):
          var(variable), pVal(pressValue), rVal(releaseValue), rEnable(true) {}

        VarAssign(T &variable, T pressValue):
          var(variable), pVal(pressValue), rVal(pVal), rEnable(false) {}

      private:
        T &var;
        const T pVal;
        const T rVal;
        const bool rEnable;
        virtual void press()   { var = pVal; }
        virtual void release() { if(rEnable) var = rVal; }
      };

      template<class T> struct VarAdd: Handler
      {
        VarAdd(T &variable, T value, bool ignoreRelease = false):
          var(variable), val(value), rEnable(!ignoreRelease) {}

      private:
        T &var;
        const T val;
        virtual void press()   { var += val; }
        virtual void release() { if(rEnable) var -= val; }
        const bool rEnable;
      };

      template<class T> struct VarMultiply: Handler
      {
        VarMultiply(T &variable, T value, bool ignoreRelease = false):
          var(variable), val(value), rEnable(!ignoreRelease) {}

      private:
        T &var;
        const T val;
        virtual void press()   { var *= val; }
        virtual void release() { if(rEnable) var /= val; }
        const bool rEnable;
      };

      struct Dispatcher: Window::KeyboardHandler
      {
        Dispatcher(unsigned numberOfModes = 1,
                   unsigned maxMultipressLimit = 1,
                   unsigned long multipressMaxDelay = 200);
        virtual ~Dispatcher();

        void setMultipressLimit(Key, unsigned limit);

        void setHandler(Key, Handler *,
                        unsigned mode = 0,
                        unsigned multipressCardinality = 1);

        void setMode(unsigned);
        unsigned getMode() const { return currentMode; }

      private:
        const unsigned numberOfModes;
        const unsigned maxMultipressLimit;
        const unsigned long multipressMaxDelay; // In milliseconds

        struct KeyAccount
        {
          unsigned long lastPress;
          unsigned multipressLimit;
          unsigned multipressCounter;
          unsigned pressMode;
          KeyAccount(): lastPress(0), multipressLimit(1),
                        multipressCounter(0), pressMode(0) {}
        };

        KeyAccount *keyAccounts;
        Handler **handlers;

        unsigned currentMode;

        virtual void press(Key, unsigned long milliSecondTime);
        virtual void release(Key);
      };
    }
  }
}

#endif // ARCHON_UTILITIES_KEYBOARD_H

---