Changeset 13890

Show
Ignore:
Timestamp:
11/09/15 17:13:03 (2 years ago)
Author:
robert
Message:

Release OpenSceneGraph-3.5.1

Location:
OpenSceneGraph/trunk
Files:
4 added
33 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/applications/present3D/deprecated/Cluster.cpp

    r13720 r13890  
    1 /* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield  
     1/* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield 
    22 * 
    3  * This software is open source and may be redistributed and/or modified under   
     3 * This software is open source and may be redistributed and/or modified under 
    44 * the terms of the GNU General Public License (GPL) version 2.0. 
    55 * The full license is in LICENSE.txt file included with this distribution,. 
    6  *  
     6 * 
    77 * This software is distributed in the hope that it will be useful, 
    88 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1010 * include LICENSE.txt for more details. 
    1111*/ 
     
    4040    #include <unistd.h> 
    4141    #include <net/soioctl.h> 
    42 #elif defined(__CYGWIN__)  
    43     #include <unistd.h> 
    44 #elif defined(__sun)  
     42#elif defined(__CYGWIN__) 
     43    #include <unistd.h> 
     44#elif defined(__sun) 
    4545    #include <unistd.h> 
    4646    #include <sys/sockio.h> 
     
    203203        ++itr) 
    204204    { 
    205         write(*(*itr)); 
     205        osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     206        if (event) write(*(event)); 
    206207    } 
    207208} 
     
    250251////////////////////////////////////////////////////////////////////////////// 
    251252// 
    252 //  Reciever  
     253//  Reciever 
    253254// 
    254255Receiver::Receiver( void ) 
     
    339340#if defined(__linux) || defined(__FreeBSD__) || defined( __APPLE__ ) || \ 
    340341    defined(__DragonFly__) 
    341     socklen_t  
     342    socklen_t 
    342343#else 
    343344    int 
     
    382383////////////////////////////////////////////////////////////////////////////// 
    383384// 
    384 //  Broadcaster  
     385//  Broadcaster 
    385386// 
    386387Broadcaster::Broadcaster( void ) 
  • OpenSceneGraph/trunk/applications/present3D/deprecated/PointsEventHandler.cpp

    r13720 r13890  
    1 /* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield  
     1/* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield 
    22 * 
    3  * This software is open source and may be redistributed and/or modified under   
     3 * This software is open source and may be redistributed and/or modified under 
    44 * the terms of the GNU General Public License (GPL) version 2.0. 
    55 * The full license is in LICENSE.txt file included with this distribution,. 
    6  *  
     6 * 
    77 * This software is distributed in the hope that it will be useful, 
    88 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1010 * include LICENSE.txt for more details. 
    1111*/ 
     
    5555} 
    5656 
    57 void PointsEventHandler::accept(osgGA::GUIEventHandlerVisitor& v) 
    58 { 
    59     v.visit(*this); 
    60 } 
    61  
    6257void PointsEventHandler::getUsage(osg::ApplicationUsage& usage) const 
    6358{ 
  • OpenSceneGraph/trunk/applications/present3D/deprecated/PointsEventHandler.h

    r13720 r13890  
    1 /* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield  
     1/* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield 
    22 * 
    3  * This software is open source and may be redistributed and/or modified under   
     3 * This software is open source and may be redistributed and/or modified under 
    44 * the terms of the GNU General Public License (GPL) version 2.0. 
    55 * The full license is in LICENSE.txt file included with this distribution,. 
    6  *  
     6 * 
    77 * This software is distributed in the hope that it will be useful, 
    88 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1010 * include LICENSE.txt for more details. 
    1111*/ 
     
    2323    public: 
    2424        PointsEventHandler(); 
    25      
     25 
    2626        virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&); 
    27          
    28         virtual void accept(osgGA::GUIEventHandlerVisitor& v); 
    29          
     27 
    3028        void getUsage(osg::ApplicationUsage& usage) const; 
    31          
     29 
    3230        void setStateSet(osg::StateSet* stateset) { _stateset=stateset; } 
    33          
     31 
    3432        osg::StateSet* getStateSet() { return _stateset.get(); } 
    35          
     33 
    3634        const osg::StateSet* getStateSet() const { return _stateset.get(); } 
    37          
     35 
    3836        void setPointSize(float psize); 
    3937 
    4038        float getPointSize() const; 
    41          
     39 
    4240        void changePointSize(float delta); 
    43          
     41 
    4442        void changePointAttenuation(float scale); 
    4543 
  • OpenSceneGraph/trunk/applications/present3D/deprecated/ShowEventHandler.cpp

    r13720 r13890  
    1 /* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield  
     1/* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield 
    22 * 
    3  * This software is open source and may be redistributed and/or modified under   
     3 * This software is open source and may be redistributed and/or modified under 
    44 * the terms of the GNU General Public License (GPL) version 2.0. 
    55 * The full license is in LICENSE.txt file included with this distribution,. 
    6  *  
     6 * 
    77 * This software is distributed in the hope that it will be useful, 
    88 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1010 * include LICENSE.txt for more details. 
    1111*/ 
     
    2929        { 
    3030            osg::notify(osg::INFO)<<"ShowEventHandler KEYUP "<<(int)ea.getKey()<<std::endl; 
    31             if (ea.getKey()>=osgGA::GUIEventAdapter::KEY_F1 &&  
     31            if (ea.getKey()>=osgGA::GUIEventAdapter::KEY_F1 && 
    3232                ea.getKey()<=osgGA::GUIEventAdapter::KEY_F8) 
    3333            { 
     
    3535                osg::notify(osg::INFO)<<"   Select "<<child<<std::endl; 
    3636                osg::Switch* showSwitch = dynamic_cast<osg::Switch*>(object); 
    37                 if (showSwitch)  
     37                if (showSwitch) 
    3838                { 
    3939                    if (child<showSwitch->getNumChildren()) 
     
    5353} 
    5454 
    55  
    56 void ShowEventHandler::accept(osgGA::GUIEventHandlerVisitor& v) 
    57 { 
    58     v.visit(*this); 
    59 } 
    60  
    6155void ShowEventHandler::getUsage(osg::ApplicationUsage& /*usage*/) const 
    6256{ 
  • OpenSceneGraph/trunk/applications/present3D/deprecated/ShowEventHandler.h

    r13720 r13890  
    1 /* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield  
     1/* -*-c++-*- Present3D - Copyright (C) 1999-2006 Robert Osfield 
    22 * 
    3  * This software is open source and may be redistributed and/or modified under   
     3 * This software is open source and may be redistributed and/or modified under 
    44 * the terms of the GNU General Public License (GPL) version 2.0. 
    55 * The full license is in LICENSE.txt file included with this distribution,. 
    6  *  
     6 * 
    77 * This software is distributed in the hope that it will be useful, 
    88 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1010 * include LICENSE.txt for more details. 
    1111*/ 
     
    2929 
    3030        virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa, osg::Object* object, osg::NodeVisitor* nv); 
    31                  
    32         virtual void accept(osgGA::GUIEventHandlerVisitor& v); 
    33          
     31 
    3432        virtual void getUsage(osg::ApplicationUsage& usage) const; 
    35          
     33 
    3634}; 
    3735 
  • OpenSceneGraph/trunk/examples/osganimationtimeline/osganimationtimeline.cpp

    r12292 r13890  
    1 /*  -*-c++-*-  
     1/*  -*-c++-*- 
    22 *  Copyright (C) 2008 Cedric Pinson <cedric.pinson@plopbyte.net> 
    33 * 
    4  * This library is open source and may be redistributed and/or modified under   
    5  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     4 * This library is open source and may be redistributed and/or modified under 
     5 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    66 * (at your option) any later version.  The full license is in LICENSE file 
    77 * included with this distribution, and on the openscenegraph.org website. 
    8  *  
     8 * 
    99 * This library is distributed in the hope that it will be useful, 
    1010 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1212 * OpenSceneGraph Public License for more details. 
    1313*/ 
     
    8585 
    8686        // add the main loop at priority 0 at time 0. 
    87          
     87 
    8888        osgAnimation::Timeline* tml = _manager->getTimeline(); 
    8989        tml->play(); 
     
    140140                _releaseKey = false; 
    141141            } 
     142            traverse(node, nv); 
    142143        } 
    143144        else 
    144145        { 
    145             osgGA::EventVisitor* ev = dynamic_cast<osgGA::EventVisitor*>(nv); 
    146             if (ev && ev->getActionAdapter() && !ev->getEvents().empty()) 
    147             { 
    148                 for(osgGA::EventQueue::Events::iterator itr = ev->getEvents().begin(); 
    149                     itr != ev->getEvents().end(); 
    150                     ++itr) 
    151                 { 
    152                     handleWithCheckAgainstIgnoreHandledEventsMask(*(*itr), *(ev->getActionAdapter()), node, nv); 
    153                 } 
    154             } 
    155         }             
    156         traverse(node, nv); 
     146            osgGA::GUIEventHandler::operator()(node, nv); 
     147        } 
    157148    } 
    158149 
     
    169160 
    170161    std::string file = "nathan.osg"; 
    171     if(argc >= 2)  
     162    if(argc >= 2) 
    172163        file = psr[1]; 
    173164 
     
    179170    } 
    180171    osgAnimation::AnimationManagerBase* animationManager = dynamic_cast<osgAnimation::AnimationManagerBase*>(root->getUpdateCallback()); 
    181     if(!animationManager)  
     172    if(!animationManager) 
    182173    { 
    183174        osg::notify(osg::FATAL) << "Did not find AnimationManagerBase updateCallback needed to animate elements" << std::endl; 
     
    187178    osg::ref_ptr<osgAnimation::TimelineAnimationManager> tl = new osgAnimation::TimelineAnimationManager(*animationManager); 
    188179    root->setUpdateCallback(tl.get()); 
    189      
     180 
    190181    ExampleTimelineUsage* callback = new ExampleTimelineUsage(tl.get()); 
    191182    root->setEventCallback(callback); 
    192183    root->getUpdateCallback()->addNestedCallback(callback); 
    193          
     184 
    194185 
    195186 
    196187    // add the state manipulator 
    197188    viewer.addEventHandler( new osgGA::StateSetManipulator(viewer.getCamera()->getOrCreateStateSet()) ); 
    198      
     189 
    199190    // add the thread model handler 
    200191    viewer.addEventHandler(new osgViewer::ThreadingHandler); 
     
    202193    // add the window size toggle handler 
    203194    viewer.addEventHandler(new osgViewer::WindowSizeHandler); 
    204          
     195 
    205196    // add the stats handler 
    206197    viewer.addEventHandler(new osgViewer::StatsHandler); 
  • OpenSceneGraph/trunk/examples/osgcluster/osgcluster.cpp

    r11624 r13890  
    4949class CameraPacket { 
    5050    public: 
    51      
    52      
    53         CameraPacket():_masterKilled(false)  
     51 
     52 
     53        CameraPacket():_masterKilled(false) 
    5454        { 
    5555            _byte_order = SWAP_BYTES_COMPARE; 
    5656        } 
    57          
     57 
    5858        void setPacket(const osg::Matrix& matrix,const osg::FrameStamp* frameStamp) 
    5959        { 
     
    6464            } 
    6565        } 
    66          
     66 
    6767        void getModelView(osg::Matrix& matrix,float angle_offset=0.0f) 
    6868        { 
    69          
     69 
    7070            matrix = _matrix * osg::Matrix::rotate(osg::DegreesToRadians(angle_offset),0.0f,1.0f,0.0f); 
    7171        } 
    72          
     72 
    7373        void readEventQueue(osgViewer::Viewer& viewer); 
    74          
     74 
    7575        void writeEventQueue(osgViewer::Viewer& viewer); 
    7676 
    7777        void setMasterKilled(const bool flag) { _masterKilled = flag; } 
    7878        const bool getMasterKilled() const { return _masterKilled; } 
    79          
     79 
    8080        unsigned int    _byte_order; 
    8181        bool            _masterKilled; 
     
    8585        // since we don't want to copy the pointer - but the memory. 
    8686        // FrameStamp doesn't have a private destructor to allow 
    87         // us to do this, even though its a reference counted object.     
     87        // us to do this, even though its a reference counted object. 
    8888        osg::FrameStamp  _frameStamp; 
    89          
     89 
    9090        osgGA::EventQueue::Events _events; 
    91          
     91 
    9292}; 
    9393 
     
    113113 
    114114        char* _currentPtr; 
    115          
     115 
    116116        void reset() 
    117117        { 
     
    123123            if (_currentPtr+1>=_endPtr) return; 
    124124 
    125             *(_currentPtr++) = *(ptr);  
     125            *(_currentPtr++) = *(ptr); 
    126126        } 
    127127 
     
    130130            if (_currentPtr+1>=_endPtr) return; 
    131131 
    132             *(ptr) = *(_currentPtr++);  
     132            *(ptr) = *(_currentPtr++); 
    133133        } 
    134134 
     
    137137            if (_currentPtr+2>=_endPtr) return; 
    138138 
    139             *(_currentPtr++) = *(ptr++);  
    140             *(_currentPtr++) = *(ptr);  
     139            *(_currentPtr++) = *(ptr++); 
     140            *(_currentPtr++) = *(ptr); 
    141141        } 
    142142 
     
    147147            if (_swapBytes) 
    148148            { 
    149                 *(ptr+1) = *(_currentPtr++);  
    150                 *(ptr) = *(_currentPtr++);  
     149                *(ptr+1) = *(_currentPtr++); 
     150                *(ptr) = *(_currentPtr++); 
    151151            } 
    152152            else 
    153153            { 
    154                 *(ptr++) = *(_currentPtr++);  
    155                 *(ptr) = *(_currentPtr++);  
     154                *(ptr++) = *(_currentPtr++); 
     155                *(ptr) = *(_currentPtr++); 
    156156            } 
    157157        } 
     
    161161            if (_currentPtr+4>=_endPtr) return; 
    162162 
    163             *(_currentPtr++) = *(ptr++);  
    164             *(_currentPtr++) = *(ptr++);  
    165             *(_currentPtr++) = *(ptr++);  
    166             *(_currentPtr++) = *(ptr);  
     163            *(_currentPtr++) = *(ptr++); 
     164            *(_currentPtr++) = *(ptr++); 
     165            *(_currentPtr++) = *(ptr++); 
     166            *(_currentPtr++) = *(ptr); 
    167167        } 
    168168 
     
    173173            if (_swapBytes) 
    174174            { 
    175                 *(ptr+3) = *(_currentPtr++);  
    176                 *(ptr+2) = *(_currentPtr++);  
    177                 *(ptr+1) = *(_currentPtr++);  
    178                 *(ptr) = *(_currentPtr++);  
     175                *(ptr+3) = *(_currentPtr++); 
     176                *(ptr+2) = *(_currentPtr++); 
     177                *(ptr+1) = *(_currentPtr++); 
     178                *(ptr) = *(_currentPtr++); 
    179179            } 
    180180            else 
    181181            { 
    182                 *(ptr++) = *(_currentPtr++);  
    183                 *(ptr++) = *(_currentPtr++);  
    184                 *(ptr++) = *(_currentPtr++);  
    185                 *(ptr) = *(_currentPtr++);  
     182                *(ptr++) = *(_currentPtr++); 
     183                *(ptr++) = *(_currentPtr++); 
     184                *(ptr++) = *(_currentPtr++); 
     185                *(ptr) = *(_currentPtr++); 
    186186            } 
    187187        } 
     
    191191            if (_currentPtr+8>=_endPtr) return; 
    192192 
    193             *(_currentPtr++) = *(ptr++);  
    194             *(_currentPtr++) = *(ptr++);  
    195             *(_currentPtr++) = *(ptr++);  
    196             *(_currentPtr++) = *(ptr++);  
    197  
    198             *(_currentPtr++) = *(ptr++);  
    199             *(_currentPtr++) = *(ptr++);  
    200             *(_currentPtr++) = *(ptr++);  
    201             *(_currentPtr++) = *(ptr);  
     193            *(_currentPtr++) = *(ptr++); 
     194            *(_currentPtr++) = *(ptr++); 
     195            *(_currentPtr++) = *(ptr++); 
     196            *(_currentPtr++) = *(ptr++); 
     197 
     198            *(_currentPtr++) = *(ptr++); 
     199            *(_currentPtr++) = *(ptr++); 
     200            *(_currentPtr++) = *(ptr++); 
     201            *(_currentPtr++) = *(ptr); 
    202202        } 
    203203 
     
    209209            if (_swapBytes) 
    210210            { 
    211                 *(ptr+7) = *(_currentPtr++);  
    212                 *(ptr+6) = *(_currentPtr++);  
    213                 *(ptr+5) = *(_currentPtr++);  
    214                 *(ptr+4) = *(_currentPtr++);  
    215  
    216                 *(ptr+3) = *(_currentPtr++);  
    217                 *(ptr+2) = *(_currentPtr++);  
    218                 *(ptr+1) = *(_currentPtr++);  
    219                 *(ptr) = *(_currentPtr++);  
     211                *(ptr+7) = *(_currentPtr++); 
     212                *(ptr+6) = *(_currentPtr++); 
     213                *(ptr+5) = *(_currentPtr++); 
     214                *(ptr+4) = *(_currentPtr++); 
     215 
     216                *(ptr+3) = *(_currentPtr++); 
     217                *(ptr+2) = *(_currentPtr++); 
     218                *(ptr+1) = *(_currentPtr++); 
     219                *(ptr) = *(_currentPtr++); 
    220220            } 
    221221            else 
    222222            { 
    223                 *(ptr++) = *(_currentPtr++);  
    224                 *(ptr++) = *(_currentPtr++);  
    225                 *(ptr++) = *(_currentPtr++);  
    226                 *(ptr++) = *(_currentPtr++);  
    227  
    228                 *(ptr++) = *(_currentPtr++);  
    229                 *(ptr++) = *(_currentPtr++);  
    230                 *(ptr++) = *(_currentPtr++);  
    231                 *(ptr) = *(_currentPtr++);  
     223                *(ptr++) = *(_currentPtr++); 
     224                *(ptr++) = *(_currentPtr++); 
     225                *(ptr++) = *(_currentPtr++); 
     226                *(ptr++) = *(_currentPtr++); 
     227 
     228                *(ptr++) = *(_currentPtr++); 
     229                *(ptr++) = *(_currentPtr++); 
     230                *(ptr++) = *(_currentPtr++); 
     231                *(ptr) = *(_currentPtr++); 
    232232            } 
    233233        } 
     
    362362            event.setTime(readDouble()); 
    363363        } 
    364          
     364 
    365365        void write(CameraPacket& cameraPacket) 
    366366        { 
    367367            writeUInt(cameraPacket._byte_order); 
    368              
     368 
    369369            writeUInt(cameraPacket._masterKilled); 
    370              
     370 
    371371            write(cameraPacket._matrix); 
    372372            write(cameraPacket._frameStamp); 
    373          
     373 
    374374            writeUInt(cameraPacket._events.size()); 
    375375            for(osgGA::EventQueue::Events::iterator itr = cameraPacket._events.begin(); 
     
    377377                ++itr) 
    378378            { 
    379                 write(*(*itr)); 
     379                osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     380                if (event) write(*event); 
    380381            } 
    381382        } 
     
    388389                _swapBytes = !_swapBytes; 
    389390            } 
    390              
     391 
    391392            cameraPacket._masterKilled = readUInt()!=0; 
    392              
     393 
    393394            read(cameraPacket._matrix); 
    394395            read(cameraPacket._frameStamp); 
    395          
     396 
    396397            cameraPacket._events.clear(); 
    397398            unsigned int numEvents = readUInt(); 
     
    410411 
    411412    osgViewer::ViewerBase::Contexts contexts; 
    412     viewer.getContexts(contexts);    
     413    viewer.getContexts(contexts); 
    413414 
    414415    for(osgViewer::ViewerBase::Contexts::iterator citr =contexts.begin();  citr != contexts.end(); ++citr) 
     
    424425        _events.insert(_events.end(), gw_events.begin(), gw_events.end()); 
    425426    } 
    426      
     427 
    427428    viewer.getEventQueue()->copyEvents(_events); 
    428429 
     
    450451    // use an ArgumentParser object to manage the program arguments. 
    451452    osg::ArgumentParser arguments(&argc,argv); 
    452      
     453 
    453454    // set up the usage document, in case we need to print out how to use this program. 
    454455    arguments.getApplicationUsage()->setDescription(arguments.getApplicationName()+" is the example which demonstrates how to approach implementation of clustering."); 
     
    460461    arguments.getApplicationUsage()->addCommandLineOption("-f <float>","Field of view of camera"); 
    461462    arguments.getApplicationUsage()->addCommandLineOption("-o <float>","Offset angle of camera"); 
    462      
     463 
    463464    // construct the viewer. 
    464465    osgViewer::Viewer viewer; 
     
    469470    while (arguments.read("-m")) viewerMode = MASTER; 
    470471    while (arguments.read("-s")) viewerMode = SLAVE; 
    471      
     472 
    472473    int socketNumber=8100; 
    473474    while (arguments.read("-n",socketNumber)) ; 
    474475 
    475476    float camera_fov=-1.0f; 
    476     while (arguments.read("-f",camera_fov))  
     477    while (arguments.read("-f",camera_fov)) 
    477478    { 
    478479    } 
     
    498499        return 1; 
    499500    } 
    500      
     501 
    501502    if (arguments.argc()<=1) 
    502503    { 
     
    515516        double fovy, aspectRatio, zNear, zFar; 
    516517        viewer.getCamera()->getProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar); 
    517          
     518 
    518519        double original_fov = atan(tan(osg::DegreesToRadians(fovy)*0.5)*aspectRatio)*2.0; 
    519520        std::cout << "setting lens perspective : original "<<original_fov<<"  "<<fovy<<std::endl; 
    520          
     521 
    521522        fovy = atan(tan(osg::DegreesToRadians(camera_fov)*0.5)/aspectRatio)*2.0; 
    522523        viewer.getCamera()->setProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar); 
    523      
     524 
    524525        viewer.getCamera()->getProjectionMatrixAsPerspective(fovy, aspectRatio,zNear, zFar); 
    525526        original_fov = atan(tan(osg::DegreesToRadians(fovy)*0.5)*aspectRatio)*2.0; 
     
    550551 
    551552    bool masterKilled = false; 
    552      
     553 
    553554    DataConverter scratchPad(1024); 
    554555 
     
    556557    { 
    557558        osg::Timer_t startTick = osg::Timer::instance()->tick(); 
    558                   
     559 
    559560        viewer.advance(); 
    560561 
     
    564565        case(MASTER): 
    565566            { 
    566                  
     567 
    567568                // take camera zero as the guide. 
    568569                osg::Matrix modelview(viewer.getCamera()->getViewMatrix()); 
    569                  
     570 
    570571                cp->setPacket(modelview,viewer.getFrameStamp()); 
    571                  
     572 
    572573                cp->readEventQueue(viewer); 
    573574 
     
    579580 
    580581                bc.setBuffer(scratchPad._startPtr, scratchPad._numBytes); 
    581                  
     582 
    582583                std::cout << "bc.sync()"<<scratchPad._numBytes<<std::endl; 
    583584 
    584585                bc.sync(); 
    585                  
     586 
    586587            } 
    587588            break; 
     
    592593 
    593594                rc.sync(); 
    594                  
     595 
    595596                scratchPad.reset(); 
    596597                scratchPad.read(*cp); 
    597      
     598 
    598599                cp->writeEventQueue(viewer); 
    599600 
    600                 if (cp->getMasterKilled())  
     601                if (cp->getMasterKilled()) 
    601602                { 
    602603                    std::cout << "Received master killed."<<std::endl; 
     
    610611            break; 
    611612        } 
    612           
     613 
    613614        osg::Timer_t endTick = osg::Timer::instance()->tick(); 
    614          
     615 
    615616        osg::notify(osg::INFO)<<"Time to do cluster sync "<<osg::Timer::instance()->delta_m(startTick,endTick)<<std::endl; 
    616617 
     
    624625            osg::Matrix modelview; 
    625626            cp->getModelView(modelview,camera_offset); 
    626          
     627 
    627628            viewer.getCamera()->setViewMatrix(modelview); 
    628629        } 
     
    631632        if(!masterKilled) 
    632633            viewer.renderingTraversals(); 
    633          
     634 
    634635    } 
    635636 
     
    639640        // need to broadcast my death. 
    640641        cp->setPacket(osg::Matrix::identity(),viewer.getFrameStamp()); 
    641         cp->setMasterKilled(true);  
     642        cp->setMasterKilled(true); 
    642643 
    643644        scratchPad.reset(); 
  • OpenSceneGraph/trunk/include/osgGA/CameraManipulator

    r13097 r13890  
    8888        virtual osg::Matrixd getInverseMatrix() const = 0; 
    8989 
    90         /** update the camera for the current frame, typically called by the viewer classes.  
     90        /** update the camera for the current frame, typically called by the viewer classes. 
    9191            Default implementation simply set the camera view matrix. */ 
    9292        virtual void updateCamera(osg::Camera& camera) { camera.setViewMatrix(getInverseMatrix()); } 
     
    164164        virtual void init(const GUIEventAdapter& ,GUIActionAdapter&) {} 
    165165 
     166        /** Handle event. Override the handle(..) method in your event handlers to respond to events. */ 
     167        virtual bool handle(osgGA::Event* event, osg::Object* object, osg::NodeVisitor* nv) { return GUIEventHandler::handle(event, object, nv); } 
     168 
    166169        /** Handle events, return true if handled, false otherwise. */ 
    167170        virtual bool handle(const GUIEventAdapter& ea,GUIActionAdapter& us); 
  • OpenSceneGraph/trunk/include/osgGA/Device

    r13429 r13890  
    3030            SEND_EVENTS     = 2 
    3131        } Capabilities; 
    32          
     32 
    3333        Device(); 
    3434        Device(const Device& es, const osg::CopyOp& copyop); 
    3535 
    3636        META_Object(osgGA,Device); 
    37          
     37 
    3838        int getCapabilities() const { return _capabilities; } 
    39      
     39 
    4040        virtual bool checkEvents() { return _eventQueue.valid() ? !(getEventQueue()->empty()) : false; } 
    41         virtual void sendEvent(const GUIEventAdapter& ea); 
     41        virtual void sendEvent(const Event& ea); 
    4242        virtual void sendEvents(const EventQueue::Events& events); 
    4343 
     
    4848    protected: 
    4949        void setCapabilities(int capabilities) { _capabilities = capabilities; } 
    50          
     50 
    5151        virtual ~Device(); 
    5252 
     
    5555 
    5656        osg::ref_ptr<osgGA::EventQueue> _eventQueue; 
    57      
    58     private:    
     57 
     58    private: 
    5959        int _capabilities; 
    60          
     60 
    6161}; 
    6262 
  • OpenSceneGraph/trunk/include/osgGA/EventQueue

    r13429 r13890  
    3434        EventQueue(GUIEventAdapter::MouseYOrientation mouseYOrientation=GUIEventAdapter::Y_INCREASING_DOWNWARDS); 
    3535 
    36         typedef std::list< osg::ref_ptr<GUIEventAdapter> > Events; 
     36        typedef std::list< osg::ref_ptr<Event> > Events; 
    3737 
    3838        bool empty() const 
     
    4141            return _eventQueue.empty(); 
    4242        } 
    43          
     43 
    4444        /** Set events.*/ 
    4545        void setEvents(Events& events); 
     
    5858 
    5959        /** Add an event to the end of the event queue.*/ 
    60         void addEvent(GUIEventAdapter* event); 
     60        void addEvent(Event* event); 
    6161 
    6262 
     
    7171        /** Set the graphics context associated with this event queue.*/ 
    7272        void setGraphicsContext(osg::GraphicsContext* context) { getCurrentEventState()->setGraphicsContext(context); } 
    73          
     73 
    7474        osg::GraphicsContext* getGraphicsContext() { return getCurrentEventState()->getGraphicsContext(); } 
    7575 
  • OpenSceneGraph/trunk/include/osgGA/EventVisitor

    r13307 r13890  
    5252        const osgGA::GUIActionAdapter* getActionAdapter() const { return _actionAdapter; } 
    5353 
    54  
    55         typedef std::list< osg::ref_ptr<GUIEventAdapter> > EventList; 
    56  
    57         void addEvent(GUIEventAdapter* event); 
    58         void removeEvent(GUIEventAdapter* event); 
     54        void addEvent(Event* event); 
     55        void removeEvent(Event* event); 
    5956 
    6057        void setEventHandled(bool handled) { _handled = handled; } 
    6158        bool getEventHandled() const { return _handled; } 
    62  
    6359 
    6460        void setEvents(const EventQueue::Events& events) { _events = events; } 
     
    138134        bool                            _handled; 
    139135        EventQueue::Events              _events; 
    140  
    141136}; 
    142137 
  • OpenSceneGraph/trunk/include/osgGA/GUIEventAdapter

    r13587 r13890  
    1212*/ 
    1313 
    14 #ifndef OSGGA_EVENT 
    15 #define OSGGA_EVENT 1 
     14#ifndef OSGGA_GUIEVENTADAPTER 
     15#define OSGGA_GUIEVENTADAPTER 1 
    1616 
    1717#include <osg/Object> 
    1818#include <osg/Matrix> 
    1919#include <osg/GraphicsContext> 
    20 #include <osgGA/Export> 
     20 
     21#include <osgGA/Event> 
    2122 
    2223namespace osgGA{ 
     
    7879/** Event class for storing Keyboard, mouse and window events. 
    7980*/ 
    80 class OSGGA_EXPORT GUIEventAdapter : public osg::Object 
     81class OSGGA_EXPORT GUIEventAdapter : public Event 
    8182{ 
    8283public: 
     
    449450        META_Object(osgGA, GUIEventAdapter); 
    450451 
     452        virtual GUIEventAdapter* asGUIEventAdapter() { return this; } 
     453        virtual const GUIEventAdapter* asGUIEventAdapter() const { return this; } 
     454 
    451455 
    452456        /** Get the accumulated event state singleton. 
     
    467471        /** get the event type. */ 
    468472        virtual EventType getEventType() const { return _eventType; } 
    469  
    470         /** set time in seconds of event. */ 
    471         void setTime(double time) { _time = time; } 
    472  
    473         /** get time in seconds of event. */ 
    474         double getTime() const { return _time; } 
    475473 
    476474        /** deprecated function for getting time of event. */ 
     
    710708        mutable bool _handled; 
    711709        EventType _eventType; 
    712         double _time; 
    713710 
    714711        osg::observer_ptr<osg::GraphicsContext> _context; 
  • OpenSceneGraph/trunk/include/osgGA/GUIEventHandler

    r13041 r13890  
    2121#include <osg/ApplicationUsage> 
    2222 
    23 #include <osgGA/Export> 
     23#include <osgGA/EventHandler> 
    2424#include <osgGA/GUIEventAdapter> 
    2525#include <osgGA/GUIActionAdapter> 
     
    4848*/ 
    4949 
    50 class OSGGA_EXPORT GUIEventHandler : public osg::NodeCallback, public osg::Drawable::EventCallback 
     50class OSGGA_EXPORT GUIEventHandler : public EventHandler 
    5151{ 
    5252public: 
    5353 
     54#if 1 
     55        GUIEventHandler() {} 
     56        GUIEventHandler(const GUIEventHandler& eh,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY): 
     57            EventHandler(eh, copyop) {} 
     58#else 
    5459        GUIEventHandler() : _ignoreHandledEventsMask(GUIEventAdapter::NONE) {} 
    55         GUIEventHandler(const GUIEventHandler& eh,const osg::CopyOp& copyop): 
    56             osg::NodeCallback(eh, copyop), 
    57             osg::Drawable::EventCallback(eh, copyop), 
     60        GUIEventHandler(const GUIEventHandler& eh,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY): 
     61            EventHandler(eh, copyop) 
    5862            _ignoreHandledEventsMask(eh._ignoreHandledEventsMask) {} 
     63#endif 
    5964 
    6065        META_Object(osgGA,GUIEventHandler); 
    6166 
    62         /** Event traversal node callback method.*/ 
    63         virtual void operator()(osg::Node* node, osg::NodeVisitor* nv); 
    64  
    65         /** Event traversal drawable callback method.*/ 
    66         virtual void event(osg::NodeVisitor* nv, osg::Drawable* drawable); 
     67        /** Handle event. Override the handle(..) method in your event handlers to respond to events. */ 
     68        virtual bool handle(osgGA::Event* event, osg::Object* object, osg::NodeVisitor* nv); 
    6769 
    6870        /** Handle events, return true if handled, false otherwise. */ 
    6971        virtual bool handle(const GUIEventAdapter& ea,GUIActionAdapter& aa, osg::Object*, osg::NodeVisitor*) { return handle(ea,aa); } 
    7072 
     73#if 0 
    7174        /** Convenience method that only passes on to the handle(,,,) method events that either haven't been 
    7275          * handled yet, or have been handled but haven't be set to be ignored by the IgnoreHandledEventsMask. 
     
    8790            } 
    8891        } 
    89  
     92#endif 
    9093        /** Deprecated, Handle events, return true if handled, false otherwise. */ 
    9194        virtual bool handle(const GUIEventAdapter&,GUIActionAdapter&) { return false; } 
    9295 
     96#if 0 
    9397        /** Convenience method that only passes on to the handle(,) method events that either haven't been 
    9498          * handled yet, or have been handled but haven't be set to be ignored by the IgnoreHandledEventsMask. 
     
    110114        } 
    111115 
    112         /** Get the keyboard and mouse usage of this manipulator.*/ 
    113         virtual void getUsage(osg::ApplicationUsage&) const {} 
    114  
    115116        /** Set a mask of osgGA::GUIEeventAdapter::Event to be ignored if marked as handled */ 
    116117        void setIgnoreHandledEventsMask(unsigned int mask) { _ignoreHandledEventsMask = mask; } 
     
    121122protected: 
    122123        unsigned int _ignoreHandledEventsMask; 
    123  
     124#endif 
    124125}; 
    125  
    126 #ifdef USE_DEPRECATED_API 
    127     // keep for backwards compatibility 
    128     class GUIEventHandlerVisitor 
    129     { 
    130         public: 
    131  
    132             void visit(GUIEventHandler&) {} 
    133     }; 
    134 #endif 
    135126 
    136127} 
  • OpenSceneGraph/trunk/include/osgPresentation/deprecated/KeyEventHandler

    r13721 r13890  
    4949        virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa, osg::Object* object, osg::NodeVisitor* nv); 
    5050 
    51         virtual void accept(osgGA::GUIEventHandlerVisitor& v); 
    52  
    5351        virtual void getUsage(osg::ApplicationUsage& usage) const; 
    5452 
  • OpenSceneGraph/trunk/include/osgPresentation/deprecated/PickEventHandler

    r13721 r13890  
    4646        virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa, osg::Object* object, osg::NodeVisitor* nv); 
    4747 
    48         virtual void accept(osgGA::GUIEventHandlerVisitor& v); 
    49  
    5048        virtual void getUsage(osg::ApplicationUsage& usage) const; 
    5149 
  • OpenSceneGraph/trunk/include/osgPresentation/deprecated/SlideEventHandler

    r13721 r13890  
    255255    void set(osg::Node* model); 
    256256 
    257     virtual void accept(osgGA::GUIEventHandlerVisitor& v) { v.visit(*this); } 
    258  
    259     /** Event traversal node callback method.*/ 
    260     virtual void operator()(osg::Node* node, osg::NodeVisitor* nv); 
    261  
    262257    virtual bool handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter&); 
    263258 
  • OpenSceneGraph/trunk/include/osgViewer/View

    r13429 r13890  
    4444 
    4545        META_Object(osgViewer,ViewConfig); 
    46          
     46 
    4747        /** configure method that is overridden by Config subclasses.*/ 
    4848        virtual void configure(osgViewer::View& /*view*/) const {} 
    49          
     49 
    5050        /** convinience method for getting the relavent display settings to use.*/ 
    5151        virtual osg::DisplaySettings* getActiveDisplaySetting(osgViewer::View& view) const; 
     
    130130        const osgDB::ImagePager* getImagePager() const; 
    131131 
    132         
     132 
    133133        /** Add a Device. 
    134134         * The Device is polled on each new frame via it's Device::checkEvents() method and any events generated then collected via Device::getEventQueue()*/ 
     
    168168 
    169169 
    170         typedef std::list< osg::ref_ptr<osgGA::GUIEventHandler> > EventHandlers; 
     170        typedef std::list< osg::ref_ptr<osgGA::EventHandler> > EventHandlers; 
    171171 
    172172        /** Add an EventHandler that adds handling of events to the View.*/ 
    173         void addEventHandler(osgGA::GUIEventHandler* eventHandler); 
     173        void addEventHandler(osgGA::EventHandler* eventHandler); 
    174174 
    175175        /** Remove an EventHandler from View.*/ 
    176         void removeEventHandler(osgGA::GUIEventHandler* eventHandler); 
     176        void removeEventHandler(osgGA::EventHandler* eventHandler); 
    177177 
    178178        /** Get the View's list of EventHandlers.*/ 
     
    217217        float getFusionDistanceValue() const { return _fusionDistanceValue; } 
    218218 
    219          
     219 
    220220        /** Apply a viewer configuration to set up Cameras and Windowing. */ 
    221221        void apply(ViewConfig* config); 
    222          
     222 
    223223        ViewConfig* getLastAppliedViewConfig() { return _lastAppliedViewConfig.get(); } 
    224224        const ViewConfig* getLastAppliedViewConfig() const { return _lastAppliedViewConfig.get(); } 
    225          
    226          
     225 
     226 
    227227        /** deprecated, use view.apply(new osgViewer::AcrossAllWindows()). */ 
    228228        void setUpViewAcrossAllScreens(); 
     
    243243        void setUpViewForWoWVxDisplay(unsigned int screenNum, unsigned char wow_content, unsigned char wow_factor, unsigned char wow_offset, float wow_disparity_Zd, float wow_disparity_vz, float wow_disparity_M, float wow_disparity_C); 
    244244 
    245          
     245 
    246246 
    247247        /** Convenience method for setting up depth partitioning on the specified camera.*/ 
     
    255255        bool containsCamera(const osg::Camera* camera) const; 
    256256 
    257          
     257 
    258258        /** deprecated. */ 
    259259        const osg::Camera* getCameraContainingPosition(float x, float y, float& local_x, float& local_y) const; 
     
    265265        bool computeIntersections(float x,float y, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
    266266 
    267          
     267 
    268268        /** Compute intersections of a ray, starting the current mouse position, through the specified camera. */ 
    269269        bool computeIntersections(const osgGA::GUIEventAdapter& ea, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
     
    272272        bool computeIntersections(const osgGA::GUIEventAdapter& ea, const osg::NodePath& nodePath, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
    273273 
    274          
     274 
    275275        /** Compute intersections of a ray through the specified camera. */ 
    276276        bool computeIntersections(const osg::Camera* camera, osgUtil::Intersector::CoordinateFrame cf, float x,float y, osgUtil::LineSegmentIntersector::Intersections& intersections,osg::Node::NodeMask traversalMask = 0xffffffff); 
     
    285285 
    286286    public: 
    287          
     287 
    288288        osg::Texture* createDistortionTexture(int width, int height); 
    289289        osg::Camera* assignRenderToTextureCamera(osg::GraphicsContext* gc, int width, int height, osg::Texture* texture); 
     
    301301            double _eyeScale; 
    302302        }; 
    303          
     303 
    304304 
    305305    public: 
     
    335335 
    336336        osg::ref_ptr<ViewConfig>                _lastAppliedViewConfig; 
    337          
     337 
    338338}; 
    339339 
  • OpenSceneGraph/trunk/src/osgDB/PropertyInterface.cpp

    r13850 r13890  
    373373        if (areTypesCompatible(valueType, sourceType)) 
    374374        { 
    375             OSG_NOTICE<<"Calling get"<<std::endl; 
    376375            return serializer->get(*object, valuePtr); 
    377376        } 
     
    397396        if (areTypesCompatible(valueType, destinationType)) 
    398397        { 
    399             OSG_NOTICE<<"Calling set"<<std::endl; 
    400398            return serializer->set(*object, const_cast<void*>(valuePtr)); 
    401399        } 
  • OpenSceneGraph/trunk/src/osgGA/CMakeLists.txt

    r13172 r13890  
    1212    ${HEADER_PATH}/DriveManipulator 
    1313    ${HEADER_PATH}/Device 
     14    ${HEADER_PATH}/Event 
     15    ${HEADER_PATH}/EventHandler 
    1416    ${HEADER_PATH}/EventQueue 
    1517    ${HEADER_PATH}/EventVisitor 
     
    3941    DriveManipulator.cpp 
    4042    Device.cpp 
     43    Event.cpp 
     44    EventHandler.cpp 
    4145    EventQueue.cpp 
    4246    EventVisitor.cpp 
  • OpenSceneGraph/trunk/src/osgGA/Device.cpp

    r13587 r13890  
    2929} 
    3030 
    31 void Device::sendEvent(const GUIEventAdapter& /*event*/) 
     31void Device::sendEvent(const Event& /*event*/) 
    3232{ 
    3333    OSG_WARN << "Device::sendEvent not implemented!" << std::endl; 
  • OpenSceneGraph/trunk/src/osgGA/EventQueue.cpp

    r13377 r13890  
    5252} 
    5353 
    54 void EventQueue::addEvent(GUIEventAdapter* event) 
     54void EventQueue::addEvent(Event* event) 
    5555{ 
    5656    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_eventQueueMutex); 
     
    426426    if(_firstTouchEmulatesMouse) 
    427427        event->setButton(GUIEventAdapter::LEFT_MOUSE_BUTTON); 
    428      
     428 
    429429    addEvent(event); 
    430430 
     
    465465    if(_firstTouchEmulatesMouse) 
    466466        event->setButton(GUIEventAdapter::LEFT_MOUSE_BUTTON); 
    467      
     467 
    468468    addEvent(event); 
    469469 
     
    496496    event->setEventType(GUIEventAdapter::FRAME); 
    497497    event->setTime(time); 
    498      
     498 
    499499    // OSG_NOTICE<<"frame("<<time<<"), event->getX()="<<event->getX()<<", event->getY()="<<event->getY()<<", event->getXmin()="<<event->getXmin()<<", event->getYmin()="<<event->getYmin()<<", event->getXmax()="<<event->getXmax()<<", event->getYmax()="<<event->getYmax()<<std::endl; 
    500500 
  • OpenSceneGraph/trunk/src/osgGA/EventVisitor.cpp

    r13041 r13890  
    2929} 
    3030 
    31 void EventVisitor::addEvent(GUIEventAdapter* event) 
     31void EventVisitor::addEvent(Event* event) 
    3232{ 
    3333    _events.push_back(event); 
    3434} 
    3535 
    36 void EventVisitor::removeEvent(GUIEventAdapter* event) 
     36void EventVisitor::removeEvent(Event* event) 
    3737{ 
    38     EventList::iterator itr = std::find(_events.begin(),_events.end(),event); 
     38    EventQueue::Events::iterator itr = std::find(_events.begin(), _events.end(), event); 
    3939    if (itr!=_events.end()) _events.erase(itr); 
    4040} 
  • OpenSceneGraph/trunk/src/osgGA/GUIEventAdapter.cpp

    r13376 r13890  
    2626    _handled(false), 
    2727    _eventType(NONE), 
    28     _time(0.0), 
    2928    _windowX(0), 
    3029    _windowY(0), 
     
    4948 
    5049GUIEventAdapter::GUIEventAdapter(const GUIEventAdapter& rhs,const osg::CopyOp& copyop): 
    51     osg::Object(rhs,copyop), 
     50    osgGA::Event(rhs,copyop), 
    5251    _handled(rhs._handled), 
    5352    _eventType(rhs._eventType), 
    54     _time(rhs._time), 
    5553    _context(rhs._context), 
    5654    _windowX(rhs._windowX), 
  • OpenSceneGraph/trunk/src/osgGA/GUIEventHandler.cpp

    r13041 r13890  
    1717using namespace osgGA; 
    1818 
    19  
    20 void GUIEventHandler::operator()(osg::Node* node, osg::NodeVisitor* nv) 
     19// adapt EventHandler usage to old style GUIEventHandler usage 
     20bool GUIEventHandler::handle(osgGA::Event* event, osg::Object* object, osg::NodeVisitor* nv) 
    2121{ 
    2222    osgGA::EventVisitor* ev = dynamic_cast<osgGA::EventVisitor*>(nv); 
    23     if (ev && ev->getActionAdapter() && !ev->getEvents().empty()) 
     23    osgGA::GUIEventAdapter* ea = event->asGUIEventAdapter(); 
     24    if (ea && ev && ev->getActionAdapter()) 
    2425    { 
    25         for(osgGA::EventQueue::Events::iterator itr = ev->getEvents().begin(); 
    26             itr != ev->getEvents().end(); 
    27             ++itr) 
    28         { 
    29             handleWithCheckAgainstIgnoreHandledEventsMask(*(*itr), *(ev->getActionAdapter()), node, nv); 
    30         } 
     26#if 1 
     27        bool handled = handle(*ea, *(ev->getActionAdapter()), object, nv); 
     28        if (handled) ea->setHandled(true); 
     29        return handled; 
     30#else 
     31        return handleWithCheckAgainstIgnoreHandledEventsMask(*ea, *(ev->getActionAdapter()), object, nv); 
     32#endif 
    3133    } 
    32     if (node->getNumChildrenRequiringEventTraversal()>0 || _nestedCallback.valid()) traverse(node,nv); 
     34    return false; 
    3335} 
    3436 
    35 void GUIEventHandler::event(osg::NodeVisitor* nv, osg::Drawable* drawable) 
    36 { 
    37     osgGA::EventVisitor* ev = dynamic_cast<osgGA::EventVisitor*>(nv); 
    38     if (ev && ev->getActionAdapter() && !ev->getEvents().empty()) 
    39     { 
    40         for(osgGA::EventQueue::Events::iterator itr = ev->getEvents().begin(); 
    41             itr != ev->getEvents().end(); 
    42             ++itr) 
    43         { 
    44             handleWithCheckAgainstIgnoreHandledEventsMask(*(*itr), *(ev->getActionAdapter()), drawable, nv); 
    45         } 
    46     } 
    47 } 
    48  
  • OpenSceneGraph/trunk/src/osgManipulator/Dragger.cpp

    r13415 r13890  
    306306                ++itr) 
    307307            { 
    308                 osgGA::GUIEventAdapter* ea = itr->get(); 
    309                 if (handle(*ea, *(ev->getActionAdapter()))) ea->setHandled(true); 
     308                osgGA::GUIEventAdapter* ea = (*itr)->asGUIEventAdapter(); 
     309                if (ea && handle(*ea, *(ev->getActionAdapter()))) ea->setHandled(true); 
    310310            } 
    311311        } 
  • OpenSceneGraph/trunk/src/osgPresentation/Cursor.cpp

    r13820 r13890  
    188188            ++itr) 
    189189        { 
    190             osgGA::GUIEventAdapter* event = itr->get(); 
     190            osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     191            if (!event) continue; 
     192 
    191193            switch(event->getEventType()) 
    192194            { 
  • OpenSceneGraph/trunk/src/osgPresentation/deprecated/KeyEventHandler.cpp

    r13721 r13890  
    6464    } 
    6565    return false; 
    66 } 
    67  
    68  
    69 void KeyEventHandler::accept(osgGA::GUIEventHandlerVisitor& v) 
    70 { 
    71     v.visit(*this); 
    7266} 
    7367 
  • OpenSceneGraph/trunk/src/osgPresentation/deprecated/PickEventHandler.cpp

    r13721 r13890  
    132132} 
    133133 
    134  
    135 void PickEventHandler::accept(osgGA::GUIEventHandlerVisitor& v) 
    136 { 
    137     v.visit(*this); 
    138 } 
    139  
    140134void PickEventHandler::getUsage(osg::ApplicationUsage& /*usage*/) const 
    141135{ 
  • OpenSceneGraph/trunk/src/osgPresentation/deprecated/SlideEventHandler.cpp

    r13734 r13890  
    968968} 
    969969 
    970 void SlideEventHandler::operator()(osg::Node* node, osg::NodeVisitor* nv) 
    971 { 
    972     osgGA::EventVisitor* ev = dynamic_cast<osgGA::EventVisitor*>(nv); 
    973     if (ev) 
    974     { 
    975         if (node->getNumChildrenRequiringEventTraversal()>0) traverse(node,nv); 
    976  
    977         if (ev->getActionAdapter() && !ev->getEvents().empty()) 
    978         { 
    979             for(osgGA::EventQueue::Events::iterator itr = ev->getEvents().begin(); 
    980                 itr != ev->getEvents().end(); 
    981                 ++itr) 
    982             { 
    983                 handleWithCheckAgainstIgnoreHandledEventsMask(*(*itr), *(ev->getActionAdapter()), node, nv); 
    984             } 
    985         } 
    986     } 
    987 } 
    988  
    989970bool SlideEventHandler::handle(const osgGA::GUIEventAdapter& ea,osgGA::GUIActionAdapter& aa) 
    990971{ 
  • OpenSceneGraph/trunk/src/osgPresentation/deprecated/Timeout.cpp

    r13721 r13890  
    258258                ++itr) 
    259259            { 
    260                 osgGA::GUIEventAdapter* event = itr->get(); 
     260                osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     261                if (!event) continue; 
    261262 
    262263                bool keyEvent = event->getEventType()==osgGA::GUIEventAdapter::KEYDOWN ||  event->getEventType()==osgGA::GUIEventAdapter::KEYUP; 
  • OpenSceneGraph/trunk/src/osgViewer/CompositeViewer.cpp

    r13876 r13890  
    917917struct SortEvents 
    918918{ 
    919     bool operator() (const osg::ref_ptr<osgGA::GUIEventAdapter>& lhs,const osg::ref_ptr<osgGA::GUIEventAdapter>& rhs) const 
     919    bool operator() (const osg::ref_ptr<osgGA::Event>& lhs,const osg::ref_ptr<osgGA::Event>& rhs) const 
    920920    { 
    921921        return lhs->getTime() < rhs->getTime(); 
     
    962962                ++itr) 
    963963            { 
    964                 (*itr)->setGraphicsContext(gw); 
     964                osgGA::GUIEventAdapter* ea = (*itr)->asGUIEventAdapter(); 
     965                if (ea) ea->setGraphicsContext(gw); 
    965966            } 
    966967 
     
    977978        ++itr) 
    978979    { 
    979         osgGA::GUIEventAdapter* event = itr->get(); 
     980        osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     981        if (!event) continue; 
    980982 
    981983        switch(event->getEventType()) 
     
    10601062        ++itr) 
    10611063    { 
    1062         osgGA::GUIEventAdapter* event = itr->get(); 
     1064        osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     1065        if (!event) continue; 
     1066 
    10631067        switch(event->getEventType()) 
    10641068        { 
     
    11191123                ++itr) 
    11201124            { 
    1121                 osgGA::GUIEventAdapter* event = itr->get(); 
     1125                osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     1126                if (!event) continue; 
    11221127                switch(event->getEventType()) 
    11231128                { 
     
    11491154        { 
    11501155            View* view = veitr->first; 
     1156            _eventVisitor->setActionAdapter(view); 
    11511157 
    11521158            if (view && view->getSceneData()) 
    11531159            { 
    1154                 _eventVisitor->setActionAdapter(view); 
    1155  
    11561160                for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); 
    11571161                    itr != veitr->second.end(); 
    11581162                    ++itr) 
    11591163                { 
    1160                     osgGA::GUIEventAdapter* event = itr->get(); 
     1164                    osgGA::Event* event = itr->get(); 
    11611165 
    11621166                    _eventVisitor->reset(); 
     
    12061210    { 
    12071211        View* view = veitr->first; 
     1212        _eventVisitor->setActionAdapter(view); 
    12081213 
    12091214        for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); 
     
    12111216            ++itr) 
    12121217        { 
    1213             osgGA::GUIEventAdapter* event = itr->get(); 
    1214  
     1218            osgGA::Event* event = itr->get(); 
    12151219            for(View::EventHandlers::iterator hitr = view->getEventHandlers().begin(); 
    12161220                hitr != view->getEventHandlers().end(); 
    12171221                ++hitr) 
    12181222            { 
    1219                 (*hitr)->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *view, 0, _eventVisitor.get()); 
     1223                (*hitr)->handle( event, view, _eventVisitor.get()); 
    12201224            } 
    12211225        } 
     
    12271231    { 
    12281232        View* view = veitr->first; 
     1233        _eventVisitor->setActionAdapter(view); 
    12291234 
    12301235        for(osgGA::EventQueue::Events::iterator itr = veitr->second.begin(); 
     
    12321237            ++itr) 
    12331238        { 
    1234             osgGA::GUIEventAdapter* event = itr->get(); 
    1235  
     1239            osgGA::Event* event = itr->get(); 
    12361240            if (view->getCameraManipulator()) 
    12371241            { 
    1238                 view->getCameraManipulator()->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *view); 
     1242                view->getCameraManipulator()->handle( event, view, _eventVisitor.get()); 
    12391243            } 
    12401244        } 
  • OpenSceneGraph/trunk/src/osgViewer/View.cpp

    r13525 r13890  
    271271{ 
    272272    _startTick = tick; 
    273      
     273 
    274274    for(Devices::iterator eitr = _eventSources.begin(); 
    275275        eitr != _eventSources.end(); 
     
    396396 
    397397 
    398 void View::addEventHandler(osgGA::GUIEventHandler* eventHandler) 
     398void View::addEventHandler(osgGA::EventHandler* eventHandler) 
    399399{ 
    400400    EventHandlers::iterator itr = std::find(_eventHandlers.begin(), _eventHandlers.end(), eventHandler); 
     
    405405} 
    406406 
    407 void View::removeEventHandler(osgGA::GUIEventHandler* eventHandler) 
     407void View::removeEventHandler(osgGA::EventHandler* eventHandler) 
    408408{ 
    409409    EventHandlers::iterator itr = std::find(_eventHandlers.begin(), _eventHandlers.end(), eventHandler); 
     
    847847{ 
    848848    OSG_INFO<<"View::requestWarpPointer("<<x<<","<<y<<")"<<std::endl; 
    849      
     849 
    850850    float local_x, local_y; 
    851851    const osg::Camera* camera = getCameraContainingPosition(x, y, local_x, local_y); 
     
    888888    const osgViewer::GraphicsWindow* gw = dynamic_cast<const osgViewer::GraphicsWindow*>(eventState->getGraphicsContext()); 
    889889    bool view_invert_y = eventState->getMouseYOrientation()==osgGA::GUIEventAdapter::Y_INCREASING_DOWNWARDS; 
    890      
     890 
    891891    // OSG_NOTICE<<"getCameraContainingPosition("<<x<<", "<<y<<") view_invert_y = "<<view_invert_y<<", Xmin() = "<<eventState->getXmin()<<", Xmax() = "<<eventState->getXmax()<<", Ymin() = "<<eventState->getYmin()<<", Ymax() = "<<eventState->getYmax()<<std::endl; 
    892892 
    893893    double epsilon = 0.5; 
    894      
    895         
     894 
     895 
    896896    // if master camera has graphics context and eventState context matches then assume coordinates refer 
    897897    // to master camera 
    898898    bool masterActive = (_camera->getGraphicsContext()!=0 && _camera->getViewport()); 
    899     bool eventStateMatchesMaster = (gw!=0) ? _camera->getGraphicsContext()==gw : false;  
    900      
     899    bool eventStateMatchesMaster = (gw!=0) ? _camera->getGraphicsContext()==gw : false; 
     900 
    901901    if (masterActive && eventStateMatchesMaster) 
    902902    { 
    903903        // OSG_NOTICE<<"Event state matches master"<<std::endl; 
    904904        const osg::Viewport* viewport = _camera->getViewport(); 
    905          
     905 
    906906        // rescale mouse x,y first to 0 to 1 range 
    907907        double new_x = (x-eventState->getXmin())/(eventState->getXmax()-eventState->getXmin()); 
    908908        double new_y = (y-eventState->getYmin())/(eventState->getYmax()-eventState->getYmin()); 
    909          
     909 
    910910        // flip y if required 
    911911        if (view_invert_y) new_y = 1.0f-new_y; 
    912          
     912 
    913913        // rescale mouse x, y to window dimensions so we can check against master Camera's viewport 
    914914        new_x *= static_cast<double>(_camera->getGraphicsContext()->getTraits()->width); 
    915915        new_y *= static_cast<double>(_camera->getGraphicsContext()->getTraits()->height); 
    916          
     916 
    917917        if (new_x >= (viewport->x()-epsilon) && new_y >= (viewport->y()-epsilon) && 
    918918            new_x < (viewport->x()+viewport->width()-1.0+epsilon) && new_y <= (viewport->y()+viewport->height()-1.0+epsilon) ) 
     
    930930        } 
    931931    } 
    932      
     932 
    933933    osg::Matrix masterCameraVPW = getCamera()->getViewMatrix() * getCamera()->getProjectionMatrix(); 
    934934 
     
    991991    float local_x, local_y; 
    992992    const osg::Camera* camera = getCameraContainingPosition(x, y, local_x, local_y); 
    993      
     993 
    994994    OSG_INFO<<"computeIntersections("<<x<<", "<<y<<") local_x="<<local_x<<", local_y="<<local_y<<std::endl; 
    995      
     995 
    996996    if (camera) return computeIntersections(camera, (camera->getViewport()==0)?osgUtil::Intersector::PROJECTION : osgUtil::Intersector::WINDOW, local_x, local_y, intersections, traversalMask); 
    997997    else return false; 
     
    10021002    float local_x, local_y; 
    10031003    const osg::Camera* camera = getCameraContainingPosition(x, y, local_x, local_y); 
    1004      
     1004 
    10051005    OSG_INFO<<"computeIntersections("<<x<<", "<<y<<") local_x="<<local_x<<", local_y="<<local_y<<std::endl; 
    10061006 
     
    10161016        const osgGA::PointerData* pd = ea.getPointerData(ea.getNumPointerData()-1); 
    10171017        const osg::Camera* camera = dynamic_cast<const osg::Camera*>(pd->object.get()); 
    1018         if (camera)  
     1018        if (camera) 
    10191019        { 
    10201020            return computeIntersections(camera, osgUtil::Intersector::PROJECTION, pd->getXnormalized(), pd->getYnormalized(), intersections, traversalMask); 
     
    10321032        const osgGA::PointerData* pd = ea.getPointerData(ea.getNumPointerData()-1); 
    10331033        const osg::Camera* camera = dynamic_cast<const osg::Camera*>(pd->object.get()); 
    1034         if (camera)  
     1034        if (camera) 
    10351035        { 
    10361036            return computeIntersections(camera, osgUtil::Intersector::PROJECTION, pd->getXnormalized(), pd->getYnormalized(), nodePath, intersections, traversalMask); 
     
    11171117        _eventSources.push_back(eventSource); 
    11181118    } 
    1119      
     1119 
    11201120    if (eventSource) 
    11211121        eventSource->getEventQueue()->setStartTick(getStartTick()); 
     
    12271227        // inherit any settings applied to the master Camera. 
    12281228        camera->inheritCullSettings(*(view.getCamera()), camera->getInheritanceMask()); 
    1229          
     1229 
    12301230        if (_eyeScale<0.0) 
    12311231        { 
     
    12361236            camera->setCullMask(camera->getCullMaskRight()); 
    12371237        } 
    1238              
     1238 
    12391239        // set projection matrix 
    12401240        if (_eyeScale<0.0) 
     
    13901390    if (!camera || camera->getGraphicsContext()==0) return; 
    13911391    if (!ds->getStereo() && !ds->getKeystoneHint()) return; 
    1392      
     1392 
    13931393    ds->setUseSceneViewForStereoHint(false); 
    13941394 
     
    14051405        } 
    14061406    } 
    1407      
     1407 
    14081408    if (ds->getKeystoneHint()) 
    14091409    { 
     
    14111411    } 
    14121412 
    1413     
     1413 
    14141414    // set up view's main camera 
    14151415    { 
     
    14211421        camera->setProjectionMatrixAsPerspective( vfov, width/height, 1.0f,10000.0f); 
    14221422    } 
    1423      
     1423 
    14241424 
    14251425    osg::ref_ptr<osg::GraphicsContext> gc = camera->getGraphicsContext(); 
    1426      
     1426 
    14271427    osg::ref_ptr<osg::GraphicsContext::Traits> traits = const_cast<osg::GraphicsContext::Traits*>(camera->getGraphicsContext()->getTraits()); 
    14281428 
     
    14331433        if (!(ds->getKeystones().empty())) keystone = dynamic_cast<osgViewer::Keystone*>(ds->getKeystones().front().get()); 
    14341434        if (!keystone) keystone = new osgViewer::Keystone; 
    1435          
     1435 
    14361436        // create distortion texture 
    14371437        osg::ref_ptr<osg::Texture> texture = createDistortionTexture(traits->width, traits->height); 
     
    14471447        // attach Keystone editing event handler. 
    14481448        distortion_camera->addEventCallback(new KeystoneHandler(keystone.get())); 
    1449          
     1449 
    14501450        camera->setGraphicsContext(0); 
    1451          
     1451 
    14521452        return; 
    14531453    } 
    1454      
     1454 
    14551455    switch(ds->getStereoMode()) 
    14561456    { 
     
    14761476            // left keystone camera to render to right buffer 
    14771477            // one keystone and editing for the one window 
    1478              
     1478 
    14791479            if (!keystones.empty()) 
    14801480            { 
     
    14851485                // right keystone camera to render to right viewport/window 
    14861486                // two keystone, one for each of the left and right viewports/windows 
    1487                  
     1487 
    14881488                osg::ref_ptr<Keystone> keystone = keystones.front(); 
    14891489 
     
    15141514                // attach the texture and use it as the color buffer. 
    15151515                right_camera->attach(osg::Camera::COLOR_BUFFER, right_texture.get()); 
    1516                  
     1516 
    15171517 
    15181518                // create Keystone left distortion camera 
     
    15281528                left_keystone_camera->addEventCallback(new KeystoneHandler(keystone.get())); 
    15291529 
    1530                  
     1530 
    15311531                // create Keystone right distortion camera 
    15321532                osg::ref_ptr<osg::Camera> right_keystone_camera = assignKeystoneDistortionCamera(ds, gc.get(), 
     
    15371537                right_keystone_camera->setRenderOrder(osg::Camera::NESTED_RENDER, 3); 
    15381538                right_keystone_camera->setAllowEventFocus(false); 
    1539                  
     1539 
    15401540            } 
    15411541 
     
    15681568 
    15691569                osg::ref_ptr<Keystone> keystone = keystones.front(); 
    1570                  
     1570 
    15711571                bool useTwoTexture = true; 
    1572                  
     1572 
    15731573                if (useTwoTexture) 
    15741574                { 
    1575                      
     1575 
    15761576                    // create left distortion texture 
    15771577                    osg::ref_ptr<osg::Texture> left_texture = createDistortionTexture(traits->width, traits->height); 
     
    16291629 
    16301630                    camera->setAllowEventFocus(false); 
    1631                      
     1631 
    16321632                } 
    16331633                else 
    1634                 {                     
     1634                { 
    16351635                    // create distortion texture 
    16361636                    osg::ref_ptr<osg::Texture> texture = createDistortionTexture(traits->width, traits->height); 
     
    16651665 
    16661666                    distortion_camera->setRenderOrder(osg::Camera::NESTED_RENDER, 2); 
    1667                      
     1667 
    16681668                    // attach Keystone editing event handler. 
    16691669                    distortion_camera->addEventCallback(new KeystoneHandler(keystone.get())); 
     
    17021702                // right keystone camera to render to right viewport/window 
    17031703                // two keystone, one for each of the left and right viewports/windows 
    1704                  
     1704 
    17051705                osg::ref_ptr<Keystone> left_keystone = keystones[0]; 
    17061706                osg::ref_ptr<Keystone> right_keystone = keystones[1]; 
     
    17341734                // attach the texture and use it as the color buffer. 
    17351735                right_camera->attach(osg::Camera::COLOR_BUFFER, right_texture.get()); 
    1736                  
     1736 
    17371737 
    17381738                // create Keystone left distortion camera 
     
    17621762 
    17631763                camera->setAllowEventFocus(false); 
    1764                  
     1764 
    17651765            } 
    1766              
     1766 
    17671767            break; 
    17681768        } 
     
    17751775            int left_start = (left_eye_bottom_viewport) ? 0 : traits->height/2; 
    17761776            int right_start = (left_eye_bottom_viewport) ? traits->height/2 : 0; 
    1777              
     1777 
    17781778            // bottom viewport Camera 
    17791779            osg::ref_ptr<osg::Camera> left_camera = assignStereoCamera(ds, gc.get(), 
     
    18331833                // attach the texture and use it as the color buffer. 
    18341834                right_camera->attach(osg::Camera::COLOR_BUFFER, right_texture.get()); 
    1835                  
     1835 
    18361836 
    18371837                // create Keystone left distortion camera 
     
    18611861 
    18621862                camera->setAllowEventFocus(false); 
    1863                  
     1863 
    18641864            } 
    18651865 
     
    19111911 
    19121912                distortion_camera->setRenderOrder(osg::Camera::NESTED_RENDER, 2); 
    1913                  
     1913 
    19141914                // attach Keystone editing event handler. 
    19151915                distortion_camera->addEventCallback(new KeystoneHandler(keystone.get())); 
     
    19611961 
    19621962                distortion_camera->setRenderOrder(osg::Camera::NESTED_RENDER, 1); 
    1963                  
     1963 
    19641964                // attach Keystone editing event handler. 
    19651965                distortion_camera->addEventCallback(new KeystoneHandler(keystone.get())); 
     
    19931993 
    19941994                geode->setCullingActive(false); 
    1995                  
     1995 
    19961996                osg::ref_ptr<osg::StateSet> stateset = geode->getOrCreateStateSet(); 
    19971997 
  • OpenSceneGraph/trunk/src/osgViewer/Viewer.cpp

    r13876 r13890  
    890890                ++itr) 
    891891            { 
    892                 osgGA::GUIEventAdapter* event = itr->get(); 
     892                osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     893                if (!event) continue; 
    893894 
    894895                event->setGraphicsContext(gw); 
     
    944945                ++itr) 
    945946            { 
    946                 osgGA::GUIEventAdapter* event = itr->get(); 
     947                osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     948                if (!event) continue; 
    947949                switch(event->getEventType()) 
    948950                { 
     
    982984            ++itr) 
    983985        { 
    984             osgGA::GUIEventAdapter* event = itr->get(); 
     986            osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     987            if (!event) continue; 
    985988            switch(event->getEventType()) 
    986989            { 
     
    10101013            ++itr) 
    10111014        { 
    1012             osgGA::GUIEventAdapter* event = itr->get(); 
     1015            osgGA::GUIEventAdapter* event = (*itr)->asGUIEventAdapter(); 
     1016            if (!event) continue; 
    10131017 
    10141018            _eventVisitor->reset(); 
     
    10561060        ++itr) 
    10571061    { 
    1058         osgGA::GUIEventAdapter* event = itr->get(); 
    1059  
     1062        osgGA::Event* event = itr->get(); 
    10601063        for(EventHandlers::iterator hitr = _eventHandlers.begin(); 
    10611064            hitr != _eventHandlers.end(); 
    10621065            ++hitr) 
    10631066        { 
    1064             (*hitr)->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *this, 0, _eventVisitor.get()); 
     1067            (*hitr)->handle( event, 0, _eventVisitor.get()); 
    10651068        } 
    10661069 
     
    10711074        ++itr) 
    10721075    { 
    1073         osgGA::GUIEventAdapter* event = itr->get(); 
    1074         if (_cameraManipulator.valid()) 
    1075         { 
    1076             _cameraManipulator->handleWithCheckAgainstIgnoreHandledEventsMask( *event, *this); 
     1076        osgGA::Event* event = itr->get(); 
     1077        if (event && _cameraManipulator.valid()) 
     1078        { 
     1079            _cameraManipulator->handle( event, 0, _eventVisitor.get()); 
    10771080        } 
    10781081    }