/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSGVIEWER_SimpleViewer
#define OSGVIEWER_SimpleViewer 1

#include <osgGA/EventVisitor>
#include <osgGA/MatrixManipulator>

#include <osgViewer/GraphicsWindow>

#include <osgDB/DatabasePager>

#include <list>

namespace osgViewer{

/** SimpleViewer provide a simple interface for setting up rendering of an scene graph, using a single camera view within a single window.*/
class OSGVIEWER_EXPORT SimpleViewer : public virtual osgViewer::GraphicsWindow
{
    public:

        SimpleViewer();
        virtual ~SimpleViewer();

        void setSceneData(osg::Node* node);
        osg::Node* getSceneData();
        const osg::Node* getSceneData() const;

        void setDatabasePager(osgDB::DatabasePager* dp);
        osgDB::DatabasePager* getDatabasePager() { return _databasePager.get(); }
        const osgDB::DatabasePager* getDatabasePager() const { return _databasePager.get(); }


        osg::Camera* getCamera();
        const osg::Camera* getCamera() const;

        void setCameraManipulator(osgGA::MatrixManipulator* manipulator);
        osgGA::MatrixManipulator* getCameraManipulator() { return _cameraManipulator.get(); }
        const osgGA::MatrixManipulator* getCameraManipulator() const { return _cameraManipulator.get(); }


        typedef std::list< osg::ref_ptr<osgGA::GUIEventHandler> > EventHandlers;
        
        void addEventHandler(osgGA::GUIEventHandler* eventHandler);
        EventHandlers& getEventHandlers() { return _eventHandlers; }
        const EventHandlers& getEventHandlers() const { return _eventHandlers; }



        /** Render a complete new frame.
          * Calls frameAdvance(), frameEventTraversal(), frameUpateTraversal(), frameCullTraversal() and frameDrawTraversal().
          * Note, no internal makeCurrent() is issued before, or swap buffers called after frame(), these operations are the responsibility of the calling code.*/ 
        virtual void frame(double simulationTime=USE_REFERENCE_TIME);

        virtual void advance(double simulationTime=USE_REFERENCE_TIME);
        virtual void eventTraversal();
        virtual void updateTraversal();
        virtual void renderingTraversal();

        /** Release all OpenGL objects associated with this viewer's scenegraph. Note, does not deleted the actual OpenGL objects, it just releases them to the pending GL object delete lists which will need flushing once a valid graphics context is obtained.*/ 
        virtual void releaseAllGLObjects();

        /** Clean up all OpenGL objects associated with this viewer's scenegraph. Note, must only be called from the graphics context associated with this viewer.*/ 
        virtual void cleanup();

    public:

        osgUtil::SceneView* getSceneView() { return _sceneView.get(); }
        const osgUtil::SceneView* getSceneView() const { return _sceneView.get(); }

        void init();

    protected:
    
    
        bool                                    _firstFrame;
        osg::ref_ptr<osg::FrameStamp>           _frameStamp;

        osg::ref_ptr<osgUtil::SceneView>        _sceneView;

        osg::ref_ptr<osgGA::MatrixManipulator>  _cameraManipulator;
        EventHandlers                           _eventHandlers;

        osg::ref_ptr<osgGA::EventVisitor>       _eventVisitor;
                
        osg::ref_ptr<osgDB::DatabasePager>      _databasePager;
    
};


}

#endif