canvas separation api and ui, without actual implementation

src/dureu3d/Data.cpp

@@ -192,6 +192,13 @@ const QIcon &Data::sceneNewCanvasOrthoIcon()
     return icon;
 }
 
+const QIcon &Data::sceneNewCanvasSeparateIcon()
+{
+    Q_ASSERT_X(!QPixmap(":/scene-newcanvas-separate-24px.svg").isNull(), Q_FUNC_INFO, "Required resource not available");
+    static QIcon icon(":/scene-newcanvas-separate-24px.svg");
+    return icon;
+}
+
 const QIcon &Data::sceneNewCanvasSetIcon()
 {
     Q_ASSERT_X(!QPixmap(":/scene-newcanvas-set-24px.svg").isNull(), Q_FUNC_INFO, "Required resource not available");

src/dureu3d/Data.h

@@ -43,6 +43,7 @@ class Data
     static const QIcon& sceneNewCanvasYZIcon();
     static const QIcon& sceneNewCanvasXZIcon();
     static const QIcon& sceneNewCanvasOrthoIcon();
+    static const QIcon& sceneNewCanvasSeparateIcon();
 
     static const QIcon& sceneNewCanvasSetIcon();
     static const QIcon& sceneNewCanvasSetParallelIcon();

src/dureu3d/Data/Actions.qrc

@@ -74,5 +74,6 @@
         <file>scene-canvas-edit-24px.svg</file>
         <file>edit-photo-transparency-on-24px.svg</file>
         <file>edit-photo-transparency-off-24px.svg</file>
+        <file>scene-newcanvas-separate-24px.svg</file>
     </qresource>
 </RCC>

src/dureu3d/Settings.h

@@ -61,7 +61,7 @@ const osg::Vec4 cyan = osg::Vec4(float(42)/255.0f, float(161)/255.0f, float(152)
 const osg::Vec4 green = osg::Vec4(float(133)/255.0f, float(153)/255.0f, float(0)/255.0f, 1.0f);
 } // solarized
 
-
+// TODO: settings must be initialized based on screen resolution
 
 namespace dureu{
 
@@ -108,6 +108,7 @@ enum MOUSE_MODE
 
     MOUSE_CREATE = 0x300,
     CREATE_CANVASCLONE,
+    CREATE_CANVASSEPARATE,
 
     MOUSE_CANVAS = 0x400,
     CANVAS_OFFSET,

src/dureu3d/Utilities.cpp

@@ -410,6 +410,7 @@ QCursor *Utilities::getCursorFromMode(dureu::MOUSE_MODE mode)
         break;
 
     case dureu::CREATE_CANVASCLONE:
+    case dureu::CREATE_CANVASSEPARATE:
         cur = new QCursor(Data::sceneCanvasCloneCursor());
         break;
     default:

src/libGUI/MainWindow.cpp

@@ -569,6 +569,12 @@ void MainWindow::onNewCanvasOrtho()
     this->recievedRequestUpdate();
 }
 
+void MainWindow::onNewCanvasSeparate()
+{
+    m_glWidget->setMouseMode(dureu::CREATE_CANVASSEPARATE);
+    this->recievedRequestUpdate();
+}
+
 void MainWindow::onNewCanvasStandard()
 {
     m_rootScene->addCanvas(osg::Matrix::identity(),
@@ -774,6 +780,9 @@ void MainWindow::initializeActions()
     m_actionCanvasOrtho = new QAction(Data::sceneNewCanvasOrthoIcon(), tr("Perpendicular to current"), this);
     this->connect(m_actionCanvasOrtho, SIGNAL(triggered(bool)), this, SLOT(onNewCanvasOrtho()));
 
+    m_actionCanvasSeparate = new QAction(Data::sceneNewCanvasSeparateIcon(), tr("Separate selected strokes"), this);
+    this->connect(m_actionCanvasSeparate, SIGNAL(triggered(bool)), this, SLOT(onNewCanvasSeparate()));
+
     m_actionCanvasXY = new QAction(Data::sceneNewCanvasXYIcon(), tr("Plane XY"), this);
     this->connect(m_actionCanvasXY, SIGNAL(triggered(bool)), this, SLOT(onNewCanvasXY()));
 
@@ -877,6 +886,7 @@ void MainWindow::initializeMenus()
     submenuCanvas->addAction(m_actionCanvasYZ);
     submenuCanvas->addAction(m_actionCanvasXZ);
     submenuCanvas->addAction(m_actionCanvasOrtho);
+    submenuCanvas->addAction(m_actionCanvasSeparate);
     QMenu* submenuSet = menuScene->addMenu("New Canvas Set");
     submenuSet->setIcon(Data::sceneNewCanvasSetIcon());
     submenuSet->addAction(m_actionSetStandard);
@@ -940,6 +950,7 @@ void MainWindow::initializeToolbars()
     menuNewCanvas->addAction(m_actionCanvasXZ);
     menuNewCanvas->addAction(m_actionCanvasClone);
     menuNewCanvas->addAction(m_actionCanvasOrtho);
+    menuNewCanvas->addAction(m_actionCanvasSeparate);
     QToolButton* tbNewCanvas = new QToolButton();
     tbNewCanvas->setIcon(Data::sceneNewCanvasIcon());
     tbNewCanvas->setMenu(menuNewCanvas);

src/libGUI/MainWindow.h

@@ -84,6 +84,7 @@ private slots:
     void onNewCanvasYZ();
     void onNewCanvasXZ();
     void onNewCanvasOrtho();
+    void onNewCanvasSeparate();
     void onNewCanvasStandard();
     void onNewCanvasCoaxial();
     void onNewCanvasParallel();
@@ -142,19 +143,15 @@ private slots:
             , * m_actionCameraSettings;
 
     // SCENE actions
-    QAction * m_actionSketch, * m_actionEraser, * m_actionSelect            
+    QAction * m_actionSketch, * m_actionEraser, * m_actionSelect
             // New Canvas sub-menu
             , * m_actionCanvasClone, * m_actionCanvasXY, * m_actionCanvasYZ, * m_actionCanvasXZ
-            , * m_actionCanvasOrtho
+            , * m_actionCanvasOrtho, * m_actionCanvasSeparate
             // New Canvas Set sub-menu
             , * m_actionSetStandard
 //            , * m_actionSetParallel, * m_actionSetCoaxial, * m_actionSetRing
             // Edit Canvas
-//            , * m_actionCanvasOffset, * m_actionCanvasRotate
             , * m_actionCanvasEdit
-            // Edit Image
-//            , * m_actionImageMove, * m_actionImageRotate, * m_actionImageScale, * m_actionImageFlipV
-//            , * m_actionImageFlipH
             // Edit Strokes
             , * m_actionStrokesPush
     ;

src/libSGControls/EventHandler.cpp

@@ -82,6 +82,9 @@ bool EventHandler::handle(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdap
         if (m_mode == dureu::CREATE_CANVASCLONE){
             this->doCanvasClone(ea, aa);
         }
+        else if (m_mode == dureu::CREATE_CANVASSEPARATE){
+            this->doCanvasSeparate(ea, aa);
+        }
         break;
     case dureu::MOUSE_CANVAS:
         switch (m_mode){
@@ -398,6 +401,37 @@ void EventHandler::doCanvasClone(const osgGA::GUIEventAdapter &ea, osgGA::GUIAct
     }
 }
 
+void EventHandler::doCanvasSeparate(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa)
+{
+    if (!( (ea.getEventType() == osgGA::GUIEventAdapter::PUSH && ea.getButtonMask()== osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON)
+           || (ea.getEventType() == osgGA::GUIEventAdapter::DRAG && ea.getButtonMask()== osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON)
+           || (ea.getEventType() == osgGA::GUIEventAdapter::RELEASE && ea.getButton()==osgGA::GUIEventAdapter::LEFT_MOUSE_BUTTON)
+           ))
+        return;
+    if (m_scene->getCanvasCurrent()->getStrokesSelectedSize() == 0)
+        return;
+
+    osg::Vec3f XC = osg::Vec3f(0.f,0.f,0.f);
+    switch (ea.getEventType()){
+    case osgGA::GUIEventAdapter::PUSH:
+        if (!this->getRaytraceNormalProjection(ea,aa,XC)) return;
+        m_scene->editCanvasSeparate(XC, dureu::EVENT_PRESSED);
+        break;
+    case osgGA::GUIEventAdapter::RELEASE:
+        if (!this->getRaytraceNormalProjection(ea,aa,XC))
+            this->finishAll();
+        m_scene->editCanvasSeparate(XC, dureu::EVENT_RELEASED);
+        break;
+    case osgGA::GUIEventAdapter::DRAG:
+        if (!this->getRaytraceNormalProjection(ea,aa,XC))
+            this->finishAll();
+        m_scene->editCanvasSeparate(XC, dureu::EVENT_DRAGGED);
+        break;
+    default:
+        break;
+    }
+}
+
 void EventHandler::doEditEntitiesMove(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa)
 {
 //    if (!this->setSubSelectionType(ea, aa)) return;

src/libSGControls/EventHandler.h

@@ -50,6 +50,7 @@ class EventHandler : public osgGA::GUIEventHandler {
     void doEditCanvasRotate(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa,
                             osg::Vec3f alongAxis, osg::Vec3f rotAxis);
     void doCanvasClone(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);
+    void doCanvasSeparate(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);
 
     template <typename T1, typename T2>
     void doEditPhotoPush(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

src/libSGEntities/RootScene.cpp

@@ -337,6 +337,12 @@ void RootScene::editCanvasClone(const osg::Vec3f &translate, dureu::EVENT event)
     m_saved = false;
 }
 
+void RootScene::editCanvasSeparate(const osg::Vec3f &translate, dureu::EVENT event)
+{
+    m_userScene->editCanvasSeparate(m_undoStack, translate, event);
+    m_saved = false;
+}
+
 void RootScene::editCanvasDelete(entity::Canvas *canvas)
 {
     m_userScene->editCanvasDelete(m_undoStack, canvas);

src/libSGEntities/RootScene.h

@@ -98,6 +98,7 @@ class RootScene : public osg::Group {
     void editCanvasOffset(const osg::Vec3f& translate, dureu::EVENT event);
     void editCanvasRotate(const osg::Quat& rotation, const osg::Vec3f& center3d, dureu::EVENT event);
     void editCanvasClone(const osg::Vec3f& translate, dureu::EVENT event);
+    void editCanvasSeparate(const osg::Vec3f& translate, dureu::EVENT event);
     void editCanvasDelete(entity::Canvas* canvas);
 
     void editPhotoDelete(entity::Photo* photo, entity::Canvas* canvas);

src/libSGEntities/SelectedGroup.cpp

@@ -88,6 +88,12 @@ const std::vector<entity::Entity2D *> &entity::SelectedGroup::getEntities() cons
     return m_group;
 }
 
+entity::Entity2D *entity::SelectedGroup::getEntity(int i) const
+{
+    if (i<0 || i>= (int)m_group.size()) return 0;
+    return m_group.at(i);
+}
+
 int entity::SelectedGroup::getSize() const
 {
     return m_group.size();

src/libSGEntities/SelectedGroup.h

@@ -17,6 +17,7 @@ class SelectedGroup
     void resetAll();
     void selectAll(osg::Geode* geodeData);
     const std::vector<Entity2D *> &getEntities() const;
+    entity::Entity2D* getEntity(int i) const;
     int getSize() const;
     bool isEmpty() const;
     osg::Vec3f getCenter3D(const osg::Matrix& M) const;

src/libSGEntities/UserScene.cpp

@@ -597,6 +597,39 @@ void entity::UserScene::editCanvasClone(QUndoStack *stack, const osg::Vec3f &tra
     }
 }
 
+void entity::UserScene::editCanvasSeparate(QUndoStack *stack, const osg::Vec3f &translate, dureu::EVENT event)
+{
+    if (!stack){
+        fatalMsg("editCanvasOffset(): undo stack is NULL, it is not initialized. "
+                 "Editing is not possible. "
+                 "Restart the program to ensure undo stack initialization.");
+        return;
+    }
+
+    switch (event){
+    case dureu::EVENT_OFF:
+        this->canvasSeparateFinish(stack);
+        break;
+    case dureu::EVENT_PRESSED:
+        this->canvasSeparateStart();
+        this->canvasSeparateAppend(translate);
+        break;
+    case dureu::EVENT_DRAGGED:
+        if (!this->canvasSeparateValid())
+            this->canvasSeparateStart();
+        this->canvasSeparateAppend(translate);
+        break;
+    case dureu::EVENT_RELEASED:
+        if (!this->canvasSeparateValid())
+            break;
+        this->canvasSeparateAppend(translate);
+        this->canvasSeparateFinish(stack);
+        break;
+    default:
+        break;
+    }
+}
+
 void entity::UserScene::editCanvasDelete(QUndoStack *stack, entity::Canvas *canvas)
 {
     outLogVal("Attempting to delete", canvas->getName());
@@ -1430,6 +1463,26 @@ bool entity::UserScene::canvasCloneValid() const
     return m_canvasClone.get();
 }
 
+void entity::UserScene::canvasSeparateStart()
+{
+
+}
+
+void entity::UserScene::canvasSeparateAppend(const osg::Vec3f &t)
+{
+
+}
+
+void entity::UserScene::canvasSeparateFinish(QUndoStack *stack)
+{
+
+}
+
+bool entity::UserScene::canvasSeparateValid() const
+{
+    return m_canvasClone.get();
+}
+
 void entity::UserScene::canvasRotateStart()
 {
     /* if the canvas is hidden, show it all so that user could see where they sketch */

src/libSGEntities/UserScene.h

@@ -89,6 +89,7 @@ class UserScene : public QObject, public osg::Group
     void editCanvasOffset(QUndoStack* stack, const osg::Vec3f& translate, dureu::EVENT event);
     void editCanvasRotate(QUndoStack* stack, const osg::Quat& rotation, const osg::Vec3f& center3d, dureu::EVENT event);
     void editCanvasClone(QUndoStack* stack, const osg::Vec3f& translate, dureu::EVENT event);
+    void editCanvasSeparate(QUndoStack* stack, const osg::Vec3f& translate, dureu::EVENT event);
     void editCanvasDelete(QUndoStack* stack, entity::Canvas* canvas);
 
     void editPhotoDelete(QUndoStack* stack, entity::Photo* photo, entity::Canvas* canvas);
@@ -164,6 +165,11 @@ public slots:
     void canvasCloneFinish(QUndoStack* stack);
     bool canvasCloneValid() const;
 
+    void canvasSeparateStart();
+    void canvasSeparateAppend(const osg::Vec3f& t);
+    void canvasSeparateFinish(QUndoStack* stack);
+    bool canvasSeparateValid() const;
+
     void canvasRotateStart();
     void canvasRotateAppend(const osg::Quat& r, const osg::Vec3f& center3d);
     void canvasRotateFinish(QUndoStack* stack);