Public API Reference

csutil/eventnames.h

Go to the documentation of this file.

/*
  Crystal Space 3D engine: Event and module naming interface
  (C) 2005 by Adam D. Bradley <[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_CSUTIL_EVENTNAMES_H__
#define __CS_CSUTIL_EVENTNAMES_H__

#include "cssysdef.h"
#include "csextern.h"
#include "csutil/scf_implementation.h"
#include "iutil/eventnames.h"
#include "iutil/objreg.h"
#include "csutil/hash.h"
#include "csutil/strset.h"
#include "csutil/csstring.h"

#ifndef CSHASHCOMPUTER_EVENTENGINE_IDS
#define CSHASHCOMPUTER_EVENTENGINE_IDS
template<>
class csHashComputer<const csEventID>
{
public:
  static uint ComputeHash (const csEventID eid) 
  {
    return (uint) eid;
  }
};
#endif // CSHASHCOMPUTER_EVENTENGINE_IDS


class CS_CRYSTALSPACE_EXPORT csEventNameRegistry :
  public scfImplementation1<csEventNameRegistry, iEventNameRegistry>
{
 private:
  csEventNameRegistry (iObjectRegistry *);
 public:
  ~csEventNameRegistry ();

  CS_CONST_METHOD csEventID GetID (const char* name);

  CS_CONST_METHOD const char * GetString (const csEventID id);
  static CS_CONST_METHOD const char * GetString (iObjectRegistry *object_reg, 
                                                 csEventID id);
  CS_CONST_METHOD csEventID GetParentID (const csEventID id);
  CS_CONST_METHOD bool IsImmediateChildOf (const csEventID child, 
                                           const csEventID parent);
  CS_CONST_METHOD bool IsKindOf (const csEventID child, 
                                 const csEventID parent);
  static csRef<iEventNameRegistry> GetRegistry(iObjectRegistry *object_reg);

  static inline csEventID GetID (iEventNameRegistry *name_reg,
                                 const char* name) 
  {
    if (name_reg != 0)
      return name_reg->GetID (name);
    else
      return CS_EVENT_INVALID;
  }
  static inline csEventID GetID (iObjectRegistry *object_reg, 
                                 const char* name)
  {
    csRef<iEventNameRegistry> nameRegistry = 
      csQueryRegistry<iEventNameRegistry> (object_reg);
    CS_ASSERT (nameRegistry);
    return nameRegistry->GetID (name);
  };

  static inline bool IsKindOf (iEventNameRegistry *name_reg,
                               csEventID name1, csEventID name2) 
  {
    if (name_reg != 0)
      return name_reg->IsKindOf(name1, name2);
    else
      return false;
  }
  static inline bool IsKindOf (iObjectRegistry *object_reg, 
                               csEventID name1, csEventID name2)
  {
    csRef<iEventNameRegistry> nameRegistry =
      csQueryRegistry<iEventNameRegistry> (object_reg);
    CS_ASSERT(nameRegistry);
    return nameRegistry->IsKindOf (name1, name2);
  };

 private:
  iObjectRegistry *object_reg;
  csHash<csEventID,csEventID> parentage;
  csStringSet names;
};


#define csevAllEvents(reg)            \
  (csEventNameRegistry::GetID((reg), ""))

#define csevFrame(reg)                \
  (csEventNameRegistry::GetID((reg), "crystalspace.frame"))

#define csevInput(reg)                \
  (csEventNameRegistry::GetID((reg), "crystalspace.input"))

#define csevKeyboardEvent(reg)        \
  (csEventNameRegistry::GetID((reg), "crystalspace.input.keyboard"))

#define csevKeyboardDown(reg)         \
  (csEventNameRegistry::GetID((reg), "crystalspace.input.keyboard.down"))

#define csevKeyboardUp(reg)           \
  (csEventNameRegistry::GetID((reg), "crystalspace.input.keyboard.up"))

#define csevMouseEvent(reg)           \
  (csEventNameRegistry::GetID((reg), "crystalspace.input.mouse"))

static inline CS_CONST_METHOD csEventID csevMouse (
  iEventNameRegistry *name_reg, uint x)
{
  csString name ("crystalspace.input.mouse.");
  name.Append (x);
  return name_reg->GetID(name);
}

static inline CS_CONST_METHOD csEventID csevMouse(
  iObjectRegistry *object_reg, uint x) 
{
  return csevMouse(csEventNameRegistry::GetRegistry(object_reg), x);
}

static inline CS_CONST_METHOD csEventID csevMouseOp(
  iEventNameRegistry *name_reg, uint x, const csString &y)
{
  csString name ("crystalspace.input.mouse.");
  name.Append (x);
  name.Append (".");
  name.Append (y);
  return name_reg->GetID(name);
}

static inline CS_CONST_METHOD csEventID csevMouseOp(
  iObjectRegistry *object_reg, uint x, const csString &y) 
{
  return csevMouseOp(csEventNameRegistry::GetRegistry(object_reg), x, y);
}

#define csevMouseButton(reg,x)        \
  csevMouseOp ((reg), (x), "button")

#define csevMouseDown(reg,x)          \
  csevMouseOp ((reg), (x), "button.down")

#define csevMouseUp(reg,x)            \
  csevMouseOp ((reg), (x), "button.up")

#define csevMouseClick(reg,x)         \
  csevMouseOp ((reg), (x), "button.click")

#define csevMouseDoubleClick(reg,x)   \
  csevMouseOp((reg), (x), "button.doubleclick")

#define csevMouseMove(reg,x)          \
  csevMouseOp((reg), (x), "move")

#define csevJoystickEvent(reg)        \
  (csEventNameRegistry::GetID((reg), "crystalspace.input.joystick"))

static inline CS_CONST_METHOD csEventID csevJoystick (
  iEventNameRegistry *name_reg, uint x) 
{
  char buffer[64];
  cs_snprintf(buffer, sizeof (buffer) - 1, "crystalspace.input.joystick.%d", 
    x);
  return name_reg->GetID(buffer);
}

static inline CS_CONST_METHOD csEventID csevJoystick (
  iObjectRegistry *object_reg, uint x)
{
  return csevJoystick(csEventNameRegistry::GetRegistry(object_reg), x);
}

static inline CS_CONST_METHOD csEventID csevJoystickOp (
  iEventNameRegistry *name_reg, uint x, const csString &y) 
{
  csString name ("crystalspace.input.joystick.");
  name.Append (x);
  name.Append (".");
  name.Append (y);
  return name_reg->GetID(name);
}

static inline CS_CONST_METHOD csEventID csevJoystickOp (
  iObjectRegistry *object_reg, uint x, const csString &y)
{
  return csevJoystickOp (csEventNameRegistry::GetRegistry(object_reg), x, y);
}

#define csevJoystickButton(reg,x)     \
  csevJoystickOp((reg),(x),"button")

#define csevJoystickDown(reg,x)       \
  csevJoystickOp((reg),(x),"button.down")

#define csevJoystickUp(reg,x)         \
  csevJoystickOp((reg),(x),"button.up")

#define csevJoystickMove(reg,x)       \
  csevJoystickOp((reg),(x),"move")

#define CS_IS_KEYBOARD_EVENT(reg,e)   \
  csEventNameRegistry::IsKindOf((reg), ((e).Name), csevKeyboardEvent(reg))

#define CS_IS_MOUSE_EVENT(reg,e)      \
  csEventNameRegistry::IsKindOf((reg), ((e).Name), csevMouseEvent(reg))

#define CS_IS_MOUSE_BUTTON_EVENT(reg,e,n) \
  csEventNameRegistry::IsKindOf((reg), ((e).Name), csevMouseButton((reg),n))

#define CS_IS_MOUSE_MOVE_EVENT(reg,e,n) \
  csEventNameRegistry::IsKindOf((reg), ((e).Name), csevMouseMove((reg),n))

#define CS_IS_JOYSTICK_EVENT(reg,e)   \
  csEventNameRegistry::IsKindOf((reg), ((e).Name), csevJoystickEvent(reg))

#define CS_IS_JOYSTICK_BUTTON_EVENT(reg,e,n) \
  csEventNameRegistry::IsKindOf((reg), ((e).Name), csevJoystickButton((reg),n))

#define CS_IS_JOYSTICK_MOVE_EVENT(reg,e,n) \
  csEventNameRegistry::IsKindOf((reg), ((e).Name), csevJoystickMove((reg),n))

#define CS_IS_INPUT_EVENT(reg,e)      \
  csEventNameRegistry::IsKindOf((reg), ((e).Name), csevInput(reg))

#define csevQuit(reg)                 \
  (csEventNameRegistry::GetID((reg), "crystalspace.application.quit"))

#define csevFocusChanged(reg)         \
  (csEventNameRegistry::GetID((reg), "crystalspace.application.focus"))

#define csevFocusGained(reg)          \
  (csEventNameRegistry::GetID((reg), "crystalspace.application.focus.gained"))

#define csevFocusLost(reg)            \
  (csEventNameRegistry::GetID((reg), "crystalspace.application.focus.lost"))

#define csevSystemOpen(reg)           \
  (csEventNameRegistry::GetID((reg), "crystalspace.application.open"))

#define csevSystemClose(reg)          \
  (csEventNameRegistry::GetID((reg), "crystalspace.application.close"))

struct iGraphics2D;

CS_CRYSTALSPACE_EXPORT
CS_CONST_METHOD csEventID csevCanvasOp (csRef<iEventNameRegistry>& reg, 
                                        const iGraphics2D* g2d, 
                                        const csString &y);
static inline CS_CONST_METHOD csEventID csevCanvasOp (
  iObjectRegistry *object_reg, const iGraphics2D* g2d, const csString &y)
{
  csRef<iEventNameRegistry> name_reg = csEventNameRegistry::GetRegistry (object_reg);
  return csevCanvasOp(name_reg, g2d, y);
}


#define csevCanvasResize(reg, g2d)      \
  csevCanvasOp((reg), (g2d), "resize")

#define csevCanvasClose(reg, g2d)             \
  csevCanvasOp((reg), (g2d), "close")

#define csevCanvasHidden(reg, g2d)      \
  csevCanvasOp((reg), (g2d), "hidden")

#define csevCanvasExposed(reg, g2d)     \
  csevCanvasOp((reg), (g2d), "exposed")

#define csevCommandLineHelp(reg)      \
  (csEventNameRegistry::GetID((reg), "crystalspace.application.commandlinehelp"))

CS_CRYSTALSPACE_EXPORT csEventID csevPreProcess(iObjectRegistry *reg);
CS_CRYSTALSPACE_EXPORT csEventID csevPreProcess(iEventNameRegistry *reg);

CS_CRYSTALSPACE_EXPORT csEventID csevProcess(iObjectRegistry *reg);
CS_CRYSTALSPACE_EXPORT csEventID csevProcess(iEventNameRegistry *reg);

CS_CRYSTALSPACE_EXPORT csEventID csevPostProcess(iObjectRegistry *reg);
CS_CRYSTALSPACE_EXPORT csEventID csevPostProcess(iEventNameRegistry *reg);

CS_CRYSTALSPACE_EXPORT csEventID csevFinalProcess(iObjectRegistry *reg);
CS_CRYSTALSPACE_EXPORT csEventID csevFinalProcess(iEventNameRegistry *reg);

#define CS_DECLARE_SYSTEM_EVENT_SHORTCUTS                       \
  csEventID SystemOpen;                                         \
  csEventID SystemClose

#define CS_DECLARE_FRAME_EVENT_SHORTCUTS                        \
  csEventID Frame;                                              \
  csEventID PreProcess;                                         \
  csEventID Process;                                            \
  csEventID PostProcess;                                        \
  csEventID FinalProcess

#define CS_DECLARE_INPUT_EVENT_SHORTCUTS                        \
  csEventID KeyboardEvent;                                      \
  csEventID MouseEvent;                                         \
  csEventID JoystickEvent

#define CS_DECLARE_EVENT_SHORTCUTS                              \
  CS_DECLARE_SYSTEM_EVENT_SHORTCUTS;                            \
  CS_DECLARE_FRAME_EVENT_SHORTCUTS;                             \
  CS_DECLARE_INPUT_EVENT_SHORTCUTS

#define CS_INITIALIZE_SYSTEM_EVENT_SHORTCUTS(object_reg) do {   \
    SystemOpen = csevSystemOpen ((object_reg));                 \
    SystemClose = csevSystemClose ((object_reg));               \
  } while (0)

#define CS_INITIALIZE_FRAME_EVENT_SHORTCUTS(object_reg) do {    \
    Frame = csevFrame ((object_reg));                           \
    PreProcess = csevPreProcess ((object_reg));                 \
    Process = csevProcess ((object_reg));                       \
    PostProcess = csevPostProcess ((object_reg));               \
    FinalProcess = csevFinalProcess ((object_reg));             \
  } while (0)

#define CS_INITIALIZE_INPUT_EVENT_SHORTCUTS(object_reg) do {    \
    KeyboardEvent = csevKeyboardEvent ((object_reg));           \
    MouseEvent = csevMouseEvent ((object_reg));                 \
    JoystickEvent = csevJoystickEvent ((object_reg));           \
  } while (0)

#define CS_INITIALIZE_EVENT_SHORTCUTS(object_reg) do {  \
    CS_INITIALIZE_SYSTEM_EVENT_SHORTCUTS (object_reg);  \
    CS_INITIALIZE_FRAME_EVENT_SHORTCUTS (object_reg);   \
    CS_INITIALIZE_INPUT_EVENT_SHORTCUTS (object_reg);   \
  } while (0)

#endif // __CS_CSUTIL_EVENTNAMES_H__

---