Public API Reference

csutil/csbaseeventh.h

Go to the documentation of this file.

/*
    Copyright (C) 2003 by Odes B. Boatwright.

    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_CSBASEEVENTH_H__
#define __CS_CSBASEEVENTH_H__

#include "csextern.h"

#include "csutil/eventhandlers.h"
#include "csutil/ref.h"
#include "csutil/scf_implementation.h"
#include "iutil/event.h"
#include "iutil/eventh.h"
#include "iutil/eventq.h"

#include <limits.h>

struct iEventQueue;
struct iObjectRegistry;

// Max event type (in event type enumeration) that will be handled.
#define _CSBASEEVENT_MAXARRAYINDEX csevFrameStart

class CS_CRYSTALSPACE_EXPORT csBaseEventHandler
{
private:
  csRef<iEventQueue> queue;

protected:
  iObjectRegistry *object_registry;
  csHandlerID self;
  csEventID FrameEvent;

  class CS_CRYSTALSPACE_EXPORT EventHandlerImpl : public 
    scfImplementation1<EventHandlerImpl, iEventHandler>
  {
    friend class csBaseEventHandler;
    csBaseEventHandler* parent;
  public:
    EventHandlerImpl (csBaseEventHandler* parent);
    virtual bool HandleEvent (iEvent &event)
    {
      if (!parent) return false;
      return parent->HandleEvent (event);
    }
    virtual const char *GenericName() const 
    { 
      if (!parent) return "application"; 
      return parent->GenericName();
    }
    virtual csHandlerID GenericID(
      csRef<iEventHandlerRegistry>& reg) const 
    { 
      if (!parent) return CS_HANDLER_INVALID;
      return parent->GenericID (reg);
    }
    virtual const csHandlerID *GenericPrec (
      csRef<iEventHandlerRegistry>& hreg, csRef<iEventNameRegistry>& nreg, 
      csEventID id) const 
    { 
      if (!parent) return 0; 
      return parent->GenericPrec (hreg, nreg, id);
    }
    virtual const csHandlerID *GenericSucc (
      csRef<iEventHandlerRegistry>& hreg, csRef<iEventNameRegistry>& nreg, 
      csEventID id) const 
    { 
      if (!parent) return 0; 
      return parent->GenericSucc (hreg, nreg, id);
    }
    virtual const csHandlerID *InstancePrec (
      csRef<iEventHandlerRegistry>& hreg, csRef<iEventNameRegistry>& nreg, 
      csEventID id) const 
    { 
      if (!parent) return 0; 
      return parent->InstancePrec (hreg, nreg, id);
    }
    virtual const csHandlerID *InstanceSucc(
      csRef<iEventHandlerRegistry>& hreg, csRef<iEventNameRegistry>& nreg, 
      csEventID id) const 
    { 
      if (!parent) return 0; 
      return parent->InstanceSucc (hreg, nreg, id);
    }
  };
  csRef<EventHandlerImpl> eventh;

  csBaseEventHandler ();

public:
  virtual ~csBaseEventHandler ();

  void Initialize (iObjectRegistry *registry);

  bool RegisterQueue (iObjectRegistry* registry, csEventID name);

  bool RegisterQueue (iObjectRegistry* registry, csEventID names[]);

  bool RegisterQueue (iEventQueue* queue, csEventID name);
  bool RegisterQueue (iEventQueue* queue, csEventID names[]);
  void UnregisterQueue ();

protected:
  virtual bool HandleEvent (iEvent &event);

  virtual const char *GenericName() const 
  { return "application"; }
  
  virtual csHandlerID GenericID (
    csRef<iEventHandlerRegistry>& reg) const 
  { 
    return reg->GetGenericID (GenericName ()); 
  }

  virtual const csHandlerID *GenericPrec (
    csRef<iEventHandlerRegistry>&, csRef<iEventNameRegistry>&, 
    csEventID) const 
  { return 0; }

  virtual const csHandlerID *GenericSucc (
    csRef<iEventHandlerRegistry>&, csRef<iEventNameRegistry>&, 
    csEventID) const 
  { return 0; }

  virtual const csHandlerID *InstancePrec (
    csRef<iEventHandlerRegistry>&, csRef<iEventNameRegistry>&, 
    csEventID) const 
  { return 0; }

  virtual const csHandlerID *InstanceSucc (
    csRef<iEventHandlerRegistry>&, csRef<iEventNameRegistry>&, 
    csEventID) const 
  { return 0; }

  virtual bool OnJoystickMove (iEvent &event);

  virtual bool OnJoystickDown (iEvent &event);

  virtual bool OnJoystickUp (iEvent &event);

  virtual bool OnKeyboard (iEvent &event);

  virtual bool OnMouseMove (iEvent &event);

  virtual bool OnMouseDown (iEvent &event);

  virtual bool OnMouseUp (iEvent &event);

  virtual bool OnMouseClick (iEvent &event);

  virtual bool OnMouseDoubleClick (iEvent &event);

  virtual bool OnUnhandledEvent (iEvent &event);

  virtual void Frame ();
  
  // Compatibility methods
  CS_DEPRECATED_METHOD_MSG("Use signpost event handlers for frame preprocessing")
  virtual void PreProcessFrame () {}
  CS_DEPRECATED_METHOD_MSG("Use Frame() method for main frame processing")
  virtual void ProcessFrame () {}
  CS_DEPRECATED_METHOD_MSG("Use signpost event handlers for frame postprocessing")
  virtual void PostProcessFrame () {}
  CS_DEPRECATED_METHOD_MSG("Use FramePrinter for frame finishing or "
    "signpost event handlers for frame finalization")
  virtual void FinishFrame () {}
};

#endif //__CS_CSBASEEVENTH_H__

---