Public API Reference

csutil/csinput.h

Go to the documentation of this file.

/*
    Crystal Space input library
    Copyright (C) 1998,2000 by Jorrit Tyberghein
    Written by Andrew Zabolotny <[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_CSINPUT_H__
#define __CS_CSINPUT_H__

#include "csextern.h"

#include "csutil/hash.h"
#include "csutil/scf_implementation.h"
#include "csutil/csstring.h"

#include "iutil/csinput.h"
#include "iutil/eventh.h"

struct iEvent;
struct iEventQueue;
struct iObjectRegistry;

class CS_CRYSTALSPACE_EXPORT csInputDriver
{
private:
  bool Registered;
protected:
  iObjectRegistry* Registry;
  csRef<iEventNameRegistry> NameRegistry;
  iEventHandler* Listener;
  csEventID FocusChanged;
  csEventID FocusGained;
  csEventID FocusLost;
  csInputDriver(iObjectRegistry*);
  virtual ~csInputDriver();
  csPtr<iEventQueue> GetEventQueue();
  virtual void GainFocus() = 0;
  virtual void LostFocus() = 0;
  virtual void Post(iEvent*);
  virtual bool HandleEvent(iEvent&);
  friend struct FocusListener;
  void StartListening();
  void StopListening();
};

class CS_CRYSTALSPACE_EXPORT csKeyComposer : 
  public scfImplementation1<csKeyComposer, iKeyComposer>
{
protected:
  utf32_char lastDead;

public:  
  csKeyComposer ();
  virtual ~csKeyComposer ();

  virtual csKeyComposeResult HandleKey (const csKeyEventData& keyEventData,
    utf32_char* buf, size_t bufChars, int* resultChars = 0);
  virtual void ResetState ();
};

#ifdef CS_DEBUG
  #ifndef CS_KEY_DEBUG_ENABLE

    #define CS_KEY_DEBUG_ENABLE
  #endif
#endif

class CS_CRYSTALSPACE_EXPORT csKeyboardDriver : public csInputDriver,
  public scfImplementation2<csKeyboardDriver, iKeyboardDriver, iEventHandler>
{
protected:
  csHash<bool, utf32_char> keyStates;
  csKeyModifiers modifiersState;
  bool keyDebug;
  bool keyDebugChecked;
  csEventID KeyboardUp;
  csEventID KeyboardDown;

  virtual void SetKeyState (utf32_char codeRaw, bool iDown,
    bool autoRepeat);
  virtual void SynthesizeCooked (utf32_char codeRaw,
    const csKeyModifiers& modifiers, utf32_char& codeCooked);

  const char* GetKeycodeString (utf32_char code);
  bool IsKeyboardDebugging ();

  virtual void LostFocus() { Reset(); }
  virtual void GainFocus() { RestoreKeys(); }

  virtual bool HandleEvent (iEvent& e)
  {
    return csInputDriver::HandleEvent (e);
  }
public:
  csKeyboardDriver (iObjectRegistry*);
  virtual ~csKeyboardDriver ();

  CS_EVENTHANDLER_NAMES("crystalspace.inputdriver.keyboard")
  CS_EVENTHANDLER_NIL_CONSTRAINTS

  virtual void Reset ();
  virtual void RestoreKeys ();

  virtual void DoKey (utf32_char codeRaw, utf32_char codeCooked, bool iDown,
    bool autoRepeat = false, csKeyCharType charType = csKeyCharTypeNormal);

  CS_PURE_METHOD virtual bool GetKeyState (utf32_char codeRaw) const;

  CS_PURE_METHOD virtual uint32 GetModifierState (utf32_char codeRaw) const;

  virtual csPtr<iKeyComposer> CreateKeyComposer ();

  virtual csEventError SynthesizeCooked (iEvent *);

};

class CS_CRYSTALSPACE_EXPORT csMouseDriver : public csInputDriver, 
  public scfImplementation2<csMouseDriver, iMouseDriver, iEventHandler>
{
private:
  // Generic keyboard driver (for checking modifier key states).
  csRef<iKeyboardDriver> Keyboard;

  virtual bool HandleEvent (iEvent& e)
  {
    return csInputDriver::HandleEvent (e);
  }
protected:
  csTicks LastClickTime[CS_MAX_MOUSE_COUNT];
  int LastClickButton[CS_MAX_MOUSE_COUNT];
  int LastClick [CS_MAX_MOUSE_COUNT][CS_MAX_MOUSE_AXES];
  int32 Last [CS_MAX_MOUSE_COUNT][CS_MAX_MOUSE_AXES];
  uint Axes [CS_MAX_MOUSE_COUNT];
  bool Button [CS_MAX_MOUSE_COUNT][CS_MAX_MOUSE_BUTTONS];
  csTicks DoubleClickTime;
  size_t DoubleClickDist;
  iKeyboardDriver* GetKeyboardDriver();

public:
  csMouseDriver (iObjectRegistry*);
  virtual ~csMouseDriver ();

  CS_EVENTHANDLER_NAMES("crystalspace.inputdriver.mouse")
  CS_EVENTHANDLER_NIL_CONSTRAINTS

  virtual void SetDoubleClickTime (int iTime, size_t iDist);

  virtual void Reset ();

  CS_PURE_METHOD virtual int GetLastX (uint n) const { return Last[n][0]; }
  CS_PURE_METHOD virtual int GetLastY (uint n) const { return Last[n][1]; }
  CS_PURE_METHOD virtual int GetLast (uint n, uint axis) const
  { return Last[n][axis]; }
  CS_PURE_METHOD virtual const int32 *GetLast (uint n) const
  { return Last [n]; }
  CS_PURE_METHOD virtual bool GetLastButton (int button) const
  { return GetLastButton(0, button); }
  CS_PURE_METHOD virtual bool GetLastButton (uint number, int button) const
  {
    return (number < CS_MAX_MOUSE_COUNT
            && button >= 0 && button < CS_MAX_MOUSE_BUTTONS) ?
            Button [number][button] : false;
  }

  virtual void DoButton (uint number, int button, bool down,
        const int32 *axes, uint numAxes);
  virtual void DoButton (int button, bool down, const int32 *axes,
        uint numAxes) 
  { DoButton (0, button, down, axes, numAxes); }
  virtual void DoButton (int button, bool down, int x, int y)
  { int32 axes[2] = {x, y}; DoButton (0, button, down, axes, 2); }
  virtual void DoMotion (uint number, const int32 *axes, uint numAxes);
  virtual void DoMotion (const int32 *axes, uint numAxes) 
  { DoMotion (0, axes, numAxes); }
  virtual void DoMotion (int x, int y)
  { int32 axes[2] = {x, y}; DoMotion (0, axes, 2); }
  virtual void LostFocus() { Reset(); }
  virtual void GainFocus() { }

};

#include "csutil/win32/msvc_deprecated_warn_off.h"

class CS_CRYSTALSPACE_EXPORT csJoystickDriver : public csInputDriver,
  public scfImplementation2<csJoystickDriver, iJoystickDriver, iEventHandler>
{
private:
  // Generic keyboard driver (for checking modifier key states).
  csRef<iKeyboardDriver> Keyboard;

protected:
  bool Button [CS_MAX_JOYSTICK_COUNT][CS_MAX_JOYSTICK_BUTTONS];
  int32 Last [CS_MAX_JOYSTICK_COUNT][CS_MAX_JOYSTICK_AXES];
  uint Axes [CS_MAX_JOYSTICK_COUNT];
  iKeyboardDriver* GetKeyboardDriver();
  virtual bool HandleEvent (iEvent& e)
  {
    return csInputDriver::HandleEvent (e);
  }
public:

  csJoystickDriver (iObjectRegistry*);
  virtual ~csJoystickDriver ();

  CS_EVENTHANDLER_NAMES("crystalspace.inputdriver.joystick")
  CS_EVENTHANDLER_NIL_CONSTRAINTS

  virtual void Reset ();

  CS_DEPRECATED_METHOD CS_PURE_METHOD virtual int GetLastX (uint number) const 
  { return Last [number][0]; }
  CS_DEPRECATED_METHOD CS_PURE_METHOD virtual int GetLastY (uint number) const 
  { return Last [number][0]; }
  CS_PURE_METHOD virtual const int32 *GetLast (uint number) const 
  { return Last [number]; }
  CS_PURE_METHOD virtual int GetLast (uint number, uint axis) const 
  { return Last [number][axis]; }
  CS_PURE_METHOD virtual bool GetLastButton (uint number, int button) const
  {
    return (number < CS_MAX_JOYSTICK_COUNT
         && button >= 0 && button < CS_MAX_JOYSTICK_BUTTONS) ?
            Button [number][button] : false;
  }

  virtual void DoButton (uint number, int button, bool down, 
    const int32 *axes, uint numAxes);
  virtual void DoMotion (uint number, const int32 *axes, uint numAxes);

  virtual void LostFocus() { Reset(); }
  virtual void GainFocus() { }

};

#include "csutil/win32/msvc_deprecated_warn_on.h"

#endif // __CS_CSINPUT_H__

---