OgreEventProcessor.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://www.ogre3d.org/

Copyright (c) 2000-2005 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 Public 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 Public License for more details.

You should have received a copy of the GNU Lesser General Public 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.
-----------------------------------------------------------------------------
*/
/***************************************************************************
OgreEventProcessor.h  -  
    The EventProcessor controls getting events, storing them in a queue, and 
    dispatching events.
    It contains an InputDevice which creates InputEvents. The events are then
    stored FIFO in the EventQueue. 

    The EventProcessor is a frame listener, so each frame, it empties the entire
    queue to the list of dispatchers.

    Each dispatcher corresponds to a registered TargetManager.

    The TargetManagers need to be registered with the Processor before initialise is called.

    After intialise is called, the Processor will start processing events once startProcessingEvents is called.

    The Processor acts like a default EventTarget, so it can process events that no dispatcher consumes.
    You can listen default actions to the processor by e.g.
        mProcessor->addMouseListener(defaultMouseMovement);

    WARNING: The event objects are created in InputReader when they are submitted to the queue
    , yet destroyed in the Event Processor when they are taken off the queue.
    Deleting objects in different locations to where they are created is usually undesirable, however,
    since the Processor, queue and InputReader are tightly coupled (only the Processor is visible to the outside)
    this can be an exception.
    The reason for this is for performance... The alternative, is to do 2 more event copies when sending events to the queue,
    so the queue manages creating (copying the event from the inputReader) and deleting objects once popped - however
    this would require the events to be copied twice.. So I have avoided this by having the same event object passed around
    and not copied.
-------------------
begin                : Nov 19 2002
copyright            : (C) 2002 by Kenny Sabir
email                : kenny@sparksuit.com
***************************************************************************/

#ifndef __EventProcessor_H__
#define __EventProcessor_H__

#include <list>
#include "OgrePrerequisites.h"
#include "OgreSingleton.h"
#include "OgreFrameListener.h"
#include "OgreMouseTarget.h"
#include "OgreKeyTarget.h"
#include "OgreMouseMotionTarget.h"

namespace Ogre {
    class _OgreExport EventProcessor : public FrameListener, public MouseTarget, public MouseMotionTarget, public Singleton<EventProcessor>, public KeyTarget
    {
    protected:
        EventQueue* mEventQueue;
        void cleanup();
        InputReader* mInputDevice;
        typedef std::list<EventDispatcher*> DispatcherList;
        typedef std::list<EventTarget*> EventTargetList;
        DispatcherList mDispatcherList;
        EventTargetList mEventTargetList;
        bool mRegisteredAsFrameListener;

    public:
        EventProcessor();
        virtual ~EventProcessor();

        void startProcessingEvents(bool registerListener=true);

        void stopProcessingEvents();

        void initialise(RenderWindow* ren);

        void processEvent(InputEvent* e);

        void addCursorMoveListener(MouseMotionListener* c);

        void removeCursorMoveListener(MouseMotionListener* c);

        void addTargetManager(TargetManager* targetManager);

        void addEventTarget(EventTarget* eventTarget);

        bool frameStarted(const FrameEvent& evt);

        // PositionTarget methods
        Real getTop() const;

        Real getLeft() const;

        PositionTarget* getPositionTargetParent() const;



        bool isKeyEnabled() const
        { return true; }

        inline InputReader* getInputReader()
        { return mInputDevice; }
        static EventProcessor& getSingleton(void);
        static EventProcessor* getSingletonPtr(void);
    };



}


#endif //__EventProcessor_H__

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:44 2006