lib/client/config.h

/* Copyright (c) 2005-2009, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * 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 GNU Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQ_CONFIG_H
#define EQ_CONFIG_H

#include <eq/client/commandQueue.h>  // member
#include <eq/client/observer.h>      // member
#include <eq/client/types.h>         // typedefs
#include <eq/client/visitorResult.h> // enum

#include <eq/net/session.h>          // base class
#include <eq/base/monitor.h>         // member

namespace eq
{
    class ConfigDeserializer;
    class ConfigVisitor;
    class Node;
    class SceneObject;
    struct ConfigEvent;

    class Config : public net::Session
    {
    public:
        EQ_EXPORT Config( ServerPtr parent );

        EQ_EXPORT virtual ~Config();

        EQ_EXPORT ClientPtr getClient();
        EQ_EXPORT ServerPtr getServer();

        EQ_EXPORT CommandQueue* getNodeThreadQueue();

        uint32_t getCurrentFrame()  const { return _currentFrame; }
        uint32_t getFinishedFrame() const { return _finishedFrame.get(); }
        uint32_t getLatency() const { return _latency; }

        const NodeVector& getNodes() const { return _nodes; }

        const ObserverVector& getObservers() const { return _observers; }

        Observer* findObserver( const uint32_t id );

        const LayoutVector& getLayouts() const { return _layouts; }

        EQ_EXPORT Layout* findLayout( const uint32_t id );

        EQ_EXPORT View* findView( const uint32_t id );

        const CanvasVector& getCanvases() const { return _canvases; }

        const std::string& getName() const { return _name; }

        EQ_EXPORT VisitorResult accept( ConfigVisitor& visitor );

        EQ_EXPORT void getStatistics( std::vector< FrameStatistics >& stats );

        bool isRunning() const { return _running; }

        void stopRunning() { _running = false; }

        int64_t getTime() const { return _clock.getTime64(); }

        EQ_EXPORT virtual bool init( const uint32_t initID );

        EQ_EXPORT virtual bool exit();

        EQ_EXPORT virtual uint32_t startFrame( const uint32_t frameID );

        EQ_EXPORT virtual uint32_t finishFrame();

        EQ_EXPORT virtual uint32_t finishAllFrames();

        void releaseFrameLocal( const uint32_t frameNumber )
            { _unlockedFrame = frameNumber; }

        EQ_EXPORT void sendEvent( ConfigEvent& event );

        EQ_EXPORT const ConfigEvent* nextEvent();

        EQ_EXPORT const ConfigEvent* tryNextEvent();

        bool checkEvent() const { return !_eventQueue.isEmpty(); }

        EQ_EXPORT virtual void handleEvents();

        EQ_EXPORT virtual bool handleEvent( const ConfigEvent* event );
        
#ifdef EQ_USE_DEPRECATED

        EQ_EXPORT void setHeadMatrix( const vmml::Matrix4f& matrix );

        EQ_EXPORT const vmml::Matrix4f& getHeadMatrix() const;

        EQ_EXPORT void setEyeBase( const float eyeBase );

        EQ_EXPORT float getEyeBase() const;
#endif

        const std::string& getErrorMessage() const { return _error; }

#ifdef EQ_TRANSMISSION_API

        void broadcastData( const void* data, uint64_t size );
#endif

        EQ_EXPORT void freezeLoadBalancing( const bool onOff );

        void setWindowSystem( const WindowSystem windowSystem );

    protected:

        EQ_EXPORT virtual void notifyMapped( net::NodePtr node );

    private:
        net::NodeID _appNodeID;
        friend class Server;

        std::string _name;

        net::NodePtr _appNode;

#ifdef EQ_TRANSMISSION_API

        std::vector<net::NodeID> _clientNodeIDs;

        net::NodeVector _clientNodes;
#endif

        NodeVector _nodes;

        ObserverVector _observers;

        LayoutVector _layouts;

        CanvasVector _canvases;

        float _eyeBase;

        std::string _error;

        CommandQueue _eventQueue;
        
        net::Command* _lastEvent;

        std::deque< FrameStatistics > _statistics;
        base::Lock                    _statisticsMutex;

        uint32_t _latency;

        uint32_t _currentFrame;
        uint32_t _unlockedFrame;
        base::Monitor< uint32_t > _finishedFrame;

        base::Clock _clock;

        bool _running;

        union // placeholder for binary-compatible changes
        {
            char dummy[64];
        };

        friend class Node;
        void _addNode( Node* node );
        void _removeNode( Node* node );
        Node* _findNode( const uint32_t id );

        friend class ConfigDeserializer;
        void _addObserver( Observer* observer );
        void _removeObserver( Observer* observer );
        void _addLayout( Layout* layout );
        void _removeLayout( Layout* layout );
        void _addCanvas( Canvas* canvas );
        void _removeCanvas( Canvas* canvas );

        bool _needsLocalSync() const;

        void _updateStatistics( const uint32_t finishedFrame );

#ifdef EQ_TRANSMISSION_API

        bool _connectClientNodes();
#endif

        void _initAppNode( const uint32_t distributorID );

        net::CommandResult _cmdSyncClock( net::Command& command );
        net::CommandResult _cmdCreateNode( net::Command& command );
        net::CommandResult _cmdDestroyNode( net::Command& command );
        net::CommandResult _cmdInitReply( net::Command& command );
        net::CommandResult _cmdExitReply( net::Command& command );
        net::CommandResult _cmdStartFrameReply( net::Command& command );
        net::CommandResult _cmdReleaseFrameLocal( net::Command& command );
        net::CommandResult _cmdFrameFinish( net::Command& command );
#ifdef EQ_TRANSMISSION_API
        net::CommandResult _cmdData( net::Command& command );
#endif
        net::CommandResult _cmdUnmap( net::Command& command );
    };
}

#endif // EQ_CONFIG_H