keyboard.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 <archon/util/keyboard.H>

namespace Archon
{
  namespace Utilities
  {
    namespace KeyboardEvents
    {
      Dispatcher::Dispatcher(unsigned numberOfModes,
                             unsigned maxMultipressLimit,
                             unsigned long multipressMaxDelay):
        numberOfModes(numberOfModes),
        maxMultipressLimit(maxMultipressLimit),
        multipressMaxDelay(multipressMaxDelay),
        currentMode(0)
      {
        if(maxMultipressLimit < 1)
          ARCHON_THROW1(ArgumentException, "Invalid multipress limit");

        keyAccounts = new KeyAccount[_key_last];

        handlers =
          new Handler *[_key_last *
                        numberOfModes *
                        maxMultipressLimit];

        for(unsigned i=0; i<_key_last *
              numberOfModes * maxMultipressLimit; ++i)
          handlers[i] = 0;
      }

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

      void Dispatcher::setMultipressLimit(Key key,
                                          unsigned limit)
      {
        if(key < 0 || key >= _key_last)
          ARCHON_THROW1(ArgumentException, "Invalid key");
        if(limit < 1 || limit > maxMultipressLimit)
          ARCHON_THROW1(ArgumentException, "Invalid multipress limit");

        keyAccounts[key].multipressLimit = limit;
      }

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

      void Dispatcher::setHandler(Key key, Handler *h,
                                  unsigned mode,
                                  unsigned multipressCardinality)
      {
        if(key < 0 || key >= _key_last)
          ARCHON_THROW1(ArgumentException, "Invalid key");
        if(mode < 0 || mode >= numberOfModes)
          ARCHON_THROW1(ArgumentException, "Invalid mode");
        if(multipressCardinality < 1 ||
           multipressCardinality > maxMultipressLimit)
          ARCHON_THROW1(ArgumentException, "Invalid multipress cardinality");

        handlers[(key*numberOfModes + mode)*maxMultipressLimit
                 + multipressCardinality - 1] = h;
      }

      void Dispatcher::press(Key key,
                             unsigned long millisecondTime)
      {
        if(key >= _key_last) return;
        KeyAccount &a = keyAccounts[key];

        if(millisecondTime - a.lastPress < multipressMaxDelay)
        {
          if(a.multipressCounter < a.multipressLimit) ++a.multipressCounter;
        }
        else a.multipressCounter = 1;
        a.lastPress = millisecondTime;
        a.pressMode = currentMode;
        Handler *h =
          handlers[(key*numberOfModes + currentMode)*maxMultipressLimit
                   + a.multipressCounter - 1];
        if(h) h->press();
      }

      void Dispatcher::release(Key key)
      {
        if(key >= _key_last) return;
        KeyAccount &a = keyAccounts[key];
        Handler *h =
          handlers[(key*numberOfModes + a.pressMode)*maxMultipressLimit
                   + a.multipressCounter - 1];
        if(h) h->release();
      }
    }
  }
}

---