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

# OgreEventMulticaster.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 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 License for more details.
    00018
    00019 You should have received a copy of the GNU Lesser General 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 "OgreException.h"
    00028 #include "OgreEventMulticaster.h"
    00029
    00030
    00031 namespace Ogre {
    00032
    00033     EventMulticaster::EventMulticaster(EventListener* a, EventListener* b)
    00034      {
    00035         mA = a;
    00036         mB = b;
    00037     }
    00038     MouseListener* EventMulticaster::add(MouseListener* a, MouseListener* b)
    00039     {
    00040         return static_cast<MouseListener*>(addInternal(a, b));
    00041     }
    00042     KeyListener* EventMulticaster::add(KeyListener* a, KeyListener* b)
    00043     {
    00044         return static_cast<KeyListener*>(addInternal(a, b));
    00045     }
    00046     MouseMotionListener* EventMulticaster::add(MouseMotionListener* a, MouseMotionListener* b)
    00047     {
    00048         return static_cast<MouseMotionListener*>(addInternal(a, b));
    00049     }
    00050
    00051     ActionListener* EventMulticaster::add(ActionListener* a, ActionListener* b)
    00052     {
    00053         return static_cast<ActionListener*>(addInternal(a, b));
    00054     }
    00055
    00056     ScrollListener* EventMulticaster::add(ScrollListener* a, ScrollListener* b)
    00057     {
    00058         return static_cast<ScrollListener*>(addInternal(a, b));
    00059     }
    00060
    00061     ListSelectionListener* EventMulticaster::add(ListSelectionListener* a, ListSelectionListener* b)
    00062     {
    00063         return static_cast<ListSelectionListener*>(addInternal(a, b));
    00064     }
    00065
    00066     EventListener* EventMulticaster::addInternal(EventListener* a, EventListener* b)
    00067     {
    00068         if (a == NULL)  return b;
    00069         if (b == NULL)  return a;
    00070         return convertMultiToListener(new EventMulticaster(a, b));
    00071     }
    00072
    00073     void EventMulticaster::listSelected(ListSelectionEvent* e)
    00074     {
    00075         (static_cast<ListSelectionListener*>(mA))->listSelected(e);
    00076         (static_cast<ListSelectionListener*>(mB))->listSelected(e);
    00077     }
    00078
    00079     void EventMulticaster::actionPerformed(ActionEvent* e)
    00080     {
    00081         (static_cast<ActionListener*>(mA))->actionPerformed(e);
    00082         (static_cast<ActionListener*>(mB))->actionPerformed(e);
    00083     }
    00084
    00085     void EventMulticaster::scrollPerformed(ScrollEvent* e)
    00086     {
    00087         (static_cast<ScrollListener*>(mA))->scrollPerformed(e);
    00088         (static_cast<ScrollListener*>(mB))->scrollPerformed(e);
    00089     }
    00090
    00091     void EventMulticaster::mouseClicked(MouseEvent* e)
    00092     {
    00093         (static_cast<MouseListener*>(mA))->mouseClicked(e);
    00094         (static_cast<MouseListener*>(mB))->mouseClicked(e);
    00095     }
    00096
    00097     void EventMulticaster::keyClicked(KeyEvent* e)
    00098     {
    00099         (static_cast<KeyListener*>(mA))->keyClicked(e);
    00100         (static_cast<KeyListener*>(mB))->keyClicked(e);
    00101     }
    00102
    00103     void EventMulticaster::mouseEntered(MouseEvent* e)
    00104     {
    00105         (static_cast<MouseListener*>(mA))->mouseEntered(e);
    00106         (static_cast<MouseListener*>(mB))->mouseEntered(e);
    00107     }
    00108
    00109     void EventMulticaster::mouseExited(MouseEvent* e)
    00110     {
    00111         (static_cast<MouseListener*>(mA))->mouseExited(e);
    00112         (static_cast<MouseListener*>(mB))->mouseExited(e);
    00113     }
    00114
    00115     void EventMulticaster::mousePressed(MouseEvent* e)
    00116     {
    00117         (static_cast<MouseListener*>(mA))->mousePressed(e);
    00118         (static_cast<MouseListener*>(mB))->mousePressed(e);
    00119     }
    00120
    00121     void EventMulticaster::mouseReleased(MouseEvent* e)
    00122     {
    00123         (static_cast<MouseListener*>(mA))->mouseReleased(e);
    00124         (static_cast<MouseListener*>(mB))->mouseReleased(e);
    00125     }
    00126     void EventMulticaster::keyPressed(KeyEvent* e)
    00127     {
    00128         (static_cast<KeyListener*>(mA))->keyPressed(e);
    00129         (static_cast<KeyListener*>(mB))->keyPressed(e);
    00130     }
    00131
    00132     void EventMulticaster::keyReleased(KeyEvent* e)
    00133     {
    00134         (static_cast<KeyListener*>(mA))->keyReleased(e);
    00135         (static_cast<KeyListener*>(mB))->keyReleased(e);
    00136     }
    00137
    00138     ListSelectionListener* EventMulticaster::remove(ListSelectionListener* l, ListSelectionListener* oldl)
    00139     {
    00140         return static_cast<ListSelectionListener*>( removeInternal(l, oldl));
    00141     }
    00142
    00143
    00144     ActionListener* EventMulticaster::remove(ActionListener* l, ActionListener* oldl)
    00145     {
    00146     return static_cast<ActionListener*>( removeInternal(l, oldl));
    00147     }
    00148
    00149     ScrollListener* EventMulticaster::remove(ScrollListener* l, ScrollListener* oldl)
    00150     {
    00151     return static_cast<ScrollListener*>( removeInternal(l, oldl));
    00152     }
    00153
    00154     MouseListener* EventMulticaster::remove(MouseListener* l, MouseListener* oldl)
    00155     {
    00156     return static_cast<MouseListener*> (removeInternal(l, oldl));
    00157     }
    00158     KeyListener* EventMulticaster::remove(KeyListener* l, KeyListener* oldl)
    00159     {
    00160     return static_cast<KeyListener*> (removeInternal(l, oldl));
    00161     }
    00162
    00163     MouseMotionListener* EventMulticaster::remove(MouseMotionListener* l, MouseMotionListener* oldl)
    00164     {
    00165     return static_cast<MouseMotionListener*> (removeInternal(l, oldl));
    00166     }
    00167
    00168     EventListener* EventMulticaster::remove(EventListener* oldl, bool& deleteSelf)
    00169      {
    00170          if (oldl == mA)
    00171          {
    00172              delete mA;
    00173              deleteSelf = true; // the multicaster is now not needed, so delete this at a higher level
    00174              return mB;
    00175          }
    00176          if (oldl == mB)
    00177          {
    00178              delete mB;
    00179              deleteSelf = true; // the multicaster is now not needed, so delete this at a higher level
    00180              return mA;
    00181          }
    00182         EventListener* a2 = removeInternal(mA, oldl);
    00183         EventListener* b2 = removeInternal(mB, oldl);
    00184         if (a2 == mA && b2 == mB)
    00185         {
    00186             return convertMultiToListener(this);    // it's not here
    00187         }
    00188         return addInternal(a2, b2); // the oldl has been removed so join the rest and return it.
    00189     }
    00190
    00191     EventListener* EventMulticaster::removeInternal(EventListener* l, EventListener* oldl)
    00192      {
    00193         if (l == oldl || l == NULL)
    00194         {
    00195             return NULL;
    00196         }
    00197         else if (l->isMulticaster())
    00198         {
    00199             bool deleteSelf = false;
    00200             EventListener* newl = convertListenerToMulti(l)->remove(oldl, deleteSelf);
    00201
    00202             if (deleteSelf)
    00203             {
    00204                 delete l;
    00205             }
    00206
    00207
    00208             return newl;
    00209         }
    00210         else
    00211         {
    00212             return l;       // it's not here
    00213         }
    00214     }
    00215
    00216     bool EventMulticaster::isMulticaster() const
    00217     {
    00218         return true;
    00219     }
    00220
    00221
    00222     EventListener* EventMulticaster::convertMultiToListener(EventMulticaster* m)
    00223     {
    00224             // messy, but C++ uses 2 copies of Base class for multiple inheritance with a common parent,
    00225             // so ActionListener is used to resolve ambiguity.
    00226             // Since Multicaster has many listeners parents, it chooses just one (actionListener arbitary)
    00227             // to get to the EventListener parent.
    00228             //http://citeseer.nj.nec.com/cache/papers/cs/15957/
    00229             //http:zSzzSzwww.cs.colorado.eduzSz~diwanzSz5535-00zSzmi.pdf/stroustrup99multiple.pdf
    00230         return static_cast <ActionListener*> (m);
    00231     }
    00232
    00233     EventMulticaster* EventMulticaster::convertListenerToMulti(EventListener* l)
    00234     {
    00235             // messy, but C++ uses 2 copies of Base class for multiple inheritance with a common parent,
    00236             // so ActionListener is used to resolve ambiguity.
    00237             // Since Multicaster has many listeners parents, it chooses just one (actionListener arbitary)
    00238             // to get to the EventListener parent.
    00239             //http://citeseer.nj.nec.com/cache/papers/cs/15957/
    00240             //http:zSzzSzwww.cs.colorado.eduzSz~diwanzSz5535-00zSzmi.pdf/stroustrup99multiple.pdf
    00241         if (!l->isMulticaster())
    00242         {
    00243             Except(Exception::ERR_INVALIDPARAMS, "Illegal convertion, listener is not a multicaster"
    00244                , "EventMulticaster::convertListenerToMulti");
    00245
    00246         }
    00247         return (static_cast <EventMulticaster*>(static_cast <ActionListener*> (l)));
    00248     }
    00249 }
    00250

Copyright © 2002-2003 by The OGRE Team
Last modified Sun Nov 28 19:48:23 2004