---

OgreEventMulticaster.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://ogre.sourceforge.net/

Copyright © 2000-2002 The OGRE Team
Also see acknowledgements in Readme.html

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

This program 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 Lesser General  License for more details.

You should have received a copy of the GNU Lesser General  License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/

/***************************************************************************
OgreEventMulticaster.h  -  
      This class implements efficient and thread-safe multi-cast event 
      dispatching.  
      It will manage an immutable structure consisting of a binary chain of 
      event listeners and will dispatch events to those listeners.  Because
      the structure is immutable, it is safe to use this API to add/remove
      listeners during the process of an event dispatch operation.
     
      An example of how this class could be used to implement a new
      component which fires "action" events:
     
       // member variable
      ActionListener* mActionListener;
     
      void addActionListener(ActionListener* l) 
      {
         mActionListener = EventMulticaster::add(mActionListener, l);
      }
      void removeActionListener(ActionListener* l) 
      {
         mActionListener = EventMulticaster::remove(mActionListener, l);
      }
      void processEvent(InputEvent* e) 
      {
          // when event occurs which is an action
          if (mActionListener != NULL) 
          {
              mActionListener->actionPerformed(static_cast<ActionEvent*>(e));
          }         
      }

-------------------
begin                : Nov 19 2002
copyright            : (C) 2002 by Kenny Sabir
email                : kenny@sparksuit.com
***************************************************************************/

#ifndef __EVENT_MULTICASTER_H__
#define __EVENT_MULTICASTER_H__

#include "OgrePrerequisites.h"
#include "OgreEventListeners.h"


namespace Ogre {

    class _OgreExport EventMulticaster :  public MouseListener, public ActionListener
    {
    public:



        EventMulticaster(EventListener* a, EventListener* b);

         void listSelected(ListSelectionEvent* e);


         void actionPerformed(ActionEvent* e);

         static MouseListener* add(MouseListener* a, MouseListener* b);
         static ActionListener* add(ActionListener* a, ActionListener* b);
         static MouseMotionListener* add(MouseMotionListener* a, MouseMotionListener* b) ;
         static ListSelectionListener* add(ListSelectionListener* a, ListSelectionListener* b) ;

//       static KeyListener* add(KeyListener* a, KeyListener* b);

//       static TextListener* add(TextListener* a, TextListener* b);



//       void keyPressed(KeyEvent* e);

//       void keyReleased(KeyEvent* e);

//       void keyTyped(KeyEvent* e);

         void mouseClicked(MouseEvent* e);

         void mouseDragged(MouseEvent* e);

         void mouseEntered(MouseEvent* e);

         void mouseExited(MouseEvent* e);

         void mouseMoved(MouseEvent* e);

         void mousePressed(MouseEvent* e);

         void mouseReleased(MouseEvent* e);

         static ActionListener* remove(ActionListener* l, ActionListener* oldl);

         static ListSelectionListener* remove(ListSelectionListener* l, ListSelectionListener* oldl);

//       static KeyListener* remove(KeyListener* l, KeyListener* oldl);

         static MouseMotionListener* remove(MouseMotionListener* l, MouseMotionListener* oldl);

         static MouseListener* remove(MouseListener* l, MouseListener* oldl);

//       static TextListener* remove(TextListener* l, TextListener* oldl);

         EventListener* remove(EventListener* oldl, bool& deleteSelf) ;

        virtual bool isMulticaster();


    protected:
        EventListener* mA;
        EventListener* mB;

         static EventListener* removeInternal(EventListener* l, EventListener* oldl);

         static EventListener* addInternal(EventListener* a, EventListener* b) ;

         static EventListener* convertMultiToListener(EventMulticaster* m);

         static EventMulticaster* convertListenerToMulti(EventListener* l);

    };



}


#endif //__EVENT_MULTICASTER_H__

Copyright © 2002 by The OGRE Team