mouse.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_MOUSE_H
#define ARCHON_UTILITIES_MOUSE_H

#include <string>

#include <archon/util/window.H>

#include <archon/util/exception.H>

namespace Archon
{
  namespace Utilities
  {
    namespace MouseEvents
    {
      using namespace std;

      struct ButtonHandler
      {
        virtual void press(unsigned x, unsigned y) = 0;
        virtual void release(unsigned x, unsigned y) = 0;
        virtual ~ButtonHandler() {}
      };

      struct ButtonFunc: ButtonHandler
      {
        ButtonFunc(void (*pressFunc)(unsigned x, unsigned y),
                   void (*releaseFunc)(unsigned x, unsigned y)):
          p(pressFunc), r(releaseFunc) {}

      private:
        void (*p)(unsigned x, unsigned y);
        void (*r)(unsigned x, unsigned y);
        virtual void press(unsigned x, unsigned y)   { if(p) (*p)(x, y); }
        virtual void release(unsigned x, unsigned y) { if(r) (*r)(x, y); }
      };

      template<class T>
      struct ButtonFuncCookie: ButtonHandler
      {
        ButtonFuncCookie(void (*pressFunc)(unsigned x, unsigned y, T),
                         void (*releaseFunc)(unsigned x, unsigned y, T),
                         T cookie):
          p(pressFunc), r(releaseFunc), cookie(cookie) {}

      private:
        void (*p)(unsigned x, unsigned y, T);
        void (*r)(unsigned x, unsigned y, T);
        T cookie;
        virtual void press(unsigned x, unsigned y)   { if(p) (*p)(x, y, cookie); }
        virtual void release(unsigned x, unsigned y) { if(r) (*r)(x, y, cookie); }
      };

      template<class T>
      struct ButtonMethod: ButtonHandler
      {
        ButtonMethod(T *object, void (T::*method)(unsigned x, unsigned y, bool press)):
          o(object), m(method) {}

      private:
        T *o;
        void (T::*m)(unsigned x, unsigned y, bool press);
        virtual void press(unsigned x, unsigned y)   { (o->*m)(x, y, true);  }
        virtual void release(unsigned x, unsigned y) { (o->*m)(x, y, false); }
      };

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

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

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

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

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

      struct MotionHandler
      {
        virtual void move(unsigned xAbs, unsigned yAbs,
                          int xRel, int yRel) = 0;
        virtual ~MotionHandler() {}
      };

      struct MotionFunc: MotionHandler
      {
        MotionFunc(void (*moveFunc)(unsigned xAbs, unsigned yAbs,
                                    int xRel, int yRel)):
          m(moveFunc) {}

      private:
        void (*m)(unsigned xAbs, unsigned yAbs, int xRel, int yRel);
        virtual void move(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
        {
          (*m)(xAbs, yAbs, xRel, yRel);
        }
      };

      template<class T>
      struct MotionFuncCookie: MotionHandler
      {
        MotionFuncCookie(void (*moveFunc)(unsigned xAbs, unsigned yAbs,
                                          int xRel, int yRel, T), T cookie):
          m(moveFunc), cookie(cookie) {}

      private:
        void (*m)(unsigned xAbs, unsigned yAbs, int xRel, int yRel, T);
        T cookie;
        virtual void move(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
        {
          (*m)(xAbs, yAbs, xRel, yRel, cookie);
        }
      };

      template<class T> struct MotionMethod: MotionHandler
      {
        MotionMethod(T *object,
                     void (T::*moveMethod)(unsigned xAbs, unsigned yAbs,
                                           int xRel, int yRel)):
          o(object), m(moveMethod) {}

      private:
        T *o;
        void (T::*m)(unsigned xAbs, unsigned yAbs, int xRel, int yRel);
        virtual void move(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
        {
          (o->*m)(xAbs, yAbs, xRel, yRel);
        }
      };

      struct Dispatcher: Window::MouseHandler
      {
        Dispatcher(unsigned numberOfButtons = 3,
                   unsigned numberOfModes = 1,
                   unsigned maxMulticlickLimit = 1,
                   unsigned long multiclickMaxDelay = 200);
        virtual ~Dispatcher();

        void setMulticlickLimit(unsigned button, unsigned limit);

        void setButtonHandler(unsigned button, ButtonHandler *,
                              unsigned mode = 0,
                              unsigned multiclickCardinality = 1);

        void setMotionHandler(MotionHandler *, unsigned mode = 0);

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

      private:
        const unsigned numberOfButtons;
        const unsigned numberOfModes;
        const unsigned maxMulticlickLimit;
        const unsigned long multiclickMaxDelay; // In milliseconds

        struct ButtonAccount
        {
          unsigned long lastClick;
          unsigned multiclickLimit;
          unsigned multiclickCounter;
          unsigned clickMode;
          ButtonAccount(): lastClick(0), multiclickLimit(1),
                           multiclickCounter(0), clickMode(0) {}
        };

        ButtonAccount *buttonAccounts;
        ButtonHandler **buttonHandlers;
        MotionHandler **motionHandlers;

        unsigned currentMode;

        virtual void press(unsigned button, unsigned x, unsigned y,
                           unsigned long milliSecondTime);
        virtual void release(unsigned button, unsigned x, unsigned y);
        virtual void motion(unsigned xAbs, unsigned yAbs, int xRel, int yRel);
      };
    }
  }
}

#endif // ARCHON_UTILITIES_KEYBOARD_H

---