Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

OgreEventDispatcher.cpp

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright © 2000-2002 The OGRE Team
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 -----------------------------------------------------------------------------
00024 */
00025 #include "OgreStableHeaders.h"
00026 
00027 #include "OgreMouseEvent.h"
00028 #include "OgreEventDispatcher.h"
00029 #include "OgreGuiContainer.h"
00030 #include "OgreTargetManager.h"
00031 #include "OgreEventProcessor.h"
00032 #include "OgrePositionTarget.h"
00033 #include "OgreKeyEvent.h"
00034 
00035 namespace Ogre {
00036 
00037     EventDispatcher::EventDispatcher(TargetManager* pTargetManager)
00038         :mTargetManager(pTargetManager) // abstract this out TODO
00039     {
00040         mFocus = 0;
00041         mMouseDragSource = 0;
00042         mKeyCursorOn = 0;
00043         mEventMask = 0;
00044         mTargetLastEntered = 0;
00045         mMouseX = 0;
00046         mMouseY = 0;
00047         mDragging = false;
00048         mDragDropOn = false;
00049         mDragDropActive = false;
00050     }
00051 
00052     //---------------------------------------------------------------------
00053     EventDispatcher::~EventDispatcher()
00054     {
00055     }
00056 
00057     //---------------------------------------------------------------------
00058     bool EventDispatcher::dispatchEvent(InputEvent* e) 
00059     {
00060         bool ret = false;
00061         if (e->isEventBetween(MouseEvent::ME_FIRST_EVENT, MouseEvent::ME_LAST_EVENT))   // i am open to suggestions for a better way to do this
00062                                                                                         // maybe a method e->isEvent(InputEvent::MouseEvent) ??
00063         {
00064             MouseEvent* me = static_cast<MouseEvent*> (e);
00065             ret = processMouseEvent(me);
00066         }
00067         else if (e->isEventBetween(KeyEvent::KE_FIRST_EVENT, KeyEvent::KE_LAST_EVENT))
00068         {
00069             KeyEvent* ke = static_cast<KeyEvent*> (e);
00070             ret = processKeyEvent(ke);
00071 
00072         }
00073         return ret;
00074     }
00075 
00076     //---------------------------------------------------------------------
00077     void EventDispatcher::setDragDrop(bool dragDropOn)
00078     {
00079         mDragDropOn = dragDropOn;
00080     }
00081 
00082     //---------------------------------------------------------------------
00083     bool EventDispatcher::processKeyEvent(KeyEvent* e) 
00084     {
00085         if (mKeyCursorOn != 0)
00086         {
00087             mKeyCursorOn->processEvent(e);
00088         }
00089         return e->isConsumed();
00090     }
00091     
00092     //---------------------------------------------------------------------
00093     bool EventDispatcher::processMouseEvent(MouseEvent* e) 
00094     {
00095         PositionTarget* targetOver;
00096 
00097         mMouseX = e->getX();
00098         mMouseY = e->getY();
00099 
00100         targetOver = mTargetManager->getPositionTargetAt(e->getX(), e->getY());
00101         trackMouseEnterExit(targetOver, e);
00102 
00103         switch (e->getID())
00104         {       
00105         case MouseEvent::ME_MOUSE_PRESSED:
00106             mDragging = true;
00107             if (mDragDropOn)
00108                 mDragDropActive = true;
00109             mMouseDragSource = targetOver;
00110             retargetMouseEvent(targetOver, e);
00111             trackKeyEnterExit(targetOver, e);
00112             break;
00113 
00114         case MouseEvent::ME_MOUSE_RELEASED:
00115             if (targetOver != 0)
00116             {
00117                 if (targetOver == mMouseDragSource)
00118                 {
00119                     retargetMouseEvent(mMouseDragSource, MouseEvent::ME_MOUSE_CLICKED, e);
00120                 }
00121                 else // i.e. targetOver != mMouseDragSource
00122                 {
00123                     if (mDragDropActive)
00124                         retargetMouseEvent(targetOver, MouseEvent::ME_MOUSE_DRAGDROPPED, e);
00125                     retargetMouseEvent(targetOver, MouseEvent::ME_MOUSE_ENTERED, e);
00126                 }
00127             }
00128 
00129             retargetMouseEvent(mMouseDragSource, e);
00130 
00131             mDragging = false;
00132             mDragDropActive = false;
00133             mMouseDragSource = 0;
00134             break;
00135 
00136         case MouseEvent::ME_MOUSE_MOVED:
00137         case MouseEvent::ME_MOUSE_DRAGGED:
00138             if (!mDragging || targetOver == mMouseDragSource)
00139             {
00140                 retargetMouseEvent(targetOver, e);
00141             }
00142             else // i.e. mDragging && targetOver != mMouseDragSource
00143             {
00144                 retargetMouseEvent(mMouseDragSource, MouseEvent::ME_MOUSE_DRAGGED, e, true);
00145                 if (mDragDropActive)
00146                     retargetMouseEvent(targetOver, MouseEvent::ME_MOUSE_DRAGMOVED, e);
00147             }
00148             break;
00149         }
00150 
00151         return e->isConsumed();
00152     }
00153 
00154     //---------------------------------------------------------------------
00155     void EventDispatcher::retargetMouseEvent(PositionTarget* target, MouseEvent* e) 
00156     {
00157         if (target == NULL)
00158         {
00159             return;
00160         }
00161 
00162         MouseEvent* retargeted = new MouseEvent(target,
00163                                                e->getID(), 
00164                                                e->getButtonID(),
00165                                                e->getWhen(), 
00166                                                e->getModifiers(),
00167                                                e->getX(), 
00168                                                e->getY(), 
00169                                                e->getZ(),
00170                                                e->getClickCount());
00171 
00172         target->processEvent(retargeted);       
00173         delete retargeted;
00174         
00175         e->consume();
00176     }
00177 
00178     //---------------------------------------------------------------------
00179     void EventDispatcher::retargetMouseEvent(PositionTarget* target, int id, MouseEvent* e, bool consume) 
00180     {
00181         if (target == NULL)
00182         {
00183             return;
00184         }
00185 
00186         MouseEvent* retargeted = new MouseEvent(target,
00187                                                id, 
00188                                                e->getButtonID(),
00189                                                e->getWhen(), 
00190                                                e->getModifiers(),
00191                                                e->getX(), 
00192                                                e->getY(), 
00193                                                e->getZ(),
00194                                                e->getClickCount());
00195 
00196         target->processEvent(retargeted);       
00197         delete retargeted;
00198 
00199         if (consume)
00200             e->consume();
00201     }
00202 
00203     //---------------------------------------------------------------------
00204     void EventDispatcher::retargetKeyEvent(PositionTarget* target, int id, MouseEvent* e) 
00205     {
00206         if (target == NULL)
00207         {
00208             return;
00209         }
00210 
00211         KeyEvent* retargeted = new KeyEvent(target,
00212                                                id,
00213                                                0,
00214                                                e->getWhen(), 
00215                                                e->getModifiers());
00216 
00217         target->processEvent(retargeted);       
00218         delete retargeted;
00219     }
00220 
00221     //---------------------------------------------------------------------
00222     void EventDispatcher::trackMouseEnterExit(PositionTarget* targetOver, MouseEvent* e) 
00223     {
00224         if (mTargetLastEntered == targetOver)
00225         {
00226             return;
00227         }
00228 
00229         if (mTargetLastEntered != 0)
00230         {
00231             if (!mDragging || mTargetLastEntered == mMouseDragSource)
00232             {
00233                 retargetMouseEvent(mTargetLastEntered, MouseEvent::ME_MOUSE_EXITED, e);
00234             }
00235             else if (mDragDropActive) // i.e. mDragging && mTargetLastEntered != mMouseDragSource && mDragDropActive
00236             {
00237                 retargetMouseEvent(mTargetLastEntered, MouseEvent::ME_MOUSE_DRAGEXITED, e);
00238             }
00239         }
00240 
00241         if (targetOver != 0)
00242         {
00243             if (!mDragging || targetOver == mMouseDragSource)
00244             {
00245                 retargetMouseEvent(targetOver, MouseEvent::ME_MOUSE_ENTERED, e);
00246             }
00247             else if (mDragDropActive) // i.e. mDragging && targetOver != mMouseDragSource && mDragDropActive
00248             {
00249                 retargetMouseEvent(targetOver, MouseEvent::ME_MOUSE_DRAGENTERED, e);
00250             }
00251         }
00252 
00253         mTargetLastEntered = targetOver;
00254     }
00255 
00256     //---------------------------------------------------------------------
00257     void EventDispatcher::trackKeyEnterExit(PositionTarget* targetOver, MouseEvent* e)
00258     {
00259         if (targetOver != mKeyCursorOn)
00260         {
00261             if (mKeyCursorOn != 0)
00262             {
00263                 retargetKeyEvent(mKeyCursorOn, KeyEvent::KE_KEY_FOCUSOUT, e);
00264             }
00265 
00266             if (targetOver != 0 && targetOver->isKeyEnabled())
00267             {
00268                 mKeyCursorOn = targetOver;
00269                 retargetKeyEvent(targetOver, KeyEvent::KE_KEY_FOCUSIN, e);
00270             }
00271             else
00272             {
00273                 mKeyCursorOn = NULL;
00274             }
00275         }
00276     }
00277 
00278 }
00279 
00280 
00281 

Copyright © 2002-2003 by The OGRE Team
Last modified Wed Jan 21 00:10:10 2004