UserScene.h

#ifndef USERSCENE_H
#define USERSCENE_H

#include <string>

#include <QUndoStack>
#include <QObject>
#include <QModelIndex>
#include <QTreeWidgetItem>

#include <osg/Group>
#include <osg/ref_ptr>
#include <osg/observer_ptr>
#include <osgDB/ObjectWrapper>
#include <osg/Camera>

#include "ProtectedGroup.h"
#include "Canvas.h"
#include "Stroke.h"
#include "Polygon.h"
#include "Photo.h"
#include "LineSegment.h"
#include "Bookmarks.h"
#include "../libGUI/ListWidget.h"
#include "../libGUI/TreeWidget.h"
#include "../libSGControls/AddEntityCommand.h"
#include "../libSGControls/EditEntityCommand.h"

namespace entity {
class Bookmarks;
}

class BookmarkWidget;
namespace fur {
class AddCanvasCommand;
class AddPhotoCommand;
class EditCanvasDeleteCommand;
class AddCanvasSeparationCommand;
class EditPhotoDeleteCommand;
class EditEntityDeleteCommand;
class AddStrokeCommand;
class AddPolygonCommand;
class AddEntityCommand;
class AddLineSegmentCommand;
class EditStrokesPushCommand;
class EditStrokeDeleteCommand;
class EditPasteCommand;
class EditCutCommand;
class EditPhotoPushCommand;
class EditSelectedEntitiesDeleteCommand;
}

namespace entity {

class UserScene : public QObject, public osg::ProtectedGroup
{
    Q_OBJECT
public:
    UserScene();

    UserScene(const UserScene& scene, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);

    META_Node(entity, UserScene)

    
    void initializeSG();

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    void setGroupCanvases(osg::Group* group);
    const osg::Group* getGroupCanvases() const;

    void setBookmarks(entity::Bookmarks* group);
    const entity::Bookmarks* getBookmarks() const;
    entity::Bookmarks* getBookmarksModel() const;

    void setIdCanvas(unsigned int id);
    unsigned int getIdCanvas() const;

    void setIdPhoto(unsigned int id);
    unsigned int getIdPhoto() const;

    void setIdBookmark(unsigned int id);
    unsigned int getIdBookmark() const;

    void setFilePath(const std::string& name);
    const std::string& getFilePath() const;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */

    bool isSetFilePath() const;


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

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

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


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

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

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

    void addPhoto(QUndoStack* stack, const std::string& fname);


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

    void updateBookmark(BookmarkWidget *widget, int row);

    void deleteBookmark(BookmarkWidget *widget, const QModelIndex& index);


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


    entity::Canvas* getCanvas(unsigned int id);

    entity::Canvas* getCanvas(const std::string& name);


    int getStrokeLevel() const;

    int getCanvasLevel() const;

    int getPhotoLevel() const;


    bool setCanvasCurrent(entity::Canvas* cnv);

    bool setCanvasPrevious(entity::Canvas* cnv);

    void setCanvasesButCurrent(bool enabled);

    void setAllCanvases(bool enabled);

    bool getCanvasesButCurrent() const;

    entity::Canvas* getCanvasCurrent() const;

    entity::Canvas* getCanvasPrevious() const;


    int getCanvasIndex(entity::Canvas* canvas) const;

    int getPhotoIndex(entity::Photo* photo, entity::Canvas* canvas) const;

    entity::Canvas* getCanvasFromIndex(int row);

    entity::Photo* getPhoto(entity::Canvas* canvas, int row);

    int getNumCanvases() const;

    int getNumPhotos(entity::Canvas* canvas) const;

    int getNumPhotos();

    int getNumPhotosTill(entity::Canvas* canvas);

    void editCanvasOffset(QUndoStack* stack, const osg::Vec3f& translate, cher::EVENT event);

    void editCanvasRotate(QUndoStack* stack, const osg::Quat& rotation, const osg::Vec3f& center3d, cher::EVENT event);

    void editCanvasClone(QUndoStack* stack, const osg::Vec3f& translate, cher::EVENT event);

    void editCanvasSeparate(QUndoStack* stack, const osg::Vec3f& translate, cher::EVENT event);

    void editCanvasDelete(QUndoStack* stack, entity::Canvas* canvas);

    void editPhotoDelete(QUndoStack* stack, entity::Photo* photo, entity::Canvas* canvas);

    void editPhotoPush(QUndoStack* stack, entity::Photo* photo, entity::Canvas* source,
                       entity::Canvas* destination);

    void editPhotoTransparency(entity::Photo* photo, entity::Canvas* canvas, float t);

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

    void editStrokesPush(QUndoStack* stack, osg::Camera* camera);


    void editStrokesMove(QUndoStack* stack, double u, double v, cher::EVENT event);

    void editStrokesScale(QUndoStack* stack, double u, double v, cher::EVENT event);

    void editStrokesRotate(QUndoStack* stack, double u, double v, cher::EVENT event);

    void editStrokeDelete(QUndoStack* stack, entity::Stroke* stroke);

    void editEntity2DDelete(QUndoStack* stack, entity::Entity2D* entity);

    void editSelectedEntitiesDelete(QUndoStack* stack);

