Public API Reference

csutil/inputdef.h

Go to the documentation of this file.

/*
    Crystal Space input library
    Copyright (C) 2000 by Andrew Zabolotny <[email protected]>
    Copyright (C) 2002, 04 by Mathew Sutcliffe <[email protected]>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_UTIL_INPUTDEF_H__
#define __CS_UTIL_INPUTDEF_H__

#include "csextern.h"

#include "csutil/csstring.h"
#include "csutil/comparator.h"
#include "csutil/eventnames.h"
#include "csutil/hash.h"

#include "iutil/evdefs.h"
#include "iutil/event.h"

struct iEvent;
class csInputBinder;

class CS_CRYSTALSPACE_EXPORT csInputDefinition
{
public:
  csRef<iEventNameRegistry> name_reg;

protected:
  csEventID containedName;

  uint32 modifiersHonored;
  csKeyModifiers modifiers;
  // The (basis-0) identifier for the device from which this event came
  uint deviceNumber;
  union
  {
    struct
    {
      utf32_char code;
      bool isCooked;
    } keyboard;
    int mouseButton;
    int mouseAxis;
    int joystickButton;
    int joystickAxis;
  };

  void Initialize (uint32 honorModifiers, bool useCookedCode);
  void InitializeFromEvent (iEvent *ev);

  friend class csInputBinder;

public:
  csInputDefinition (iEventNameRegistry* name_reg, 
                     uint32 honorModifiers = 0, bool useCookedCode = false);

  csInputDefinition (const csInputDefinition &other);

  csInputDefinition (iEventNameRegistry* name_reg, iEvent *event,
                     uint32 honorModifiers = 0, bool useCookedCode = false);

  csInputDefinition (iEventNameRegistry* name_reg, iEvent *event, uint8 axis);

  csInputDefinition (iEventNameRegistry* name_reg, const char *string,
                     uint32 honorModifiers = 0, bool useCookedCode = false);

  csString ToString (bool distinguishModifiers = true) const;

  bool IsValid () const;

  csEventID GetName () const { return containedName; }

  void SetName (csEventID n) { containedName = n; }

  bool GetKeyCode (utf32_char &code, bool &isCooked) const
  { code = keyboard.code;
    isCooked = keyboard.isCooked;
    return (containedName == csevKeyboardEvent(name_reg)); }

  bool SetKeyCode (utf32_char code)
  { if (containedName != csevKeyboardEvent(name_reg)) return false;
    keyboard.code = code;
    return true; }

  int GetNumber () const { return mouseButton; }

  void SetNumber (int n) { mouseButton = n; }

  const csKeyModifiers& GetModifiers () const { return modifiers; }

  const uint GetDeviceNumber () const { return deviceNumber; }

  void SetModifiers (const csKeyModifiers &mods) { modifiers = mods; }

  uint32 ComputeHash () const;

  int Compare (csInputDefinition const &) const;

  static bool ParseKey (iEventNameRegistry* reg, 
                        const char *iStr, utf32_char *oKeyCode,
                        utf32_char *oCookedCode, csKeyModifiers *oModifiers);

  static bool ParseOther (iEventNameRegistry* reg, 
                          const char *iStr, csEventID *oType, uint *oDevice,
                          int *oNumeric, csKeyModifiers *oModifiers);

  static csString GetKeyString (iEventNameRegistry* reg,
                                utf32_char code, const csKeyModifiers *mods,
                                bool distinguishModifiers = true);

  static csString GetOtherString (iEventNameRegistry* reg,
                                  csEventID type, uint device, int num, 
                                  const csKeyModifiers *mods,
                                  bool distinguishModifiers = true);
};

template<>
class csComparator<csInputDefinition, csInputDefinition>
{
public:
  static int Compare (csInputDefinition const& r1, csInputDefinition const& r2)
  {
    return r1.Compare (r2);
  }
};

template<>
class csHashComputer<csInputDefinition>
{
public:
  static uint ComputeHash (csInputDefinition const& key)
  {
    return key.ComputeHash (); 
  }
};

#endif // __CS_UTIL_INPUTDEF_H__

---