RootScene.h

#ifndef ROOTSCENE
#define ROOTSCENE

#include <iostream>
#include <string>
#include <string>

#include <osg/ref_ptr>
#include <osg/AutoTransform>
#include <osg/Node>

#include "ProtectedGroup.h"
#include "Settings.h"
#include "../libGUI/hudcamera.h"
#include "UserScene.h"
#include "Entity2D.h"
#include "Stroke.h"
#include "Photo.h"
#include "Bookmarks.h"
#include "../libGUI/ListWidget.h"
#include "ToolGlobal.h"
#include "SceneState.h"
#include "SVMData.h"
#include "CamPoseData.h"
#include "DraggableWire.h"

#include <QUndoStack>
#include <QModelIndex>

namespace fur{
class AddStrokeCommand;
}
namespace entity{
class SceneState;
class UserScene;
class Bookmarks;
}

class RootScene : public osg::ProtectedGroup {
public:
    RootScene(QUndoStack* undoStack);

    entity::UserScene* getUserScene() const;

    QUndoStack* getUndoStack() const;

    void setFilePath(const std::string& name);

    bool isSetFilePath() const;

    bool isSavedToFile() const;

    void setSavedToFile(bool saved);

    bool isEmptyScene() const;

    void clearUserData();

    void setToolsVisibility(bool vis);

    bool getToolsVisibility() const;

    void setAxesVisibility(bool vis);

    bool getAxesVisibility() const;

    void setCanvasVisibilityAll(entity::Canvas* canvas, bool vis);

    bool getCanvasVisibilityAll(entity::Canvas* canvas) const;

    bool writeScenetoFile();

    bool exportSceneToFile(const std::string& name);

    bool loadSceneFromFile();

    int getStrokeLevel() const;

    int getCanvasLevel() const;

    int getPhotoLevel() const;

    void addCanvas(const osg::Matrix& R, const osg::Matrix& T);

    void addCanvas(const osg::Vec3f& normal, const osg::Vec3f& center);

    void addCanvas(const osg::Matrix& R, const osg::Matrix& T, const std::string& name);

    void addStroke(float u, float v, cher::EVENT event);

    void addPolygon(float u, float v, cher::EVENT event);

    void addLineSegment(float u, float v, cher::EVENT event);

    void selectAllEntities();

    void addPhoto(const std::string& fname);

    void addBookmark(BookmarkWidget* widget, const osg::Vec3d& eye, const osg::Vec3d& center, const osg::Vec3d& up, const double& fov);

    bool addSVMData();

    bool addPhotoScaleData();

    bool hidePhotoScaleData();

    bool removePhotoScaleData();

    const entity::SVMData* getPhotoScaleData() const;

    /* A method to supplement a last added entity::SceneState with entity::CamPoseData as a child.
     * Used to create a new bookmark using user interaction. This method requires presense of at least
     * one canvas on the scene. */
    bool addCamPoseData();

    void hideAndUpdateSVMData();

    void hideAndUpdateCamPoseData();

    entity::SVMData* getSVMDataCurrent() const;

    entity::CamPoseData* getCamPoseDataCurrent() const;

    void addBookmarkTool(const osg::Vec3d& eye, const osg::Vec3d& center, const osg::Vec3d& up);
    void updateBookmark(BookmarkWidget* widget, int row);
    void deleteBookmark(BookmarkWidget* widget, const QModelIndex& index);
    void deleteBookmarkTool(int first, int last);

    void resetBookmarks(BookmarkWidget* widget);

    void setBookmarkToolVisibility(bool vis);

    bool getBookmarkToolVisibility() const;

    void eraseStroke(entity::Stroke* stroke, int first, int last, cher::EVENT event);

    bool setCanvasCurrent(entity::Canvas* cnv);
    bool setCanvasPrevious(entity::Canvas* cnv);

    void setCanvasesButCurrent(bool enable);

    void setAllCanvases(bool enable);

    entity::Canvas* getCanvasCurrent() const;
    entity::Canvas* getCanvasPrevious() const;
    entity::Bookmarks* getBookmarksModel() const;

    void editCanvasOffset(const osg::Vec3f& translate, cher::EVENT event);
    void editCanvasRotate(const osg::Quat& rotation, const osg::Vec3f& center3d, cher::EVENT event);
    void editCanvasClone(const osg::Vec3f& translate, cher::EVENT event);
    void editCanvasSeparate(const osg::Vec3f& translate, cher::EVENT event);
    void editCanvasDelete(entity::Canvas* canvas);

    void editPhotoDelete(entity::Photo* photo, entity::Canvas* canvas);
    void editPhotoPush(entity::Photo* photo, entity::Canvas* source, entity::Canvas* destination);

    void editPolygonDelete(entity::Polygon* poly, entity::Canvas* canvas);

    void editStrokesPush(osg::Camera *camera);
    void editStrokesMove(double u, double v, cher::EVENT event);
    void editStrokesScale(double u, double v, cher::EVENT event);
    void editStrokesRotate(double u, double v, cher::EVENT event);
    void editStrokeDelete(entity::Stroke* stroke);

    void editEntity2DDelete(entity::Entity2D* entity);

    void copyToBuffer();
    void cutToBuffer();
    void pasteFromBuffer();

    const std::vector< osg::ref_ptr<entity::Entity2D> >& getBuffer() const;

    entity::SceneState* createSceneState() const;

    bool setSceneState(const entity::SceneState* state);

    entity::BookmarkTool* getBookmarkTool(int index);

protected:

private:
    osg::ref_ptr<entity::UserScene> m_userScene;
    osg::ref_ptr<entity::AxisGlobalTool> m_axisTool;
    osg::ref_ptr<osg::Group> m_bookmarkTools;
    std::vector< osg::ref_ptr<entity::Entity2D> > m_buffer; /* copy-paste buffer */
    QUndoStack* m_undoStack;
    bool m_saved;
    bool m_visibilityBookmarkTool;
};

#endif // SCENE