    bool isEntityCurrent() const;


    bool isEmptyScene() const;

    bool clearUserData();

    void updateWidgets();

    void resetModel(CanvasPhotoWidget* widget);

signals:
    void sendRequestUpdate();

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

    void photoAdded(const std::string& name, int idxCanvas);

    void canvasRemoved(int row);

    void photoRemoved(int rowCanvas, int rowPhoto);

    void canvasSelectedColor(int row, int color);

    void canvasVisibilitySet(int row, bool visibility);

    void requestSceneToolStatus(bool& visibility);

    void requestCanvasCreate(const osg::Vec3f& eye, const osg::Vec3f& center, const osg::Vec3f& up);

public slots:
    void onItemChanged(QTreeWidgetItem* item, int column);

    void onClicked(const QModelIndex& index);

    void onRightClicked(const QModelIndex& index);

protected:
    std::string getCanvasName();
    std::string getPhotoName();
    std::string getBookmarkName();
    std::string getEntityName(const std::string& name, unsigned int id) const;

    void strokeStart();
    void strokeAppend(float u, float v);
    void strokeFinish(QUndoStack* stack);
    bool strokeValid() const;

    void polygonStart();
    void polygonAppend(float u, float v, QUndoStack *stack);
    void polygonEdit(float u, float v);
    void polygonFinish(QUndoStack* stack);
    bool polygonValid() const;

    void linesegmentStart();
    void linesegmentAppend(float u, float v, QUndoStack* stack);
    void linesegmentEdit(float u, float v);
    void linesegmentFinish(QUndoStack* stack);
    bool linesegmentValid() const;

    void entitiesMoveStart(double u, double v);
    void entitiesMoveAppend(double u, double v);
    void entitiesMoveFinish(QUndoStack* stack);
    bool entitiesSelectedValid() const;

    void entitiesScaleStart(double u, double v);
    void entitiesScaleAppend(double u, double v);
    void entitiesScaleFinish(QUndoStack* stack);

    void entitiesRotateStart(double u, double v);
    void entitiesRotateAppend(double u, double v);
    void entitiesRotateFinish(QUndoStack* stack);

    void eraseStart(entity::Stroke* stroke, osg::Vec3d& hit);
    void eraseAppend(entity::Stroke* stroke, osg::Vec3d& hit);
    void eraseFinish(QUndoStack* stack, entity::Stroke* stroke);
    bool eraseValid(entity::Stroke* stroke) const;

    void canvasOffsetStart();
    void canvasOffsetAppend(const osg::Vec3f& t);
    void canvasOffsetFinish(QUndoStack* stack);
    bool canvasEditValid() const;

    void canvasCloneStart();
    void canvasCloneAppend(const osg::Vec3f& t);
    void canvasCloneFinish(QUndoStack* stack);
    bool canvasCloneValid() const;

    void canvasSeparateStart();
    void canvasSeparateAppend(const osg::Vec3f& t);
    void canvasSeparateFinish(QUndoStack* stack);

    void canvasRotateStart();
    void canvasRotateAppend(const osg::Quat& r, const osg::Vec3f& center3d);
    void canvasRotateFinish(QUndoStack* stack);

    friend class ::fur::AddCanvasCommand;
    friend class ::fur::AddPhotoCommand;
    friend class ::fur::EditCanvasDeleteCommand;
    friend class ::fur::AddCanvasSeparationCommand;
    friend class ::fur::EditPhotoDeleteCommand;
    friend class ::fur::EditEntityDeleteCommand;
    friend class ::fur::AddStrokeCommand;
    friend class ::fur::AddPolygonCommand;
    friend class ::fur::AddEntityCommand;
    friend class ::fur::AddLineSegmentCommand;
    friend class ::fur::EditStrokesPushCommand;
    friend class ::fur::EditStrokeDeleteCommand;
    friend class ::fur::EditPasteCommand;
    friend class ::fur::EditCutCommand;
    friend class ::fur::EditPhotoPushCommand;
    friend class ::fur::EditSelectedEntitiesDeleteCommand;

    bool addCanvas(entity::Canvas* canvas);
    bool removeCanvas(entity::Canvas* canvas);

    bool addEntity(entity::Canvas* canvas, entity::Entity2D* entity);
    bool removeEntity(entity::Canvas* canvas, entity::Entity2D* entity);

private:
    osg::ref_ptr<osg::Group>            m_groupCanvases;    
    osg::ref_ptr<entity::Bookmarks>     m_groupBookmarks;   
    osg::observer_ptr<entity::Canvas>   m_canvasCurrent;    
    osg::observer_ptr<entity::Canvas>   m_canvasPrevious;   
    osg::ref_ptr<entity::Canvas>        m_canvasClone;      
    osg::Vec3f      m_deltaT;    
    osg::Quat       m_deltaR;     
    double          m_u              
        ,           m_v;             
    bool            m_inits;           
    double          m_du             
        ,           m_dv;            
    double          m_scaleX         
        ,           m_scaleY;        
    double          m_rotate;        
    unsigned int    m_idCanvas;    
    unsigned int    m_idPhoto;     
    unsigned int    m_idBookmark;  
    std::string     m_filePath;     
};

}

#endif // USERSCENE_H