mouse.C

/*
 * 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).
 */

#include <iostream>

#include <archon/util/mouse.H>

namespace Archon
{
  namespace Utilities
  {
    namespace MouseEvents
    {
      Dispatcher::Dispatcher(unsigned numberOfButtons,
                             unsigned numberOfModes,
                             unsigned maxMulticlickLimit,
                             unsigned long multiclickMaxDelay):
        numberOfButtons(numberOfButtons),
        numberOfModes(numberOfModes),
        maxMulticlickLimit(maxMulticlickLimit),
        multiclickMaxDelay(multiclickMaxDelay),
        currentMode(0)
      {
        if(maxMulticlickLimit < 1)
          ARCHON_THROW1(ArgumentException, "Invalid multiclick limit");

        buttonAccounts = new ButtonAccount[numberOfButtons];

        buttonHandlers =
          new ButtonHandler *[numberOfButtons *
                              numberOfModes *
                              maxMulticlickLimit];

        motionHandlers = new MotionHandler *[numberOfModes];

        for(unsigned i=0; i<numberOfButtons * numberOfModes *
              maxMulticlickLimit; ++i)
          buttonHandlers[i] = 0;

        for(unsigned i=0; i<numberOfModes; ++i)
          motionHandlers[i] = 0;
      }

      Dispatcher::~Dispatcher()
      {{ // The extra scope is needed to work around gcc3.2 bug #8287
        delete[] motionHandlers;
        delete[] buttonHandlers;
        delete[] buttonAccounts;
      }}

      void Dispatcher::setMulticlickLimit(unsigned button, unsigned limit)
      {
        if(button < 0 || button >= numberOfButtons)
          ARCHON_THROW1(ArgumentException, "Invalid button");
        if(limit < 1 || limit > maxMulticlickLimit)
          ARCHON_THROW1(ArgumentException, "Invalid multiclick limit");

        buttonAccounts[button].multiclickLimit = limit;
      }

      void Dispatcher::setMode(unsigned mode)
      {
        if(mode < 0 || mode >= numberOfModes)
          ARCHON_THROW1(ArgumentException, "Invalid mode");
        currentMode = mode;
      }

      void Dispatcher::setButtonHandler(unsigned button, ButtonHandler *h,
                                        unsigned mode,
                                        unsigned multiclickCardinality)
      {
        if(button < 0 || button >= numberOfButtons)
          ARCHON_THROW1(ArgumentException, "Invalid button");
        if(mode < 0 || mode >= numberOfModes)
          ARCHON_THROW1(ArgumentException, "Invalid mode");
        if(multiclickCardinality < 1 ||
           multiclickCardinality > maxMulticlickLimit)
          ARCHON_THROW1(ArgumentException, "Invalid multiclick cardinality");

        buttonHandlers[(button*numberOfModes + mode)*maxMulticlickLimit
                       + multiclickCardinality - 1] = h;
      }

      void Dispatcher::setMotionHandler(MotionHandler *h, unsigned mode)
      {
        if(mode < 0 || mode >= numberOfModes)
          ARCHON_THROW1(ArgumentException, "Invalid mode");

        motionHandlers[mode] = h;
      }

      void Dispatcher::press(unsigned button, unsigned x, unsigned y,
                             unsigned long millisecondTime)
      {
        if(button >= numberOfButtons) return;
        ButtonAccount &a = buttonAccounts[button];

        if(millisecondTime - a.lastClick < multiclickMaxDelay)
        {
          if(a.multiclickCounter < a.multiclickLimit) ++a.multiclickCounter;
        }
        else a.multiclickCounter = 1;
        a.lastClick = millisecondTime;
        a.clickMode = currentMode;
        ButtonHandler *h =
          buttonHandlers[(button*numberOfModes + currentMode)*
                         maxMulticlickLimit + a.multiclickCounter - 1];
        if(h) h->press(x, y);
      }

      void Dispatcher::release(unsigned button, unsigned x, unsigned y)
      {
        if(button >= numberOfButtons) return;
        ButtonAccount &a = buttonAccounts[button];
        ButtonHandler *h =
          buttonHandlers[(button*numberOfModes + a.clickMode)*
                         maxMulticlickLimit + a.multiclickCounter - 1];
        if(h) h->release(x, y);
      }

      void Dispatcher::motion(unsigned xAbs, unsigned yAbs,
                              int xRel, int yRel)
      {
        MotionHandler *h = motionHandlers[currentMode];
        if(h) h->move(xAbs, yAbs, xRel, yRel);
      }
    }
  }
}

---