diff --git a/GUI/coregui/CMakeLists.txt b/GUI/coregui/CMakeLists.txt
index 4dbc223dd345ad40afc727404e6d20fea9a4df1b..80bbab772c89f775d5b80039c168a5adc15882ea 100644
--- a/GUI/coregui/CMakeLists.txt
+++ b/GUI/coregui/CMakeLists.txt
@@ -33,6 +33,7 @@ set(include_dirs
${CMAKE_CURRENT_SOURCE_DIR}/Views/SimulationWidgets
${CMAKE_CURRENT_SOURCE_DIR}/Views/FitWidgets
${CMAKE_CURRENT_SOURCE_DIR}/Views/PropertyEditor
+ ${CMAKE_CURRENT_SOURCE_DIR}/Views/MaskWidgets
)
include_directories(${include_dirs})
@@ -50,6 +51,7 @@ file(GLOB source_files
"Views/SimulationWidgets/*.cpp"
"Views/FitWidgets/*.cpp"
"Views/PropertyEditor/*.cpp"
+ "Views/MaskWidgets/*.cpp"
)
set(source_widgetbox
@@ -74,6 +76,7 @@ file(GLOB include_files
"Views/SimulationWidgets/*.h"
"Views/FitWidgets/*.h"
"Views/PropertyEditor/*.h"
+ "Views/MaskWidgets/*.h"
)
set(include_widgetbox
diff --git a/GUI/coregui/Models/EllipseItem.cpp b/GUI/coregui/Models/EllipseItem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..52cf52762b21ffba305c9cec462be8545b9955f7
--- /dev/null
+++ b/GUI/coregui/Models/EllipseItem.cpp
@@ -0,0 +1,21 @@
+#include "EllipseItem.h"
+
+const QString EllipseItem::P_POSX = "X position";
+const QString EllipseItem::P_POSY = "Y position";
+const QString EllipseItem::P_WIDTH = "Width";
+const QString EllipseItem::P_HEIGHT = "Height";
+const QString EllipseItem::P_COLOR = "Color";
+const QString EllipseItem::P_ANGLE = "Angle";
+
+EllipseItem::EllipseItem(ParameterizedItem *parent)
+ : ParameterizedItem(Constants::EllipseType, parent)
+{
+ setItemName(Constants::EllipseType);
+ registerProperty(P_POSX, 0.0);
+ registerProperty(P_POSY, 0.0);
+ registerProperty(P_WIDTH, 0.0);
+ registerProperty(P_HEIGHT, 0.0);
+ registerProperty(P_COLOR, 0);
+ registerProperty(P_ANGLE, 0.0);
+}
+
diff --git a/GUI/coregui/Models/EllipseItem.h b/GUI/coregui/Models/EllipseItem.h
new file mode 100644
index 0000000000000000000000000000000000000000..652fe90daa761fa769367a6191e6bdfdd74e64e3
--- /dev/null
+++ b/GUI/coregui/Models/EllipseItem.h
@@ -0,0 +1,22 @@
+#ifndef ELLIPSEITEM_H
+#define ELLIPSEITEM_H
+
+#include "ParameterizedItem.h"
+
+class EllipseItem : public ParameterizedItem
+{
+ Q_OBJECT
+
+public:
+ static const QString P_POSX;
+ static const QString P_POSY;
+ static const QString P_WIDTH;
+ static const QString P_HEIGHT;
+ static const QString P_COLOR;
+ static const QString P_ANGLE;
+
+ explicit EllipseItem(ParameterizedItem *parent=0);
+ ~EllipseItem(){}
+};
+
+#endif
diff --git a/GUI/coregui/Models/ItemFactory.cpp b/GUI/coregui/Models/ItemFactory.cpp
index 0e1ea1ee77c21a6afdadac3f84288596e988d641..3ec97d55134c66b7b6a670d7a08fd4dc57d8e632 100644
--- a/GUI/coregui/Models/ItemFactory.cpp
+++ b/GUI/coregui/Models/ItemFactory.cpp
@@ -45,6 +45,10 @@
#include "BeamDistributionItem.h"
#include "BeamWavelengthItem.h"
#include "BeamAngleItems.h"
+#include "RectangleItem.h"
+#include "EllipseItem.h"
+#include "PolygonItem.h"
+#include "PointItem.h"
#include <QDebug>
namespace {
@@ -147,6 +151,11 @@ ItemFactory::ItemMap_t initializeItemMap() {
result[Constants::ResolutionFunctionNoneType] = &createInstance<ResolutionFunctionNoneItem>;
result[Constants::ResolutionFunction2DGaussianType] = &createInstance<ResolutionFunction2DGaussianItem>;
+ result[Constants::RectangleType] = &createInstance<RectangleItem>;
+ result[Constants::EllipseType] = &createInstance<EllipseItem>;
+ result[Constants::PolygonType] = &createInstance<PolygonItem>;
+ result[Constants::PointType] = &createInstance<PointItem>;
+
return result;
}
}
@@ -180,7 +189,7 @@ ParameterizedItem *ItemFactory::createItem(const QString &model_name,
if(parent) {
parent->insertChildItem(-1, result);
}
-
+ qDebug() << " result:" << result;
return result;
}
diff --git a/GUI/coregui/Models/MaskModel.cpp b/GUI/coregui/Models/MaskModel.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..981a428bbc86086b5399a970aab80fe1e738569c
--- /dev/null
+++ b/GUI/coregui/Models/MaskModel.cpp
@@ -0,0 +1,7 @@
+#include "MaskModel.h"
+
+MaskModel::MaskModel(QObject *parent)
+ : SessionModel(SessionXML::MaskModelTag, parent)
+{
+
+}
diff --git a/GUI/coregui/Models/MaskModel.h b/GUI/coregui/Models/MaskModel.h
new file mode 100644
index 0000000000000000000000000000000000000000..930cdb85f50777d16c255ccf0d244ad0b9259402
--- /dev/null
+++ b/GUI/coregui/Models/MaskModel.h
@@ -0,0 +1,16 @@
+#ifndef MASKMODEL_H
+#define MASKMODEL_H
+
+#include "SessionModel.h"
+
+class BA_CORE_API_ MaskModel : public SessionModel
+{
+ Q_OBJECT
+
+public:
+ explicit MaskModel(QObject *parent = 0);
+ ~MaskModel(){}
+
+};
+
+#endif
diff --git a/GUI/coregui/Models/PointItem.cpp b/GUI/coregui/Models/PointItem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d850484bd9664779b0165c9913252d678b8871b2
--- /dev/null
+++ b/GUI/coregui/Models/PointItem.cpp
@@ -0,0 +1,32 @@
+#include "PointItem.h"
+
+const QString PointItem::P_POSX = "X position";
+const QString PointItem::P_POSY = "Y positon";
+
+PointItem::PointItem(ParameterizedItem *parent)
+ : ParameterizedItem(Constants::PointType, parent)
+{
+ setItemName(Constants::PointType);
+ registerProperty(P_POSX, 0.0);
+ registerProperty(P_POSY, 0.0);
+}
+
+qreal PointItem::getXPos()
+{
+ return getRegisteredProperty(P_POSX).toReal();
+}
+
+qreal PointItem::getYPos()
+{
+ return getRegisteredProperty(P_POSY).toReal();
+}
+
+void PointItem::setXPos(qreal xPos)
+{
+ setRegisteredProperty(P_POSX, xPos);
+}
+
+void PointItem::setYPos(qreal yPos)
+{
+ setRegisteredProperty(P_POSY, yPos);
+}
diff --git a/GUI/coregui/Models/PointItem.h b/GUI/coregui/Models/PointItem.h
new file mode 100644
index 0000000000000000000000000000000000000000..43fa03134c6030cc5e6a01ba36d6e133eac4a529
--- /dev/null
+++ b/GUI/coregui/Models/PointItem.h
@@ -0,0 +1,25 @@
+#ifndef POINTITEM_H
+#define POINTITEM_H
+
+#include "ParameterizedItem.h"
+
+class PointItem : public ParameterizedItem
+{
+ Q_OBJECT
+
+public:
+ static const QString P_POSX;
+ static const QString P_POSY;
+
+ explicit PointItem(ParameterizedItem *parent = 0);
+ ~PointItem()
+ {
+ }
+
+ qreal getXPos();
+ qreal getYPos();
+ void setXPos(qreal xPos);
+ void setYPos(qreal yPos);
+};
+
+#endif
diff --git a/GUI/coregui/Models/PolygonItem.cpp b/GUI/coregui/Models/PolygonItem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b8b4aaa8ef114311b0b4e3928c0f869a0fa2b478
--- /dev/null
+++ b/GUI/coregui/Models/PolygonItem.cpp
@@ -0,0 +1,14 @@
+#include "PolygonItem.h"
+
+const QString PolygonItem::P_COLOR = "Color";
+const QString PolygonItem::P_DRAWINGMODE = "Drawing Mode";
+
+PolygonItem::PolygonItem(ParameterizedItem *parent)
+ : ParameterizedItem(Constants::PolygonType, parent)
+{
+ setItemName(Constants::PolygonType);
+ registerProperty(P_COLOR, 0);
+ registerProperty(P_DRAWINGMODE, false);
+
+ addToValidChildren(Constants::PointType);
+}
diff --git a/GUI/coregui/Models/PolygonItem.h b/GUI/coregui/Models/PolygonItem.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bdb4216321481cd5d3562758556bc302cb62d86
--- /dev/null
+++ b/GUI/coregui/Models/PolygonItem.h
@@ -0,0 +1,18 @@
+#ifndef POLYGONITEM_H
+#define POLYGONITEM_H
+
+#include "ParameterizedItem.h"
+
+class PolygonItem : public ParameterizedItem
+{
+ Q_OBJECT
+
+public:
+ static const QString P_COLOR;
+ static const QString P_DRAWINGMODE;
+
+ explicit PolygonItem(ParameterizedItem *parent=0);
+ ~PolygonItem(){}
+};
+
+#endif
diff --git a/GUI/coregui/Models/RectangleItem.cpp b/GUI/coregui/Models/RectangleItem.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6a5d9706336b69bbfc6ea5a7fe99c9ddd1d59bc3
--- /dev/null
+++ b/GUI/coregui/Models/RectangleItem.cpp
@@ -0,0 +1,20 @@
+#include "RectangleItem.h"
+
+const QString RectangleItem::P_POSX = "X position";
+const QString RectangleItem::P_POSY = "Y position";
+const QString RectangleItem::P_WIDTH = "Width";
+const QString RectangleItem::P_HEIGHT = "Height";
+const QString RectangleItem::P_COLOR = "Color";
+const QString RectangleItem::P_ANGLE = "Angle";
+
+RectangleItem::RectangleItem(ParameterizedItem *parent)
+ : ParameterizedItem(Constants::RectangleType, parent)
+{
+ setItemName(Constants::RectangleType);
+ registerProperty(P_POSX, 0.0);
+ registerProperty(P_POSY, 0.0);
+ registerProperty(P_WIDTH, 0.0);
+ registerProperty(P_HEIGHT, 0.0);
+ registerProperty(P_COLOR, 0);
+ registerProperty(P_ANGLE, 0.0);
+}
diff --git a/GUI/coregui/Models/RectangleItem.h b/GUI/coregui/Models/RectangleItem.h
new file mode 100644
index 0000000000000000000000000000000000000000..55bea55c6a71de07740eed1df3c91d96d5801568
--- /dev/null
+++ b/GUI/coregui/Models/RectangleItem.h
@@ -0,0 +1,22 @@
+#ifndef RECTANGLEITEM_H
+#define RECTANGLEITEM_H
+
+#include "ParameterizedItem.h"
+
+class RectangleItem : public ParameterizedItem
+{
+ Q_OBJECT
+
+public:
+ static const QString P_POSX;
+ static const QString P_POSY;
+ static const QString P_WIDTH;
+ static const QString P_HEIGHT;
+ static const QString P_COLOR;
+ static const QString P_ANGLE;
+
+ explicit RectangleItem(ParameterizedItem *parent=0);
+ ~RectangleItem(){}
+};
+
+#endif
diff --git a/GUI/coregui/Models/SessionModel.h b/GUI/coregui/Models/SessionModel.h
index 6d093a6534e3170631b511b2ad9c70092617e619..20b9386f301ade721fc2589f047f8a1e7f7ad615 100644
--- a/GUI/coregui/Models/SessionModel.h
+++ b/GUI/coregui/Models/SessionModel.h
@@ -31,6 +31,7 @@ const QString SampleModelTag("SampleModel");
const QString MaterialModelTag("MaterialModel");
const QString FitModelTag("FitModel");
const QString JobModelTag("JobModel");
+const QString MaskModelTag("MaskModel");
const QString ModelNameAttribute("Name");
const QString ItemTag("Item");
diff --git a/GUI/coregui/Models/item_constants.h b/GUI/coregui/Models/item_constants.h
index 11b01f4d51f7d823ca5743c52db0b692d97f1b37..03320f99eebbe4a60f49e58fa687b8da8bfc864a 100644
--- a/GUI/coregui/Models/item_constants.h
+++ b/GUI/coregui/Models/item_constants.h
@@ -120,6 +120,11 @@ const ModelType BeamInclinationAngleType = "BeamInclinationAngle";
const ModelType ResolutionFunctionNoneType = "ResolutionFunctionNone";
const ModelType ResolutionFunction2DGaussianType = "ResolutionFunction2DGaussian";
+const ModelType RectangleType = "Rectangle";
+const ModelType EllipseType = "Ellipse";
+const ModelType PolygonType = "Polygon";
+const ModelType PointType = "Point";
+
// --- Groups ------------------------------------------------------------------
const ModelType FormFactorGroup = "Form Factor";
diff --git a/GUI/coregui/Views/InfoWidgets/DistributionEditor.cpp b/GUI/coregui/Views/InfoWidgets/DistributionEditor.cpp
index bd82187f45d09c01a136a1edd06b88971f8e69d5..e8aabe8c014abc78983f98efbcf0af3e42b8075d 100644
--- a/GUI/coregui/Views/InfoWidgets/DistributionEditor.cpp
+++ b/GUI/coregui/Views/InfoWidgets/DistributionEditor.cpp
@@ -95,3 +95,4 @@ void DistributionEditor::setNameOfEditor(QString name)
m_box->setTitle(name);
m_plotwidget->setXAxisName(name);
}
+
diff --git a/GUI/coregui/Views/InfoWidgets/DistributionEditor.h b/GUI/coregui/Views/InfoWidgets/DistributionEditor.h
index 54d113bd40748024609600335fdd430bf2c93860..e7aeffa6e0d49c47f3afb348822c2ed10bfc2c29 100644
--- a/GUI/coregui/Views/InfoWidgets/DistributionEditor.h
+++ b/GUI/coregui/Views/InfoWidgets/DistributionEditor.h
@@ -17,6 +17,7 @@
#define DISTRIBUTIONEDITOR_H
#include <QWidget>
+#include "qcustomplot.h"
class QGroupBox;
class DistributionWidget;
diff --git a/GUI/coregui/Views/InfoWidgets/DistributionWidget.cpp b/GUI/coregui/Views/InfoWidgets/DistributionWidget.cpp
index 034b6f6e6493ee37cf18171ef65b8587e48cb5a5..c222cb0373f14d49975f1fb0a27eceabd0d06575 100644
--- a/GUI/coregui/Views/InfoWidgets/DistributionWidget.cpp
+++ b/GUI/coregui/Views/InfoWidgets/DistributionWidget.cpp
@@ -61,6 +61,8 @@ DistributionWidget::DistributionWidget(QWidget *parent)
setStyleSheet("background-color:white;");
connect(m_plot, SIGNAL(mousePress(QMouseEvent *)), this, SLOT(onMousePress(QMouseEvent *)));
+ connect(m_plot, SIGNAL(mouseRelease(QMouseEvent*)), this, SLOT(onMouseRelease(QMouseEvent*)));
+ connect(m_plot, SIGNAL(mouseRelease(QMouseEvent*)), this, SLOT(onMouseRelease(QMouseEvent*)));
}
void DistributionWidget::setItem(DistributionItem *item)
@@ -253,6 +255,7 @@ void DistributionWidget::onMousePress(QMouseEvent *event)
menu.exec(point);
}
}
+
void DistributionWidget::resetView()
{
m_plot->xAxis->setRange(*m_xRange);
@@ -283,3 +286,4 @@ void DistributionWidget::resizeEvent(QResizeEvent *event)
m_warningSign->setPosition(pos.x(), pos.y());
}
}
+
diff --git a/GUI/coregui/Views/InfoWidgets/DistributionWidget.h b/GUI/coregui/Views/InfoWidgets/DistributionWidget.h
index e40e364e57c2745cd0f623e77668393fb3edb4f8..80ff1f54b72b18cbaefe5bc85a42012c0d5f8c12 100644
--- a/GUI/coregui/Views/InfoWidgets/DistributionWidget.h
+++ b/GUI/coregui/Views/InfoWidgets/DistributionWidget.h
@@ -18,6 +18,7 @@
#include <QWidget>
#include "WarningSignWidget.h"
+#include "qcustomplot.h"
class ParameterizedItem;
class AwesomePropertyEditor;
@@ -34,7 +35,9 @@ class DistributionWidget : public QWidget
public:
DistributionWidget(QWidget *parent = 0);
- virtual ~DistributionWidget() {}
+ virtual ~DistributionWidget()
+ {
+ }
void setItem(DistributionItem *item);
void plotItem();
double getWidthOfBars(double min, double max, int samples);
@@ -42,7 +45,6 @@ public:
int getMaxYPosition(int y);
void setXAxisName(QString xAxisName);
QPoint getPositionForWarningSign();
- QString generateCodeSnippet();
public slots:
void onMouseMove(QMouseEvent *event);
@@ -51,7 +53,7 @@ public slots:
protected:
void resizeEvent(QResizeEvent *event);
private slots:
- void onPropertyChanged();
+ void onPropertyChanged();
void resetView();
private:
diff --git a/GUI/coregui/Views/MaskToolBar.cpp b/GUI/coregui/Views/MaskToolBar.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..43dea403ceeb404500d25133c407d3621d8f0338
--- /dev/null
+++ b/GUI/coregui/Views/MaskToolBar.cpp
@@ -0,0 +1,157 @@
+#include "MaskToolBar.h"
+#include <QToolBar>
+#include <QToolButton>
+#include <QVBoxLayout>
+#include <QFrame>
+#include <QSplitter>
+#include <QListView>
+#include <QButtonGroup>
+#include <QDebug>
+
+
+
+MaskToolBar::MaskToolBar(QWidget *parent)
+{
+ this->setParent(parent);
+ this->setIconSize(QSize(25,25));
+
+
+ // selection mode
+ m_selectionButton = new QToolButton(this);
+ m_selectionButton->setIcon(QIcon(":/images/mouseCursor.png"));
+ m_selectionButton->setCheckable(true);
+ m_selectionButton->setToolTip(QString("Selection Mode"));
+ connect(m_selectionButton, SIGNAL(pressed()), this, SLOT(onChangeToSelectionMode()));
+
+ // pan mode
+ m_panButton = new QToolButton(this);
+ m_panButton->setIcon(QIcon(":/SampleDesigner/images/toolbar_hand.png"));
+ m_panButton->setCheckable(true);
+ m_panButton->setToolTip(QString("Pan Mode"));
+ connect(m_panButton, SIGNAL(toggled(bool)), this, SLOT(onPanMode(bool)));
+
+ // rectangle
+ m_rectangleButton = new QToolButton(this);
+ m_rectangleButton->setIcon(QIcon(":/images/rectangle.png"));
+ m_rectangleButton->setCheckable(true);
+ m_rectangleButton->setToolTip(QString("Create rectangles and squares"));
+ connect(m_rectangleButton, SIGNAL(pressed()), this, SLOT(onRectangleButtonPressed()));
+
+ // ellipse
+ m_ellipseButton = new QToolButton(this);
+ m_ellipseButton->setCheckable(true);
+ m_ellipseButton->setToolTip(QString("Create ellipses and circles"));
+ m_ellipseButton->setIcon(QIcon(":/images/ellipse.png"));
+ connect(m_ellipseButton, SIGNAL(pressed()), this, SLOT(onEllipseButtonPressed()));
+
+ // polygon
+
+ m_polygonButton = new QToolButton(this);
+ m_polygonButton->setCheckable(true);
+ m_polygonButton->setToolTip(QString("Create Polygons"));
+ m_polygonButton->setIcon(QIcon(":/images/polygon.png"));
+ connect(m_polygonButton, SIGNAL(pressed()), this, SLOT(onPolygonButtonPressed()));
+
+ // bring to front
+ m_bringToFrontButton = new QToolButton(this);
+ m_bringToFrontButton->setToolTip(QString("Bring selected item to the front"));
+ m_bringToFrontButton->setIcon(QIcon(":/images/bringToFront.png"));
+ connect(m_bringToFrontButton, SIGNAL(clicked()), this, SLOT(onBringToFrontClicked()));
+
+ // send to back
+ m_sendToBackButton = new QToolButton(this);
+ m_sendToBackButton->setToolTip(QString("Send selected item to the back"));
+ m_sendToBackButton->setIcon(QIcon(":/images/sendToBack.png"));
+ connect(m_sendToBackButton, SIGNAL(clicked()), this, SLOT(onSendToBackClicked()));
+
+ // include
+ m_includeButton = new QToolButton(this);
+ m_includeButton->setCheckable(true);
+ m_includeButton->setToolTip(QString("Including area"));
+ m_includeButton->setIcon(QIcon(":/images/include.png"));
+ connect(m_includeButton, SIGNAL(clicked()), this, SLOT(onIncludeClicked()));
+
+ // exclude
+ m_excludeButton = new QToolButton(this);
+ m_excludeButton->setCheckable(true);
+ m_excludeButton->setToolTip(QString("Excluding area"));
+ m_excludeButton->setIcon(QIcon(":/images/exclude.png"));
+ connect(m_excludeButton, SIGNAL(clicked()), this, SLOT(onExcludeClicked()));
+
+ QButtonGroup *drawingGroup = new QButtonGroup(this);
+ drawingGroup->addButton(m_rectangleButton);
+ drawingGroup->addButton(m_ellipseButton);
+ drawingGroup->addButton(m_polygonButton);
+ drawingGroup->addButton(m_panButton);
+ drawingGroup->addButton(m_selectionButton);
+
+ QButtonGroup *ColorGroup = new QButtonGroup(this);
+ ColorGroup->addButton(m_includeButton);
+ ColorGroup->addButton(m_excludeButton);
+
+
+ this->addWidget(m_selectionButton);
+ this->addWidget(m_panButton);
+ this->addSeparator();
+ this->addWidget(m_rectangleButton);
+ this->addWidget(m_ellipseButton);
+ this->addWidget(m_polygonButton);
+ this->addSeparator();
+ this->addWidget(m_includeButton);
+ this->addWidget(m_excludeButton);
+ this->addSeparator();
+ this->addWidget(m_bringToFrontButton);
+ this->addWidget(m_sendToBackButton);
+
+
+}
+
+void MaskToolBar::onChangeToSelectionMode()
+{
+ emit changeToSelectionMode();
+}
+
+void MaskToolBar::selectSelectionMode()
+{
+ m_selectionButton->click();
+}
+
+void MaskToolBar::onPanMode(bool isActive)
+{
+ emit panMode(isActive);
+}
+
+void MaskToolBar::onRectangleButtonPressed()
+{
+ emit rectangleButtonPressed();
+}
+
+void MaskToolBar::onEllipseButtonPressed()
+{
+ emit ellipseButtonPressed();
+}
+
+void MaskToolBar::onPolygonButtonPressed()
+{
+ emit polygonButtonPressed();
+}
+
+void MaskToolBar::onBringToFrontClicked()
+{
+ emit bringToFrontClicked();
+}
+
+void MaskToolBar::onSendToBackClicked()
+{
+ emit sendToBackClicked();
+}
+
+void MaskToolBar::onIncludeClicked()
+{
+ emit includeClicked();
+}
+
+void MaskToolBar::onExcludeClicked()
+{
+ emit excludeClicked();
+}
diff --git a/GUI/coregui/Views/MaskToolBar.h b/GUI/coregui/Views/MaskToolBar.h
new file mode 100644
index 0000000000000000000000000000000000000000..2d2029fac8b4bd4edb2ebd841c6db8a944f6e4c4
--- /dev/null
+++ b/GUI/coregui/Views/MaskToolBar.h
@@ -0,0 +1,88 @@
+#ifndef MASKTOOLBAR_H
+#define MASKTOOLBAR_H
+
+#include <QToolBar>
+class QToolButton;
+
+class MaskToolBar : public QToolBar
+{
+ Q_OBJECT
+public:
+ MaskToolBar(QWidget *parent = 0);
+ virtual ~MaskToolBar()
+ {
+ }
+
+signals:
+ //! signal is emitted when rectangle button pressed
+ void rectangleButtonPressed();
+
+ //! signal is emitted when ellipse button pressed
+ void ellipseButtonPressed();
+
+ //! signal is emitted when polygon button pressed
+ void polygonButtonPressed();
+
+ //! signal is emitted when selection button pressed
+ void changeToSelectionMode();
+
+ //! signal is emitted when pan button pressed
+ void panMode(bool);
+
+ //! signal is emitted when bring to front button pressed
+ void bringToFrontClicked();
+
+ //! signal is emitted when send to back button pressed
+ void sendToBackClicked();
+
+ //! signal is emitted when include button pressed
+ void includeClicked();
+
+ //! signal is emitted when exclude button pressed
+ void excludeClicked();
+
+private slots:
+ //! emits signal when rectangle button pressed
+ void onRectangleButtonPressed();
+
+ //! emits signal when selection button pressed
+ void onChangeToSelectionMode();
+
+ //! from scene if item is drawn
+ //! This works if emit isDrawn is uncommented in MaskGraphicsScene
+ void selectSelectionMode();
+
+ //! emits signal when pan button pressed
+ void onPanMode(bool isActive);
+
+ //! emits signal when ellipse button pressed
+ void onEllipseButtonPressed();
+
+ //! emits signal when polygon button pressed
+ void onPolygonButtonPressed();
+
+ //! emits signal when bring to front button pressed
+ void onBringToFrontClicked();
+
+ //! emits signal when send to back button pressed
+ void onSendToBackClicked();
+
+ //! emits signal when include button pressed
+ void onIncludeClicked();
+
+ //! emits signal when exclude button pressed
+ void onExcludeClicked();
+
+private:
+ QToolButton *m_selectionButton; //!< selection button
+ QToolButton *m_panButton; //!<pan button
+ QToolButton *m_rectangleButton; //!< rectangle button
+ QToolButton *m_ellipseButton; //!< ellipse button
+ QToolButton *m_polygonButton; //!< polygon button
+ QToolButton *m_bringToFrontButton; //!< bring to front button
+ QToolButton *m_sendToBackButton; //!< send to back button
+ QToolButton *m_includeButton; //!< include button
+ QToolButton *m_excludeButton; //!< exclude button
+};
+
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/EllipseView.cpp b/GUI/coregui/Views/MaskWidgets/EllipseView.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..087d42e0819e2b3bed2f09c8bd944b473352cc5b
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/EllipseView.cpp
@@ -0,0 +1,394 @@
+#include "EllipseView.h"
+#include "EllipseItem.h"
+#include "ParameterizedItem.h"
+#include "RotationArrow.h"
+#include "ResizeArrow.h"
+#include <cmath>
+#include <QPainter>
+#include <QGraphicsSceneMouseEvent>
+#include <QCursor>
+#include <QDebug>
+
+static const qreal widthAndHeight = 5;
+static const qreal OffsetPosition = 2.5;
+
+EllipseView::EllipseView() : m_diagonalOpposedPoint(new QPointF)
+{
+ setFlag(QGraphicsItem::ItemIsSelectable);
+ setFlag(QGraphicsItem::ItemIsMovable);
+ setAcceptHoverEvents(true);
+ connect(this, SIGNAL(xChanged()), this, SLOT(onChangedX()));
+ connect(this, SIGNAL(yChanged()), this, SLOT(onChangedY()));
+}
+
+void EllipseView::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+{
+
+ // paint ellipse
+ painter->setRenderHints(QPainter::Antialiasing);
+ this->prepareGeometryChange();
+
+ QBrush brush;
+ brush.setStyle(Qt::SolidPattern);
+ if (m_item->getRegisteredProperty(EllipseItem::P_COLOR).toBool() == 0) {
+ brush.setColor(DesignerHelper::getDefaultColor("Transparant red"));
+ painter->setPen(brush.color().darker());
+ painter->setBrush(brush);
+ painter->drawEllipse(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal(),
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal(),
+ m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal(),
+ m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal());
+ } else {
+ brush.setColor(DesignerHelper::getDefaultColor("Transparant blue"));
+ painter->setPen(brush.color().darker());
+ painter->setBrush(brush);
+ painter->drawEllipse(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal(),
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal(),
+ m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal(),
+ m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal());
+ }
+
+ // paint rectangles on corners if this item is selected
+ if (this->isSelected()) {
+ painter->setBrush(painter->pen().color());
+ painter->drawRect(getTopLeftCorner());
+ painter->drawRect(getBottomLeftCorner());
+ painter->drawRect(getTopRightCorner());
+ painter->drawRect(getBottomRightCorner());
+ }
+ updateArrows();
+}
+
+QRectF EllipseView::boundingRect() const
+{
+ return QRectF(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal() - 5,
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal() - 5,
+ m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() + 10,
+ m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() + 10);
+}
+
+void EllipseView::setDiagonalOpposedPoint()
+{
+ if (m_corner == TOPLEFT) {
+ m_diagonalOpposedPoint->setX(getBottomRightCorner().x());
+ m_diagonalOpposedPoint->setY(getBottomRightCorner().x());
+ } else if (m_corner == TOPRIGHT) {
+ m_diagonalOpposedPoint->setX(getBottomLeftCorner().x());
+ m_diagonalOpposedPoint->setY(getBottomLeftCorner().y());
+ } else if (m_corner == BOTTOMLEFT) {
+ m_diagonalOpposedPoint->setX(getTopRightCorner().x());
+ m_diagonalOpposedPoint->setY(getTopRightCorner().y());
+ } else if (m_corner == BOTTOMRIGHT) {
+ m_diagonalOpposedPoint->setX(getTopLeftCorner().x());
+ m_diagonalOpposedPoint->setY(getTopLeftCorner().y());
+ }
+}
+
+void EllipseView::calculateResize(QGraphicsSceneMouseEvent *event)
+{
+ qreal xmin = std::min(event->pos().x(),m_diagonalOpposedPoint->x());
+ qreal xmax = std::max(event->pos().x(),m_diagonalOpposedPoint->x());
+ qreal ymin = std::min(event->pos().y(),m_diagonalOpposedPoint->y());
+ qreal ymax = std::max(event->pos().y(),m_diagonalOpposedPoint->y());
+
+ m_item->setRegisteredProperty(EllipseItem::P_WIDTH, xmax - xmin);
+ m_item->setRegisteredProperty(EllipseItem::P_HEIGHT, ymax - ymin);
+
+ m_item->setRegisteredProperty(EllipseItem::P_POSX, xmin);
+ m_item->setRegisteredProperty(EllipseItem::P_POSY, ymin);
+}
+
+qreal EllipseView::getRotationAngle(QGraphicsSceneMouseEvent *event)
+{
+ QPointF middlePoint
+ = mapToScene(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() / 2,
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() / 2);
+ qreal lengthOfHypotenuse
+ = sqrt(pow(m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() / 2, 2)
+ + pow(m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() / 2, 2));
+ qreal offsetAngle = acos((m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() / 2)
+ / lengthOfHypotenuse) * 180 / M_PI;
+ qreal radians = atan((event->scenePos().y() - middlePoint.y())
+ / (event->scenePos().x() - middlePoint.x()));
+
+ if (m_corner == TOPLEFT) {
+ m_item->setRegisteredProperty(EllipseItem::P_ANGLE, radians * 180 / M_PI - offsetAngle);
+ return radians * 180 / M_PI - offsetAngle;
+
+ } else if (m_corner == TOPRIGHT) {
+ m_item->setRegisteredProperty(EllipseItem::P_ANGLE, radians * 180 / M_PI + offsetAngle - 180);
+ return radians * 180 / M_PI + offsetAngle - 180;
+
+ } else if (m_corner == BOTTOMLEFT) {
+ m_item->setRegisteredProperty(EllipseItem::P_ANGLE, radians * 180 / M_PI + offsetAngle - 180);
+ return radians * 180 / M_PI + offsetAngle - 180;
+
+ } else if (m_corner == BOTTOMRIGHT) {
+ m_item->setRegisteredProperty(EllipseItem::P_ANGLE, radians * 180 / M_PI - offsetAngle);
+ return radians * 180 / M_PI - offsetAngle;
+ }
+ return 0.0;
+}
+
+void EllipseView::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+
+ if (event->button() == Qt::LeftButton) {
+ setSelectedCorner(event->pos());
+
+ if (m_corner == NONE) {
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ QGraphicsItem::mousePressEvent(event);
+ }
+ else {
+ setDiagonalOpposedPoint();
+ }
+ }
+}
+
+void EllipseView::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+ if(m_corner == NONE) {
+ m_block_mode = true;
+ }
+
+ // check which mode is active and process with the active mode
+ if (m_mode == RESIZE && m_corner != NONE) {
+ calculateResize(event);
+ } else if (m_corner != NONE && m_mode == ROTATION) {
+ QTransform transform;
+ transform.translate(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() * 0.5,
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() * 0.5);
+ transform.rotate(getRotationAngle(event));
+ transform.translate(-(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() * 0.5),
+ -(m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() * 0.5));
+ setTransform(transform);
+// process as usual
+ } else {
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ QGraphicsItem::mouseMoveEvent(event);
+ }
+}
+
+void EllipseView::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+ if(!m_block_mode) {
+ if ((m_mode == RESIZE)) {
+ m_mode = ROTATION;
+ } else if ((m_mode == ROTATION)) {
+ m_mode = RESIZE;
+ }
+ }
+ m_block_mode = false;
+ m_corner = NONE;
+ setCursor(Qt::ArrowCursor);
+ QGraphicsItem::mouseReleaseEvent(event);
+}
+
+void EllipseView::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
+ setSelectedCorner(event->pos());
+ m_corner = NONE;
+}
+
+void EllipseView::setInclude()
+{
+ m_item->setRegisteredProperty(EllipseItem::P_COLOR, 0);
+}
+
+void EllipseView::setExclude()
+{
+ m_item->setRegisteredProperty(EllipseItem::P_COLOR, 1);
+}
+
+QRectF EllipseView::getTopLeftCorner()
+{
+ return QRectF(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal() - OffsetPosition,
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal() - OffsetPosition,
+ widthAndHeight, widthAndHeight);
+}
+
+QRectF EllipseView::getTopRightCorner()
+{
+ return QRectF(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() - OffsetPosition,
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal() - OffsetPosition,
+ widthAndHeight, widthAndHeight);
+}
+
+QRectF EllipseView::getBottomLeftCorner()
+{
+ return QRectF(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal() - OffsetPosition,
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() - OffsetPosition,
+ widthAndHeight, widthAndHeight);
+}
+
+QRectF EllipseView::getBottomRightCorner()
+{
+ return QRectF(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() - OffsetPosition,
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() - OffsetPosition,
+ widthAndHeight, widthAndHeight);
+}
+
+void EllipseView::setParameterizedItem(ParameterizedItem *item)
+{
+ m_item = item;
+ setRotation(m_item->getRegisteredProperty(EllipseItem::P_ANGLE).toReal());
+ connect(m_item, SIGNAL(propertyChanged(const QString &)), this,
+ SLOT(onPropertyChange(const QString &)));
+ initializeArrows();
+}
+
+void EllipseView::onChangedX()
+{
+ m_block_mode = true;
+}
+
+void EllipseView::onChangedY()
+{
+ m_block_mode = true;
+}
+
+void EllipseView::onPropertyChange(const QString &propertyName)
+{
+ if(propertyName == EllipseItem::P_POSX) {
+ m_block_mode = true;
+ }
+ else if(propertyName == EllipseItem::P_POSY) {
+ m_block_mode = true;
+ }
+ else if(propertyName == EllipseItem::P_ANGLE) {
+ QTransform transform;
+ transform.translate(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() * 0.5,
+ m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() * 0.5);
+ transform.rotate(m_item->getRegisteredProperty(EllipseItem::P_ANGLE).toReal());
+ transform.translate(-(m_item->getRegisteredProperty(EllipseItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_WIDTH).toReal() * 0.5),
+ -(m_item->getRegisteredProperty(EllipseItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal() * 0.5));
+ setTransform(transform);
+ }
+
+}
+
+ParameterizedItem *EllipseView::getParameterizedItem()
+{
+ return m_item;
+}
+
+void EllipseView::setSelectedCorner(QPointF currentMousePosition)
+{
+ if (getTopLeftCorner().contains(currentMousePosition)) {
+ qDebug() << "TOPLEFT";
+ m_corner = TOPLEFT;
+ if(m_mode == RESIZE)
+ setCursor(Qt::SizeFDiagCursor);
+ } else if (getTopRightCorner().contains(currentMousePosition)) {
+ qDebug() << "TOPRIGHT";
+ m_corner = TOPRIGHT;
+ if(m_mode == RESIZE)
+ setCursor(Qt::SizeBDiagCursor);
+ } else if (getBottomLeftCorner().contains(currentMousePosition)) {
+ qDebug() << "BOTTOMLEFT";
+ m_corner = BOTTOMLEFT;
+ if(m_mode == RESIZE)
+ setCursor(Qt::SizeBDiagCursor);
+ } else if (getBottomRightCorner().contains(currentMousePosition)) {
+ qDebug() << "BOTTOMRIGHT";
+ m_corner = BOTTOMRIGHT;
+ if(m_mode == RESIZE)
+ setCursor(Qt::SizeFDiagCursor);
+ } else {
+ m_corner = NONE;
+ setCursor(QCursor());
+ }
+
+ if (m_mode == ROTATION && m_corner != NONE) {
+ setCursor(QCursor(QPixmap(":/images/rotationArrow.png")));
+ }
+}
+
+void EllipseView::updateArrows()
+{
+ // 0 - 3 are rotation arrows
+ childItems()[0]->setPos(getTopLeftCorner().x(), getTopLeftCorner().y());
+ childItems()[1]->setPos(getTopRightCorner().x(), getTopRightCorner().y());
+ childItems()[2]->setPos(getBottomLeftCorner().x(), getBottomLeftCorner().y());
+ childItems()[3]->setPos(getBottomRightCorner().x(), getBottomRightCorner().y());
+
+ // 4 - 7 are resize arrows
+ childItems()[4]->setPos(getTopLeftCorner().x(), getTopLeftCorner().y());
+ childItems()[5]->setPos(getTopRightCorner().x(), getTopRightCorner().y());
+ childItems()[6]->setPos(getBottomLeftCorner().x(), getBottomLeftCorner().y());
+ childItems()[7]->setPos(getBottomRightCorner().x(), getBottomRightCorner().y());
+
+
+ if(isSelected() == false) {
+ for(int i = 0; i < childItems().length(); ++i) {
+ childItems()[i]->setVisible(false);
+ }
+
+ }
+ else if(m_mode == RESIZE) {
+ for(int i = 0; i < childItems().length(); ++i) {
+ if(i < 4) {
+ childItems()[i]->setVisible(false);
+ }
+ else {
+ childItems()[i]->setVisible(true);
+ }
+ }
+ } else if(m_mode == ROTATION) {
+ for(int i = 0; i < childItems().length(); ++i) {
+ if(i < 4) {
+ childItems()[i]->setVisible(true);
+ }
+ else {
+ childItems()[i]->setVisible(false);
+ }
+ }
+ }
+}
+
+void EllipseView::initializeArrows()
+{
+ RotationArrow *topLeftRotationArrow = new RotationArrow(this);
+ RotationArrow *topRightRotationArrow = new RotationArrow(this);
+ RotationArrow *bottomLeftRotationArrow = new RotationArrow(this);
+ RotationArrow *bottomRightRotationArrow = new RotationArrow(this);
+
+ ResizeArrow *topLeftResizeArrow = new ResizeArrow(this);
+ ResizeArrow *topRightResizeArrow = new ResizeArrow(this);
+ ResizeArrow *bottomLeftResizeArrow = new ResizeArrow(this);
+ ResizeArrow *bottomRightResizeArrow = new ResizeArrow(this);
+
+ topRightRotationArrow->setRotation(90);
+ bottomLeftRotationArrow->setRotation(270);
+ bottomRightRotationArrow->setRotation(180);
+
+ topRightResizeArrow->setRotation(90);
+ bottomLeftResizeArrow->setRotation(270);
+ bottomRightResizeArrow->setRotation(180);
+
+ topRightRotationArrow->setVisible(false);
+ topLeftRotationArrow->setVisible(false);
+ bottomLeftRotationArrow->setVisible(false);
+ bottomRightRotationArrow->setVisible(false);
+
+ topRightResizeArrow->setVisible(false);
+ topLeftResizeArrow->setVisible(false);
+ bottomLeftResizeArrow->setVisible(false);
+ bottomRightResizeArrow->setVisible(false);
+}
diff --git a/GUI/coregui/Views/MaskWidgets/EllipseView.h b/GUI/coregui/Views/MaskWidgets/EllipseView.h
new file mode 100644
index 0000000000000000000000000000000000000000..4c1cdf970e784baa98f548f172d027767f53a3c1
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/EllipseView.h
@@ -0,0 +1,126 @@
+#ifndef ELLIPSEVIEW_H
+#define ELLIPSEVIEW_H
+
+#include "IView.h"
+
+class EllipseItem;
+class QGraphicsSceneMouseEvent;
+class QPainter;
+class QPointF;
+
+class EllipseView : public IView
+{
+ Q_OBJECT
+
+public:
+ EllipseView();
+
+ //! describes the corners
+ enum Corner { NONE, TOPLEFT, TOPRIGHT, BOTTOMLEFT, BOTTOMRIGHT };
+
+ //! current active mode
+ enum Mode { ROTATION, RESIZE };
+
+ //! Type of this item
+ enum { Type = UserType + 2 };
+
+ //! boundingbox of this item
+ QRectF boundingRect() const;
+
+ //! returns the type of this item
+ //! @return number of type
+ int type() const
+ {
+ return Type;
+ }
+
+ //! ellipse including an area and it's color is changing to red
+ void setInclude();
+
+ //! ellipse is excluding an area and it's color is changing to blue
+ void setExclude();
+
+ //! get current ellipse item
+ //! @return ellipse item as parameterized item
+ void setParameterizedItem(ParameterizedItem *item);
+
+ //! get current ellipse item
+ //! @return ellipse item as parameterized item
+ ParameterizedItem *getParameterizedItem();
+
+public slots:
+ //! called when x-value changed
+ void onChangedX();
+
+ //! called when x-value changed
+ void onChangedY();
+
+ //! called when property of ellipse changed
+ void onPropertyChange(const QString &propertyName);
+
+protected:
+ //! paintEvent paints ellipse and corners
+ void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *);
+
+ //! manages mouse press events
+ //! @param event from scene
+ void mousePressEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages mouse move events
+ //! @param event from scene
+ void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages hover events
+ //! @param event from scene
+ void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages hover events
+ //! @param event from scene
+ void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
+
+private:
+ ParameterizedItem *m_item; //!< ellipse item
+ Corner m_corner; //!< enum with all corners
+ Mode m_mode; //!< current active mode
+ bool m_block_mode; //!< blocking modes
+ QPointF *m_diagonalOpposedPoint; //!< diagonally opposite point from current selected corner
+
+ //! calculates angle for rotation
+ //! @return angle between selected corner and mouse
+ //! @param event to receive current mouse position
+ qreal getRotationAngle(QGraphicsSceneMouseEvent *event);
+
+ //! calculates resized ellipse
+ //! @param event to receive current mouse position
+ void calculateResize(QGraphicsSceneMouseEvent *event);
+
+ //! updates all arrows;
+ void updateArrows();
+
+ //! initialize all arrows
+ void initializeArrows();
+
+ //! verfies clicked corner
+ //! @param current mouse position
+ void setSelectedCorner(QPointF currentMousePosition);
+
+ //! set diagonally opposite point from current selected corner
+ void setDiagonalOpposedPoint();
+
+ //! returns corner of rectangle
+ //! @return top left corner
+ QRectF getTopLeftCorner();
+
+ //! returns corner of rectangle
+ //! @return top left corner
+ QRectF getTopRightCorner();
+
+ //! returns corner of rectangle
+ //! @return top left corner
+ QRectF getBottomLeftCorner();
+
+ //! returns corner of rectangle
+ //! @return top left corner
+ QRectF getBottomRightCorner();
+};
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/GraphicsProxyWidget.cpp b/GUI/coregui/Views/MaskWidgets/GraphicsProxyWidget.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a48711e6ab3b56c7c9a1d03058bd71a338401a57
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/GraphicsProxyWidget.cpp
@@ -0,0 +1,20 @@
+#include "GraphicsProxyWidget.h"
+
+
+
+void GraphicsProxyWidget::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+ QGraphicsProxyWidget::mousePressEvent(event);
+ event->accept();
+}
+
+void GraphicsProxyWidget::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+ QGraphicsProxyWidget::mouseReleaseEvent(event);
+}
+
+
+void GraphicsProxyWidget::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+ QGraphicsProxyWidget::mouseMoveEvent(event);
+}
diff --git a/GUI/coregui/Views/MaskWidgets/GraphicsProxyWidget.h b/GUI/coregui/Views/MaskWidgets/GraphicsProxyWidget.h
new file mode 100644
index 0000000000000000000000000000000000000000..4aa8579fd56a59ddaec062e0ed7e098b966a8c5c
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/GraphicsProxyWidget.h
@@ -0,0 +1,33 @@
+#include "DistributionEditor.h"
+
+#ifndef GRAPHICSITEM_H
+#define GRAPHICSITEM_H
+
+class GraphicsProxyWidget : public QGraphicsProxyWidget
+{
+public:
+ //! Type of this item
+ enum { Type = UserType + 4 };
+
+ //! returns the type of this item
+ //! @return number of type
+ int type() const
+ {
+ return Type;
+ }
+
+protected:
+ //! manages mouse press events
+ //! @param event from scene
+ void mousePressEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages mouse move events
+ //! @param event from scene
+ void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages mouse release events
+ //! @param event from scene
+ void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+};
+
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/MaskEditor.cpp b/GUI/coregui/Views/MaskWidgets/MaskEditor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..78d28a5240c56e733e3b8dfded26912b75d7b53b
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/MaskEditor.cpp
@@ -0,0 +1,209 @@
+#include <QDebug>
+#include <ColorMapPlot.h>
+#include <QPointF>
+#include "GraphicsProxyWidget.h"
+#include "ColorMapPlot.h"
+#include "IntensityDataItem.h"
+#include "SimulationRegistry.h"
+#include "MaskGraphicsScene.h"
+#include "MaskGraphicsView.h"
+#include "MaskEditor.h"
+#include "MaskToolBar.h"
+#include "RectangleView.h"
+#include "EllipseView.h"
+#include "PolygonView.h"
+#include "MaskModel.h"
+#include "SampleBuilderFactory.h"
+
+
+const qreal widthOfScene = 2000;
+const qreal heightOfScene = 2000;
+
+
+MaskEditor::MaskEditor(QWidget *parent)
+ : QWidget(parent)
+ , m_scene(new MaskGraphicsScene(this))
+ , m_view(new MaskGraphicsView(m_scene, this))
+ , m_proxyWidget(new GraphicsProxyWidget)
+ , m_listView(new QListView(this))
+ , m_toolBar(new MaskToolBar)
+ , m_deleteAction(new QAction("Delete", this))
+{
+ this->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+ setMouseTracking(true);
+ m_view->setMouseTracking(true);
+ m_view->setRenderHint(QPainter::HighQualityAntialiasing);
+ m_view->setRenderHint(QPainter::TextAntialiasing);
+ m_scene->sceneRect().setWidth(widthOfScene);
+ m_scene->setSceneRect(0,0,widthOfScene, heightOfScene);
+ m_listView->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
+ m_listView->setContextMenuPolicy(Qt::ActionsContextMenu);
+ m_listView->addAction(m_deleteAction);
+ m_listView->setSelectionMode(QAbstractItemView::ExtendedSelection);
+
+ init_connections();
+
+ QGridLayout *mainLayout = new QGridLayout;
+ mainLayout->addWidget(m_toolBar,0,0,1,0);
+ mainLayout->setSpacing(0);
+ mainLayout->addWidget(m_view, 1,0);
+ mainLayout->addWidget(m_listView, 1,1);
+ setLayout(mainLayout);
+
+}
+
+void MaskEditor::init_connections()
+{
+ connect(m_toolBar, SIGNAL(changeToSelectionMode()), this, SLOT(changeToSelectionMode()));
+ connect(m_scene, SIGNAL(itemIsDrawn()), this, SLOT(changeToSelectionMode()));
+ connect(m_scene, SIGNAL(itemIsDrawn()), m_toolBar, SLOT(selectSelectionMode()));
+ connect(m_toolBar, SIGNAL(panMode(bool)), this, SLOT(panMode(bool)));
+ connect(m_toolBar, SIGNAL(rectangleButtonPressed()), this, SLOT(rectangleButtonPressed()));
+ connect(m_toolBar, SIGNAL(ellipseButtonPressed()), SLOT(ellipseButtonPressed()));
+ connect(m_toolBar, SIGNAL(polygonButtonPressed()), this, SLOT(polygonButtonPressed()));
+ connect(m_toolBar, SIGNAL(bringToFrontClicked()), this, SLOT(bringToFrontClicked()));
+ connect(m_toolBar, SIGNAL(sendToBackClicked()), this, SLOT(sendToBackClicked()));
+ connect(m_toolBar, SIGNAL(includeClicked()), this, SLOT(includeClicked()));
+ connect(m_toolBar, SIGNAL(excludeClicked()), this , SLOT(excludeClicked()));
+ connect(this, SIGNAL(deleteSelectedItems()), m_scene, SLOT(deleteSelectedItems()));
+ connect(m_deleteAction, SIGNAL(triggered(bool)), m_scene, SLOT(deleteSelectedItems()));
+ connect(m_view, SIGNAL(deleteSelectedItems()), m_scene, SLOT(deleteSelectedItems()));
+}
+
+void MaskEditor::keyPressEvent(QKeyEvent *event)
+{
+ switch (event->key()) {
+ case Qt::Key_Delete:
+ emit deleteSelectedItems();
+ break;
+ default:
+ QWidget::keyPressEvent(event);
+ break;
+ };
+}
+
+void MaskEditor::rectangleButtonPressed()
+{
+ m_scene->setDrawing(MaskGraphicsScene::RECTANGLE);
+}
+
+void MaskEditor::ellipseButtonPressed()
+{
+ m_scene->setDrawing(MaskGraphicsScene::ELLIPSE);
+}
+
+void MaskEditor::polygonButtonPressed()
+{
+ m_scene->setDrawing(MaskGraphicsScene::POLYGON);
+}
+
+void MaskEditor::panMode(bool active)
+{
+ if(active) {
+ m_view->setDragMode(QGraphicsView::ScrollHandDrag);
+ m_view->setInteractive(false);
+ }
+ else {
+ m_view->setDragMode(QGraphicsView::NoDrag);
+ m_view->setInteractive(true);
+ }
+}
+
+void MaskEditor::deleteSelectedItem()
+{
+ QList<QGraphicsItem*> selectedItems = m_view->scene()->selectedItems();
+ for(int i = 0; i < selectedItems.length(); ++i) {
+ m_scene->removeItem(selectedItems[i]);
+ }
+
+}
+
+void MaskEditor::bringToFrontClicked()
+{
+ m_scene->onBringToFront();
+
+}
+
+void MaskEditor::sendToBackClicked()
+{
+ m_scene->onSendToBack();
+}
+
+void MaskEditor::includeClicked()
+{
+ QList<QGraphicsItem*> selectedItems = m_view->scene()->selectedItems();
+ for(int i = 0; i < selectedItems.length(); ++i) {
+ if(RectangleView::Type == selectedItems[i]->type()) {
+ qgraphicsitem_cast<RectangleView* >(selectedItems[i])->setInclude();
+ }
+ else if(EllipseView::Type == selectedItems[i]->type()) {
+ qgraphicsitem_cast<EllipseView* >(selectedItems[i])->setInclude();
+ }
+ else if(PolygonView::Type == selectedItems[i]->type()) {
+ qgraphicsitem_cast<PolygonView* >(selectedItems[i])->setInclude();
+ }
+ }
+}
+
+void MaskEditor::excludeClicked()
+{
+ QList<QGraphicsItem*> selectedItems = m_view->scene()->selectedItems();
+ for(int i = 0; i < selectedItems.length(); ++i) {
+ if(RectangleView::Type == selectedItems[i]->type()) {
+ qgraphicsitem_cast<RectangleView * >(selectedItems[i])->setExclude();
+ }
+ else if(EllipseView::Type == selectedItems[i]->type()) {
+ qgraphicsitem_cast<EllipseView* >(selectedItems[i])->setExclude();
+ }
+ else if(PolygonView::Type == selectedItems[i]->type()) {
+ qgraphicsitem_cast<PolygonView* >(selectedItems[i])->setExclude();
+ }
+ }
+}
+
+void MaskEditor::changeToSelectionMode()
+{
+ m_scene->setDrawing(MaskGraphicsScene::NONE);
+}
+
+void MaskEditor::changeToDrawingMode()
+{
+ m_view->setDragMode(QGraphicsView::NoDrag);
+ m_view->setInteractive(true);
+}
+
+void MaskEditor::setModel(MaskModel *maskModel)
+{
+ m_listView->setModel(maskModel);
+ m_scene->setModel(maskModel);
+ m_scene->setSelectionModel(m_listView->selectionModel());
+
+// SimulationRegistry sim_registry;
+// Simulation *sim = sim_registry.createSimulation("BasicGISAS");
+// SampleBuilderFactory sampleFactory;
+// SampleBuilder_t builder = sampleFactory.createBuilder("CylindersAndPrismsBuilder");
+// sim->setSampleBuilder(builder);
+
+// sim->runSimulation();
+// qDebug() << sim->getIntensityData() << sim->getIntensityData()->totalSum();
+
+// IntensityDataItem *dataItem = new IntensityDataItem;
+// dataItem->setOutputData(sim->getIntensityData());
+
+// ColorMapPlot *colorMapPlot = new ColorMapPlot;
+// colorMapPlot->setItem(dataItem);
+
+// m_proxyWidget->setWidget(colorMapPlot);
+
+ m_proxyWidget->setPos(m_scene->sceneRect().topLeft());
+ m_proxyWidget->resize(m_scene->width(), m_scene->height());
+ m_scene->addItem(m_proxyWidget);
+}
+
+void MaskEditor::onItemIsDrawn()
+{
+ emit itemIsDrawn();
+}
+
+
+
diff --git a/GUI/coregui/Views/MaskWidgets/MaskEditor.h b/GUI/coregui/Views/MaskWidgets/MaskEditor.h
new file mode 100644
index 0000000000000000000000000000000000000000..49b2dd8119ef2a9cdbdef11eac156e49f0f68df7
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/MaskEditor.h
@@ -0,0 +1,86 @@
+#ifndef MASKEDITOR_H
+#define MASKEDITOR_H
+
+class MaskGraphicsView;
+class MaskGraphicsScene;
+class GraphicsProxyWidget;
+class MaskModel;
+class MaskToolBar;
+class QListView;
+class QVBoxLayout;
+class QAction;
+
+class MaskEditor : public QWidget
+{
+ Q_OBJECT
+public:
+ MaskEditor(QWidget *parent = 0);
+
+ virtual ~MaskEditor()
+ {
+ }
+
+ //! set Model
+ //! param mask model that caries model for masking
+ void setModel(MaskModel *maskModel);
+
+private slots:
+
+ //! creates a rectangle on button press event
+ void rectangleButtonPressed();
+
+ //! creates a ellipse on button press event
+ void ellipseButtonPressed();
+
+ //! creates a polygon on button press event
+ void polygonButtonPressed();
+
+ //! switch on pan mode
+ void panMode(bool active);
+
+ //! delete selected item
+ void deleteSelectedItem();
+
+ //! bring current selected item to the top
+ void bringToFrontClicked();
+
+ //! send current selected item to the bottom
+ void sendToBackClicked();
+
+ //! create include item
+ void includeClicked();
+
+ //! create exclude item
+ void excludeClicked();
+
+ //! change from drawing mode to selection mode
+ void changeToSelectionMode();
+
+ //!change from selection mode to drawing mode
+ void changeToDrawingMode();
+
+ //!change back to selecton mode if item is drawn
+ void onItemIsDrawn();
+
+private:
+ MaskGraphicsScene *m_scene; //!< scene contains all items
+ MaskGraphicsView *m_view; //!< view renders all items and show them item in the scene on display
+ GraphicsProxyWidget *m_proxyWidget; //!< color map (detector)
+ QListView *m_listView; //!< list wiht currently created items as a list
+ MaskToolBar *m_toolBar; //!< tool bar
+ QAction *m_deleteAction; //!< delete action for the list view
+ void init_connections(); //!< initialie all connections between scene, view and toolbar
+
+signals:
+ //! emittes this signal to toolbar if item is drawn
+ void itemIsDrawn();
+
+ //! signal is emitted when someone want to delete item
+ void deleteSelectedItems();
+
+protected:
+ //! event that manages key press events
+ void keyPressEvent(QKeyEvent *event);
+};
+
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.cpp b/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8604318575bb0e29857b4124c503a950bb13b601
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.cpp
@@ -0,0 +1,497 @@
+#include "MaskGraphicsScene.h"
+#include "RectangleItem.h"
+#include "RectangleView.h"
+#include "EllipseItem.h"
+#include "PolygonItem.h"
+#include "PointItem.h"
+#include "MaskModel.h"
+#include "SampleViewFactory.h"
+#include <QItemSelection>
+#include <cmath>
+#include <sstream>
+#include <QGraphicsSceneMouseEvent>
+#include <QDebug>
+#include <QTreeView>
+#include <QPainter>
+#include <QGraphicsProxyWidget>
+
+MaskGraphicsScene::MaskGraphicsScene(QObject *parent)
+ : QGraphicsScene(parent)
+ , m_maskModel(0)
+ , m_currentItem(0)
+ , m_currentMousePosition(QPointF(0, 0))
+ , m_lastAddedPoint(QPointF(0, 0))
+ , m_block_selection(false)
+ , m_numberOfRectangles(0)
+ , m_numberOfEllipses(0)
+ , m_numberOfPolygons(0)
+{
+// setSceneRect(QRectF(-800, 0, 1600, 1600));
+ m_drawingMode = NONE;
+}
+
+void MaskGraphicsScene::setDrawing(DrawingMode drawingMode)
+{
+ m_drawingMode = drawingMode;
+}
+
+void MaskGraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+ if(event->button() == Qt::LeftButton) {
+ if (m_drawingMode == RECTANGLE) {
+ m_currentItem = m_maskModel->insertNewItem(Constants::RectangleType);
+ setItemName(m_currentItem);
+ } else if (m_drawingMode == ELLIPSE) {
+ m_currentItem = m_maskModel->insertNewItem(Constants::EllipseType);
+ setItemName(m_currentItem);
+ } else if (m_drawingMode == POLYGON) {
+ if (!m_currentItem) {
+ m_currentItem = m_maskModel->insertNewItem(Constants::PolygonType);
+ m_currentItem->setRegisteredProperty(PolygonItem::P_DRAWINGMODE, true);
+ setItemName(m_currentItem);
+ }
+ if (numberOfPoints() > 2 && firstPointContainsMouseClick(event)) {
+ m_currentItem->setRegisteredProperty(PolygonItem::P_DRAWINGMODE, false);
+ m_maskModel->moveParameterizedItem(m_currentItem, 0, 0);
+ m_currentItem = 0;
+ m_drawingMode = NONE;
+ emit itemIsDrawn();
+ }
+ else if(m_currentItem) {
+ ParameterizedItem *pointItem = m_maskModel->insertNewItem(Constants::PointType,
+ m_maskModel->indexOfItem(m_currentItem));
+ pointItem->setRegisteredProperty(PointItem::P_POSX, event->scenePos().x());
+ pointItem->setRegisteredProperty(PointItem::P_POSY, event->scenePos().y());
+ }
+ }
+ else {
+ QGraphicsScene::mousePressEvent(event);
+ }
+ }
+ m_lastAddedPoint = event->buttonDownScenePos(Qt::LeftButton);
+ m_currentPoint = event->buttonDownScenePos(Qt::LeftButton);
+}
+
+void MaskGraphicsScene::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+ if (m_drawingMode == RECTANGLE && m_currentItem) {
+ drawingDirection(event);
+ } else if (m_drawingMode == ELLIPSE && m_currentItem) {
+ drawingDirection(event);
+ }
+ else {
+ QGraphicsScene::mouseMoveEvent(event);
+ }
+ m_currentMousePosition = event->scenePos();
+}
+
+void MaskGraphicsScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+ bool drawingToSmall = false;
+ if (m_drawingMode == RECTANGLE && m_currentItem) {
+ if (std::abs(m_currentItem->getRegisteredProperty(RectangleItem::P_WIDTH).toReal()) <= 10 &&
+ std::abs(m_currentItem->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal()) <= 10){
+ QModelIndex index = m_maskModel->indexOfItem(m_currentItem);
+ m_maskModel->removeRows(index.row(), 1, index.parent());
+ m_numberOfRectangles--;
+ drawingToSmall = true;
+ }
+ } else if (m_drawingMode == ELLIPSE && m_currentItem) {
+ if (std::abs(m_currentItem->getRegisteredProperty(EllipseItem::P_WIDTH).toReal()) <= 10 &&
+ std::abs(m_currentItem->getRegisteredProperty(EllipseItem::P_HEIGHT).toReal()) <= 10) {
+ QModelIndex index = m_maskModel->indexOfItem(m_currentItem);
+ m_maskModel->removeRows(index.row(), 1, index.parent());
+ m_numberOfEllipses--;
+ drawingToSmall = true;
+ }
+ }
+
+ if (m_drawingMode == RECTANGLE || m_drawingMode == ELLIPSE) {
+ if(!drawingToSmall && m_currentItem) {
+ m_maskModel->moveParameterizedItem(m_currentItem, 0, 0);
+ // uncomment this if you want to change to selection mode after drawing an item.
+// emit itemIsDrawn();
+ }
+ m_currentItem = 0;
+ }
+ QGraphicsScene::mouseReleaseEvent(event);
+}
+
+void MaskGraphicsScene::drawForeground(QPainter *painter, const QRectF & /* rect */)
+{
+ if (m_drawingMode == POLYGON && m_currentItem) {
+ if(numberOfPoints() == 0) {
+ m_lastAddedPoint = m_currentMousePosition;
+ }
+ painter->setPen(QPen(Qt::black, 1, Qt::DashLine));
+ painter->drawLine(QLineF(m_lastAddedPoint, m_currentMousePosition));
+ invalidate();
+ }
+ else {
+ m_lastAddedPoint = m_currentMousePosition;
+ }
+
+}
+
+void MaskGraphicsScene::updateViews(const QModelIndex &parentIndex)
+{
+ Q_ASSERT(m_maskModel);
+
+ for (int i_row = 0; i_row < m_maskModel->rowCount(parentIndex); ++i_row) {
+ QModelIndex itemIndex = m_maskModel->index(i_row, 0, parentIndex);
+
+ if (ParameterizedItem *item = m_maskModel->itemForIndex(itemIndex)) {
+ addViewForItem(item);
+ }
+ }
+}
+
+IView *MaskGraphicsScene::addViewForItem(ParameterizedItem *item)
+{
+ qDebug() << "GraphicsScene::addViewForItem() ->" << item->modelType() << item;
+ Q_ASSERT(item);
+
+ IView *view = m_ItemToView[item];
+ if (!view) {
+ qDebug() << " GraphicsScene::addViewForItem() -> Creating view for item"
+ << item->modelType();
+ view = SampleViewFactory::createSampleView(item->modelType());
+ if (view) {
+ m_ItemToView[item] = view;
+ view->setParameterizedItem(item);
+ addItem(view);
+ return view;
+ }
+ } else {
+ qDebug() << " GraphicsScene::addViewForItem() -> View for item exists."
+ << item->modelType();
+ }
+ return view;
+}
+
+void MaskGraphicsScene::updateScene()
+{
+ if(this->items().size() > 0) {
+ m_colorMap = this->items().at(0);
+ updateViews();
+ setZValues();
+ addItem(m_colorMap);
+ }
+ else {
+ updateViews();
+ setZValues();
+ }
+}
+
+void MaskGraphicsScene::resetScene()
+{
+ qDebug() << "GraphicsScene::resetScene()";
+ clear();
+ m_ItemToView.clear();
+}
+
+void MaskGraphicsScene::setSelectionModel(QItemSelectionModel *selectionModel)
+{
+ m_selectionModel = selectionModel;
+
+ connect(m_selectionModel, SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this,
+ SLOT(onSessionSelectionChanged(QItemSelection, QItemSelection)));
+}
+
+void MaskGraphicsScene::setModel(MaskModel *maskModel)
+{
+ if(m_maskModel) {
+ disconnect(this, SIGNAL(selectionChanged()), this, SLOT(onSceneSelectionChanged()));
+ disconnect(m_maskModel, SIGNAL(modelAboutToBeReset()), this, SLOT(resetScene()));
+ disconnect(m_maskModel, SIGNAL(rowsInserted(QModelIndex, int, int)), this,
+ SLOT(onRowsInserted(QModelIndex, int, int)));
+ disconnect(m_maskModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), this,
+ SLOT(onRowsAboutToBeRemoved(QModelIndex, int, int)));
+ disconnect(m_maskModel, SIGNAL(rowsRemoved(QModelIndex, int, int)), this,
+ SLOT(onRowsRemoved(QModelIndex, int, int)));
+ disconnect(m_maskModel, SIGNAL(modelReset()), this, SLOT(updateScene()));
+ }
+
+ m_maskModel = maskModel;
+
+ connect(this, SIGNAL(selectionChanged()), this, SLOT(onSceneSelectionChanged()));
+ connect(m_maskModel, SIGNAL(modelAboutToBeReset()), this, SLOT(resetScene()));
+ connect(m_maskModel, SIGNAL(rowsInserted(QModelIndex, int, int)), this,
+ SLOT(onRowsInserted(QModelIndex, int, int)));
+ connect(m_maskModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), this,
+ SLOT(onRowsAboutToBeRemoved(QModelIndex, int, int)));
+ connect(m_maskModel, SIGNAL(rowsRemoved(QModelIndex, int, int)), this,
+ SLOT(onRowsRemoved(QModelIndex, int, int)));
+ connect(m_maskModel, SIGNAL(modelReset()), this, SLOT(updateScene()));
+
+ resetScene();
+ updateScene();
+}
+
+void MaskGraphicsScene::onSessionSelectionChanged(const QItemSelection &, const QItemSelection &)
+{
+ if (m_block_selection)
+ return;
+
+ qDebug() << "GraphicsScene::SelectionChanged()";
+ m_block_selection = true;
+
+ for (QMap<ParameterizedItem *, IView *>::iterator it = m_ItemToView.begin();
+ it != m_ItemToView.end(); ++it) {
+ QModelIndex index = m_maskModel->indexOfItem(it.key());
+ if (index.isValid()) {
+ if (m_selectionModel->isSelected(index)) {
+ it.value()->setSelected(true);
+ } else {
+ it.value()->setSelected(false);
+ }
+ }
+ }
+
+ m_block_selection = false;
+}
+
+void MaskGraphicsScene::onRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last)
+{
+ m_block_selection = true;
+ qDebug() << "GraphicsScene::onRowsAboutToBeRemoved()" << parent << first << last;
+ for (int irow = first; irow <= last; ++irow) {
+ QModelIndex itemIndex = m_maskModel->index(irow, 0, parent);
+ deleteViews(itemIndex); // deleting all child items
+ }
+ m_block_selection = false;
+}
+
+void MaskGraphicsScene::deleteViews(const QModelIndex &parentIndex)
+{
+ qDebug() << "GraphicsScene::deleteViews()" << parentIndex;
+
+ for (int i_row = 0; i_row < m_maskModel->rowCount(parentIndex); ++i_row) {
+ QModelIndex itemIndex = m_maskModel->index(i_row, 0, parentIndex);
+
+ if (ParameterizedItem *item = m_maskModel->itemForIndex(itemIndex)) {
+
+ removeItemViewFromScene(item);
+
+ } else {
+ qDebug() << "not a parameterized graphics item";
+ }
+ deleteViews(itemIndex);
+ }
+ removeItemViewFromScene(m_maskModel->itemForIndex(parentIndex)); // deleting parent item
+}
+
+//! removes view from scene corresponding to given item
+void MaskGraphicsScene::removeItemViewFromScene(ParameterizedItem *item)
+{
+ qDebug() << "GraphicsScene::removeItemFromScene()" << item->modelType();
+ for (QMap<ParameterizedItem *, IView *>::iterator it = m_ItemToView.begin();
+ it != m_ItemToView.end(); ++it) {
+ if (it.key() == item) {
+ IView *view = it.value();
+ view->setSelected(false);
+ m_ItemToView.erase(it);
+ emit view->aboutToBeDeleted();
+ delete view;
+ update();
+ break;
+ }
+ }
+}
+
+void MaskGraphicsScene::onRowsRemoved(const QModelIndex &/* parent */, int /* first */, int /* last */)
+{
+ updateScene();
+}
+
+void MaskGraphicsScene::deleteSelectedItems()
+{
+ qDebug() << "GraphicsScene::deleteSelectedItems() 1.1" << selectedItems().size();
+
+ QModelIndexList indexes = m_selectionModel->selectedIndexes();
+
+ // deleting selected items on model side, corresponding views will be deleted automatically
+ // Since we don't know the order of items, we need this
+
+ while(indexes.size()) {
+ m_maskModel->removeRows(indexes.back().row(), 1, indexes.back().parent());
+ indexes = m_selectionModel->selectedIndexes();
+ }
+}
+
+//! propagate selection from scene to model
+void MaskGraphicsScene::onSceneSelectionChanged()
+{
+ qDebug() << "GraphicsScene::onSceneSelectionChanged() 1.1";
+ if (m_block_selection)
+ return;
+
+ m_block_selection = true;
+
+ m_selectionModel->clearSelection();
+ QList<QGraphicsItem *> selected = selectedItems();
+ for (int i = 0; i < selected.size(); ++i) {
+ IView *view = dynamic_cast<IView *>(selected[i]);
+ if (view) {
+ ParameterizedItem *sampleItem = view->getParameterizedItem();
+ QModelIndex itemIndex = m_maskModel->indexOfItem(sampleItem);
+ Q_ASSERT(itemIndex.isValid());
+ if (!m_selectionModel->isSelected(itemIndex))
+ m_selectionModel->select(itemIndex, QItemSelectionModel::Select);
+ // break; // selection of only one item will be propagated to the model
+ }
+ }
+
+ m_block_selection = false;
+}
+
+void MaskGraphicsScene::onRowsInserted(const QModelIndex & /* parent */, int /* first */, int /* last */)
+{
+ updateScene();
+}
+
+void MaskGraphicsScene::setItemName(ParameterizedItem *item)
+{
+ int numberOfItems(0);
+ QString name;
+ QMap<ParameterizedItem *, IView *>::iterator it;
+ for(it = m_ItemToView.begin(); it != m_ItemToView.end(); ++it) {
+ if(item->modelType() == it.key()->modelType()) {
+ numberOfItems ++;
+ }
+ }
+ if(item->modelType() == "Rectangle") {
+ if(numberOfItems <= m_numberOfRectangles) {
+ m_numberOfRectangles ++;
+ }
+ else {
+ m_numberOfRectangles = numberOfItems;
+ }
+ name = item->itemName().append(QString("%1")).arg(m_numberOfRectangles);
+ }
+ else if(item->modelType() == "Ellipse") {
+ if(numberOfItems <= m_numberOfEllipses) {
+ m_numberOfEllipses ++;
+ }
+ else {
+ m_numberOfEllipses = numberOfItems;
+ }
+ name = item->itemName().append(QString("%1")).arg(m_numberOfEllipses);
+ }
+ else if(item->modelType() == "Polygon") {
+ if(numberOfItems <= m_numberOfPolygons) {
+ m_numberOfPolygons++;
+ }
+ else {
+ m_numberOfPolygons = numberOfItems;
+ }
+ name = item->itemName().append(QString("%1")).arg(m_numberOfPolygons);
+ }
+ item->setItemName(name);
+}
+
+int MaskGraphicsScene::numberOfPoints()
+{
+ if(m_drawingMode == POLYGON) {
+ int items = m_currentItem->childItems().length();
+ return items;
+ }
+ return 0;
+}
+
+bool MaskGraphicsScene::firstPointContainsMouseClick(QGraphicsSceneMouseEvent *event)
+{
+ QRectF firstPoint(
+ m_currentItem->childItems()[0]->getRegisteredProperty(PointItem::P_POSX).toReal() - 2.5,
+ m_currentItem->childItems()[0]->getRegisteredProperty(PointItem::P_POSY).toReal() - 2.5,
+ 5, 5);
+
+ if(firstPoint.contains(event->scenePos())) {
+ ParameterizedItem *pointItem = m_maskModel->insertNewItem(Constants::PointType,
+ m_maskModel->indexOfItem(m_currentItem));
+ pointItem->setRegisteredProperty(PointItem::P_POSX, firstPoint.center().x());
+ pointItem->setRegisteredProperty(PointItem::P_POSY, firstPoint.center().y());
+ return true;
+ }
+
+ else {
+ return false;
+ }
+}
+
+void MaskGraphicsScene::onBringToFront()
+{
+ QModelIndexList indexes = m_selectionModel->selectedIndexes();
+
+ for(int i = 0; i < indexes.size(); i++) {
+ ParameterizedItem *item = m_maskModel->itemForIndex(indexes.at(i));
+ int row = indexes.at(i).row() -1;
+
+ if(m_maskModel->rowCount(QModelIndex()) == 0) {
+ return;
+ }
+ else {
+ qreal x = m_ItemToView[item]->pos().x();
+ qreal y = m_ItemToView[item]->pos().y();
+ m_maskModel->moveParameterizedItem(item, 0, row);
+
+ QModelIndex movedItemIndex = m_maskModel->index(row,0,QModelIndex());
+ ParameterizedItem *movedItem = m_maskModel->itemForIndex(movedItemIndex);
+ m_ItemToView[movedItem]->setPos(x,y);
+ }
+ }
+}
+
+void MaskGraphicsScene::onSendToBack()
+{
+ QModelIndexList indexes = m_selectionModel->selectedIndexes();
+ qDebug() << "MaskGraphicsScene::onSendToBack()" << indexes.size();
+ for(int i = 0; i < indexes.size(); i++) {
+ ParameterizedItem *item = m_maskModel->itemForIndex(indexes.at(i));
+ int row = indexes.at(i).row() + 2;
+
+ if(indexes.at(i).row() == m_maskModel->rowCount(QModelIndex()) -1 ) {
+ return;
+ }
+ else {
+ qreal x = m_ItemToView[item]->pos().x();
+ qreal y = m_ItemToView[item]->pos().y();
+ m_maskModel->moveParameterizedItem(item, 0, row);
+
+ QModelIndex movedItemIndex = m_maskModel->index(row -1 ,0,QModelIndex());
+ ParameterizedItem *movedItem = m_maskModel->itemForIndex(movedItemIndex);
+ m_ItemToView[movedItem]->setPos(x,y);
+ }
+
+ }
+}
+
+void MaskGraphicsScene::setZValues()
+{
+ for(int i = 0; i < m_maskModel->rowCount(QModelIndex()); i++) {
+ QModelIndex indexes = m_maskModel->index(i, 0, QModelIndex());
+ ParameterizedItem *item = m_maskModel->itemForIndex(indexes);
+ m_ItemToView[item]->setZValue(m_maskModel->rowCount(QModelIndex()) - indexes.row() + 1);
+ }
+}
+
+void MaskGraphicsScene::drawingDirection(QGraphicsSceneMouseEvent *event)
+{
+ qreal xmin = std::min(event->scenePos().x(),m_currentPoint.x());
+ qreal xmax = std::max(event->scenePos().x(),m_currentPoint.x());
+ qreal ymin = std::min(event->scenePos().y(),m_currentPoint.y());
+ qreal ymax = std::max(event->scenePos().y(),m_currentPoint.y());
+
+ m_currentItem->setRegisteredProperty("Width", xmax - xmin);
+ m_currentItem->setRegisteredProperty("Height", ymax - ymin);
+
+ m_currentItem->setRegisteredProperty("X position", xmin);
+ m_currentItem->setRegisteredProperty("Y position", ymin);
+
+
+}
+
+
+
+
+
diff --git a/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.h b/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.h
new file mode 100644
index 0000000000000000000000000000000000000000..f030e15834230c1f4e078b38c23f5287a3bf0e06
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/MaskGraphicsScene.h
@@ -0,0 +1,147 @@
+#ifndef MASKGRAPHICSSCENE_H
+#define MASKGRAPHICSSCENE_H
+
+#include <QGraphicsScene>
+#include <QItemSelection>
+#include <QModelIndex>
+
+class RectangleItem;
+class MaskModel;
+class ParameterizedItem;
+class QListView;
+class QTreeView;
+class QItemSelectionModel;
+class IView;
+class QSelectionModel;
+class QGraphicsItem;
+class QGraphicsSceneMouseEvent;
+
+class MaskGraphicsScene : public QGraphicsScene
+{
+ Q_OBJECT
+
+public:
+ MaskGraphicsScene(QObject *parent = 0);
+
+ //! describes items that are currently being drawn
+ enum DrawingMode { NONE, RECTANGLE, ELLIPSE, POLYGON };
+
+ //! set drawing mode
+ //! @param drawingMode item that shoulb be drawn
+ void setDrawing(DrawingMode drawingMode);
+
+ //! set selection Model
+ //! @param selectionModel includes the selected item from the list view
+ void setSelectionModel(QItemSelectionModel *selectionModel);
+
+ //! set mask model
+ //! @param maskModel contains all models for masking
+ void setModel(MaskModel *maskModel);
+
+ //! takes current selected item and put it one row upwards
+ void onBringToFront();
+
+ //! takes current selected item and put it one row below
+ void onSendToBack();
+
+public slots:
+ //! delete current selected items
+ void deleteSelectedItems();
+
+ //! removes all items and views
+ //! @param parent
+ //! @param first child item
+ //! @param last child item
+ void onRowsAboutToBeRemoved(const QModelIndex &parent, int first, int last);
+
+ //! selects selected items from list view on the graphics view
+ void onSessionSelectionChanged(const QItemSelection &, const QItemSelection &);
+
+ //! updates scene
+ void onRowsRemoved(const QModelIndex &, int, int);
+
+ //! updates scene
+ void onRowsInserted(const QModelIndex &, int, int);
+
+ //! selects selected items from graphics view on the list view
+ void onSceneSelectionChanged();
+
+ //! resets scene by clearing scene
+ void resetScene();
+
+ //! updates views, sets z-values and adds color map
+ void updateScene();
+
+signals:
+ //! emits signal that current item is drawn (only working if it is uncommented)
+ void itemIsDrawn();
+
+protected:
+ //! manages mouse press events
+ //! @param event contains current mouse press
+ void mousePressEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages mouse move events
+ //! @param event contains current mouse move
+ void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages mouse release events
+ //! @param event contains current mouse release
+ void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+
+ //! draws dashed line when polygon is drawn
+ //! @param painter to draw dashed line
+ void drawForeground(QPainter *painter, const QRectF &);
+
+private:
+ MaskModel *m_maskModel; //!< model that contains all mask items
+ QItemSelectionModel *m_selectionModel; //!< model that contains all selected items
+ QMap<ParameterizedItem *, IView *>
+ m_ItemToView; //!< map that contains all items as key and all views as value
+ DrawingMode m_drawingMode; //!< current drawing mode
+ ParameterizedItem *m_currentItem; //!<current item being drawn
+ QPointF m_currentMousePosition; //!< current mouse position
+ QPointF m_lastAddedPoint; //!< last added point to a polygon
+ bool m_block_selection; //!< blocks selection of items
+ QPointF m_currentPoint; //!< describes the current point of polygon
+ QGraphicsItem *m_colorMap; //!< color map (detector)
+ int m_numberOfRectangles; //!< number of rectangles were ever drawn
+ int m_numberOfEllipses; //!< number of ellipses were ever drawn
+ int m_numberOfPolygons; //!< number of polygon were ever drawn
+
+ //! number of points from polygon
+ //! @returns the number of points in polygon else 0
+ int numberOfPoints();
+
+ //! sets name to current item
+ //! @param item currently drawn item
+ void setItemName(ParameterizedItem *item);
+
+ //! delete views
+ //! @param parentIndex parameter for parent idex
+ void deleteViews(const QModelIndex &parentIndex);
+
+ //! removes item view from scene
+ //! @param item to remove
+ void removeItemViewFromScene(ParameterizedItem *item);
+
+ //! updating views
+ void updateViews(const QModelIndex &parentIndex = QModelIndex());
+
+ //! adds view for item
+ //! @param item parameter that gets a view
+ IView *addViewForItem(ParameterizedItem *item);
+
+ //! verifies if first point contains the current mouse press
+ //! @param current mouse event
+ //! @returns true if first point contains mouse click else false
+ bool firstPointContainsMouseClick(QGraphicsSceneMouseEvent *event);
+
+ //! sets z-values from views
+ void setZValues();
+
+ //! verifies drawing direction
+ //! @param event to get current direction
+ void drawingDirection(QGraphicsSceneMouseEvent *event);
+};
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/MaskGraphicsView.cpp b/GUI/coregui/Views/MaskWidgets/MaskGraphicsView.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..85f14507cd91721c91b83862ae1fbe99c4212f45
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/MaskGraphicsView.cpp
@@ -0,0 +1,83 @@
+#include "MaskGraphicsView.h"
+#include "GraphicsProxyWidget.h"
+#include "MaskGraphicsScene.h"
+
+
+MaskGraphicsView::MaskGraphicsView(QGraphicsScene *scene, QWidget *parent)
+ : QGraphicsView(scene, parent)
+{
+}
+
+
+void MaskGraphicsView::wheelEvent(QWheelEvent *event)
+{
+ // hold control button
+ if(controlButtonIsPressed(event)) {
+ centerOn(mapToScene(event->pos()));
+
+ // Scale the view / do the zoom
+ const double scaleFactor = 1.15;
+
+ if(event->delta() > 0) {
+ // Zoom in
+ this->scale(scaleFactor, scaleFactor);
+
+ } else {
+ // Zooming out
+ if(horizontalScrollBar()->isVisible() || verticalScrollBar()->isVisible())
+ this->scale(1.0 / scaleFactor, 1.0 / scaleFactor);
+ }
+ }
+// else if(eventPosIsOnColorMap(event)) {
+// this->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+// this->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+// QGraphicsView::wheelEvent(event);
+// }
+ else {
+ QGraphicsView::wheelEvent(event);
+ }
+}
+void MaskGraphicsView::keyPressEvent(QKeyEvent *event)
+{
+ switch (event->key()) {
+ case Qt::Key_Delete:
+ emit deleteSelectedItems();
+ break;
+ case Qt::Key_Space:
+ if (!event->isAutoRepeat())
+ panMode(true);
+ break;
+ default:
+ QWidget::keyPressEvent(event);
+ break;
+ }
+}
+void MaskGraphicsView::keyReleaseEvent(QKeyEvent *event)
+{
+ switch (event->key()) {
+ case Qt::Key_Space:
+ if (!event->isAutoRepeat())
+ panMode(false);
+ break;
+ default:
+ QWidget::keyReleaseEvent(event);
+ break;
+ }
+}
+
+
+bool MaskGraphicsView::controlButtonIsPressed(QWheelEvent *event)
+{
+ if(event->modifiers().testFlag(Qt::ControlModifier)){
+ return true;
+ }
+ return false;
+}
+
+bool MaskGraphicsView::eventPosIsOnColorMap(QWheelEvent *event)
+{
+ if(this->scene()->items()[0]->boundingRect().contains(event->pos())) {
+ return true;
+ }
+ return false;
+}
diff --git a/GUI/coregui/Views/MaskWidgets/MaskGraphicsView.h b/GUI/coregui/Views/MaskWidgets/MaskGraphicsView.h
new file mode 100644
index 0000000000000000000000000000000000000000..86d5a62527ae681b955b701c493643aebe0e765a
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/MaskGraphicsView.h
@@ -0,0 +1,50 @@
+#ifndef MASKGRAPHICSVIEW_H
+#define MASKGRAPHICSVIEW_H
+
+#include <QGraphicsView>
+
+class MaskGraphicsView : public QGraphicsView
+{
+Q_OBJECT
+public:
+ MaskGraphicsView(QGraphicsScene *scene, QWidget *parent = 0);
+
+protected:
+ //! manages mouse wheel events
+ //! @param event contain current mouse wheel event
+ void wheelEvent(QWheelEvent* event);
+
+ //! zoom to a specific position
+ //! @param factor to be zoomed in or out
+ //! @param centerPoint the point where to zoom in or out
+ void zoom(qreal factor, QPointF centerPoint);
+
+ //! manages key release events
+ //! @param event contains current release button
+ void keyReleaseEvent(QKeyEvent *event);
+
+ //! manages key press events
+ //! @param event contains current clicked button
+ void keyPressEvent(QKeyEvent *event);
+
+private:
+ //! check if control button is pressed to zoom on view
+ //! @param event contains current pressed button
+ //! @returns true if controll button pressed else false
+ bool controlButtonIsPressed(QWheelEvent *event);
+
+ //! check if color map is clicked to zoom on the color map
+ //! @param event contains current pressed button
+ //! @returns true if position of the event is about color map else false
+ bool eventPosIsOnColorMap(QWheelEvent *event);
+
+signals:
+
+ //! emitted if space button is pressed
+ void panMode(bool active);
+
+ //! emitted if delete button is pressed
+ void deleteSelectedItems();
+
+};
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/PolygonView.cpp b/GUI/coregui/Views/MaskWidgets/PolygonView.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..21171d3e6ffd06cbe429f8f3d8c5d6e2610faf18
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/PolygonView.cpp
@@ -0,0 +1,212 @@
+#include "PolygonView.h"
+#include "ParameterizedItem.h"
+#include "PolygonItem.h"
+#include "PointItem.h"
+#include <cmath>
+#include <QDebug>
+#include <QPainter>
+#include <QCursor>
+#include <QGraphicsSceneMouseEvent>
+
+PolygonView::PolygonView()
+ : m_changeCornerMode(false), m_indexOfCurrentSelectedPoint(0), m_mouseIsOverFirstPoint(false)
+
+{
+ this->setFlag(QGraphicsItem::ItemIsSelectable);
+ this->cursor().setShape(Qt::ClosedHandCursor);
+ this->setAcceptHoverEvents(true);
+}
+
+void PolygonView::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+{
+ QPen pen;
+ prepareGeometryChange();
+ painter->setRenderHints(QPainter::Antialiasing);
+ QList<ParameterizedItem *> points = m_item->childItems();
+ QPolygon polygon;
+
+ // draws polygon
+ for (int i = 0; i < points.length(); ++i) {
+ polygon << QPoint(points[i]->getRegisteredProperty(PointItem::P_POSX).toReal(),
+ points[i]->getRegisteredProperty(PointItem::P_POSY).toReal());
+ }
+ painter->drawPolyline(polygon);
+
+ // fills polygon with a color
+ if (getFirstPoint().center().x() == polygon[polygon.length() - 1].x()
+ && getFirstPoint().center().y() == polygon[polygon.length() - 1].y()
+ && points.length() >= 2) {
+
+ QPainterPath path;
+ QBrush transRed(DesignerHelper::getDefaultColor("Transparant red"));
+ QBrush transBlue(DesignerHelper::getDefaultColor("Transparant blue"));
+ path.moveTo(polygon[0].x(),polygon[0].y());
+ for (int i = 1; i < polygon.length(); ++i) {
+ path.lineTo(polygon[i].x(), polygon[i].y());
+ }
+ painter->setPen(Qt::NoPen);
+ if (m_item->getRegisteredProperty(PolygonItem::P_COLOR).toInt() == 0) {
+ painter->fillPath(path, transRed);
+ } else {
+ painter->fillPath(path, transBlue);
+ }
+ }
+
+ if (points.length() >= 1
+ && m_item->getRegisteredProperty(PolygonItem::P_DRAWINGMODE).toBool()) {
+ pen.setWidth(1);
+ if (m_mouseIsOverFirstPoint) {
+ painter->fillRect(getFirstPoint(), Qt::red);
+ } else {
+ painter->drawRect(getFirstPoint());
+ }
+ }
+ // draw all points if item is finised with drawing and is selected
+ if (!m_item->getRegisteredProperty(PolygonItem::P_DRAWINGMODE).toBool() && isSelected()) {
+ pen.setWidth(5);
+ painter->setPen(pen);
+ for (int i = 0; i < points.length() - 1; ++i) {
+ painter->drawPoint(
+ QPointF(polygon[i].x(), polygon[i].y()));
+ }
+ painter->setPen(QPen());
+ }
+}
+
+QRectF PolygonView::boundingRect() const
+{
+ if (m_item->childItems().length() >= 1) {
+ return calculateBoundingRectangle();
+ } else {
+ return QRectF(0, 0, 20, 20);
+ }
+}
+
+bool PolygonView::isCornerClicked(QGraphicsSceneMouseEvent *event)
+{
+ QList<ParameterizedItem *> points = m_item->childItems();
+ for (int i = 0; i < points.length() - 1; ++i) {
+ QRectF rectangle(
+ points[i]->getRegisteredProperty(PointItem::P_POSX).toReal() - 2.5,
+ points[i]->getRegisteredProperty(PointItem::P_POSY).toReal() - 2.5, 5, 5);
+ if (rectangle.contains(event->pos())) {
+ if (i != points.length() - 1 && i != 0) {
+ m_indexOfCurrentSelectedPoint = i;
+ } else {
+ m_indexOfCurrentSelectedPoint = 0;
+ }
+ m_changeCornerMode = true;
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+ return true;
+ }
+ }
+ return false;
+}
+
+QRectF PolygonView::calculateBoundingRectangle() const
+{
+ QList<ParameterizedItem *> points = m_item->childItems();
+ qreal smallestXValue = points[0]->getRegisteredProperty(PointItem::P_POSX).toReal();
+ qreal biggestXValue = points[0]->getRegisteredProperty(PointItem::P_POSX).toReal();
+ qreal smallestYValue = points[0]->getRegisteredProperty(PointItem::P_POSY).toReal();
+ qreal biggestYValue = points[0]->getRegisteredProperty(PointItem::P_POSY).toReal();
+
+
+ for (int i = 1; i < points.length(); ++i) {
+ smallestXValue = std::min(smallestXValue, points[i]->getRegisteredProperty(PointItem::P_POSX).toReal());
+ biggestXValue = std::max(biggestXValue, points[i]->getRegisteredProperty(PointItem::P_POSX).toReal());
+ smallestYValue = std::min(smallestYValue, points[i]->getRegisteredProperty(PointItem::P_POSY).toReal());
+ biggestYValue = std::max(biggestYValue, points[i]->getRegisteredProperty(PointItem::P_POSY).toReal());
+ }
+ return QRectF(QPointF(smallestXValue - 20, smallestYValue - 20),
+ QPointF(biggestXValue + 20, biggestYValue + 20));
+}
+
+void PolygonView::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+ if (isCornerClicked(event)) {
+ m_changeCornerMode = true;
+ } else if (event->button() == Qt::RightButton) {
+ m_item->setRegisteredProperty(PolygonItem::P_DRAWINGMODE, false);
+ } else {
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ QGraphicsItem::mousePressEvent(event);
+ }
+}
+
+void PolygonView::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+ if (m_changeCornerMode) {
+ QList<ParameterizedItem *> points = m_item->childItems();
+ setCursor(Qt::CrossCursor);
+ if (m_indexOfCurrentSelectedPoint == 0) {
+ points[m_indexOfCurrentSelectedPoint]->setRegisteredProperty(PointItem::P_POSX, event->pos().x());
+ points[m_indexOfCurrentSelectedPoint]->setRegisteredProperty(PointItem::P_POSY, event->pos().y());
+ points[points.length() - 1]->setRegisteredProperty(PointItem::P_POSX, event->pos().x());
+ points[points.length() - 1]->setRegisteredProperty(PointItem::P_POSY, event->pos().y());
+ } else {
+ points[m_indexOfCurrentSelectedPoint]->setRegisteredProperty(PointItem::P_POSX, event->pos().x());
+ points[m_indexOfCurrentSelectedPoint]->setRegisteredProperty(PointItem::P_POSY, event->pos().y());
+ }
+ } else if (!m_item->getRegisteredProperty(PolygonItem::P_DRAWINGMODE).toBool()) {
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ QGraphicsItem::mouseMoveEvent(event);
+ }
+}
+
+void PolygonView::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ m_changeCornerMode = false;
+ setCursor(Qt::ArrowCursor);
+ QGraphicsItem::mouseReleaseEvent(event);
+}
+
+void PolygonView::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
+ if(getFirstPoint().contains(event->pos())) {
+ m_mouseIsOverFirstPoint = true;
+ }
+ else {
+ m_mouseIsOverFirstPoint = false;
+ }
+ QGraphicsItem::hoverMoveEvent(event);
+}
+
+void PolygonView::setInclude()
+{
+ m_item->setRegisteredProperty(PolygonItem::P_COLOR, 0);
+}
+
+QRectF PolygonView::getFirstPoint() const
+{
+ QList<ParameterizedItem *> points = m_item->childItems();
+ return QRectF(points[0]->getRegisteredProperty(PointItem::P_POSX).toReal() - 2.5,
+ points[0]->getRegisteredProperty(PointItem::P_POSY).toReal() - 2.5, 5, 5);
+}
+
+QPointF PolygonView::getLastPoint() const
+{
+ QList<ParameterizedItem *> points = m_item->childItems();
+ int indexOfLastPoint = points.length() - 1;
+ return QPointF(points[indexOfLastPoint]->getRegisteredProperty(PointItem::P_POSX).toReal(),
+ points[indexOfLastPoint]->getRegisteredProperty(PointItem::P_POSY).toReal());
+}
+
+ParameterizedItem *PolygonView::getParameterizedItem()
+{
+ return m_item;
+}
+
+void PolygonView::setParameterizedItem(ParameterizedItem *item)
+{
+ m_item = item;
+ disconnect(this, SIGNAL(xChanged()), this, SLOT(onChangedX()));
+ disconnect(this, SIGNAL(yChanged()), this, SLOT(onChangedY()));
+ connect(m_item, SIGNAL(propertyChanged(QString)), this, SLOT(onPropertyChange(QString)));
+}
+
+void PolygonView::setExclude()
+{
+ m_item->setRegisteredProperty(PolygonItem::P_COLOR, 1);
+}
diff --git a/GUI/coregui/Views/MaskWidgets/PolygonView.h b/GUI/coregui/Views/MaskWidgets/PolygonView.h
new file mode 100644
index 0000000000000000000000000000000000000000..a3a1837f8e343c83802e323c9085b308f230bea2
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/PolygonView.h
@@ -0,0 +1,85 @@
+#ifndef POLYGONVIEW_H
+#define POLYGONVIEW_H
+
+#include "IView.h"
+
+class PolygonItem;
+class QPainter;
+class QGraphicsSceneMouseEvent;
+
+class PolygonView : public IView
+{
+ Q_OBJECT
+
+public:
+ PolygonView();
+
+ //! Type of this item
+ enum { Type = UserType + 3 };
+
+ //! boundingbox of this item
+ QRectF boundingRect() const;
+
+ //! returns the type of this item
+ //! @return number of type
+ int type() const
+ {
+ return Type;
+ }
+
+ //! polygon including an area and it's color is changing to red
+ void setExclude();
+
+ //! polygon is excluding an area and it's color is changing to blue
+ void setInclude();
+
+ //! get current polygon item
+ //! @return polygon item as parameterized item
+ ParameterizedItem *getParameterizedItem();
+
+ //! get current polygon item
+ //! @return polygon item as parameterized item
+ void setParameterizedItem(ParameterizedItem *item);
+
+protected:
+ //! manages mouse press events
+ //! @param event from scene
+ void mousePressEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages mouse move events
+ //! @param event from scene
+ void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages hover events
+ //! @param event from scene
+ void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages hover events
+ //! @param event from scene
+ void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
+
+private:
+ bool m_changeCornerMode; //!< shows if someone is going to change the points from polygon
+ int m_indexOfCurrentSelectedPoint; //!< index from current current selected point
+ bool m_mouseIsOverFirstPoint; //!< shows if mouse is over the first point
+ ParameterizedItem *m_item; //!< polygon item
+
+ //! first point as rectangle
+ //! @return first point
+ QRectF getFirstPoint() const;
+
+ //! last point from polygon
+ //! @return last added point
+ QPointF getLastPoint() const;
+
+ //! verifies if any of the points from polygon is clicked
+ //! @return true if a point is selected else false
+ bool isCornerClicked(QGraphicsSceneMouseEvent *event);
+
+ //! calculates the bounding box of the polygon by looking for the smallest and biggest values.
+ QRectF calculateBoundingRectangle() const;
+
+ //! paints polygon
+ void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *);
+};
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/RectangleView.cpp b/GUI/coregui/Views/MaskWidgets/RectangleView.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1fc260bb1e17863192164ec37645d50f3121dd05
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/RectangleView.cpp
@@ -0,0 +1,405 @@
+#include "RectangleView.h"
+#include "RectangleItem.h"
+#include "ParameterizedItem.h"
+#include "DesignerHelper.h"
+#include "RotationArrow.h"
+#include "ResizeArrow.h"
+#include <QPainterPath>
+#include <QPainter>
+#include <QGraphicsSceneMouseEvent>
+#include <QDebug>
+#include <cmath>
+#include <QCursor>
+
+static const qreal widthAndHeight = 5;
+static const qreal OffsetPosition = 2.5;
+
+
+RectangleView::RectangleView() :
+ m_diagonalOpposedPoint(new QPointF)
+{
+ setFlag(QGraphicsItem::ItemIsSelectable);
+ setFlag(QGraphicsItem::ItemIsMovable);
+ setAcceptHoverEvents(true);
+ connect(this, SIGNAL(xChanged()), this, SLOT(onChangedX()));
+ connect(this, SIGNAL(yChanged()), this, SLOT(onChangedY()));
+}
+
+void RectangleView::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+{
+ // paint rectangle
+ painter->setRenderHints(QPainter::Antialiasing);
+ prepareGeometryChange();
+
+ QRectF rectangle(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal(),
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal(),
+ m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal(),
+ m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal());
+ QBrush brush;
+ brush.setStyle(Qt::SolidPattern);
+
+ // change color
+ if (m_item->getRegisteredProperty(RectangleItem::P_COLOR).toInt() == 0) {
+ brush.setColor(DesignerHelper::getDefaultColor("Transparant red"));
+ painter->setPen(brush.color().darker());
+ painter->setBrush(brush);
+ painter->drawRect(rectangle);
+
+ } else {
+ brush.setColor(DesignerHelper::getDefaultColor("Transparant blue"));
+ painter->setPen(brush.color().darker());
+ painter->setBrush(brush);
+ painter->drawRect(rectangle);
+ }
+
+ // paint rectangles on corners if this item is selected
+ if (this->isSelected()) {
+ painter->setBrush(painter->pen().color());
+ painter->drawRect(getTopLeftCorner());
+ painter->drawRect(getBottomLeftCorner());
+ painter->drawRect(getTopRightCorner());
+ painter->drawRect(getBottomRightCorner());
+ }
+
+ updateArrows();
+}
+
+QRectF RectangleView::boundingRect() const
+{
+ return QRectF(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal() -5,
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal() -5,
+ m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() + 10,
+ m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() + 10);
+}
+
+void RectangleView::setDiagonalOpposedPoint()
+{
+ if (m_corner == TOPLEFT) {
+ m_diagonalOpposedPoint->setX(getBottomRightCorner().x());
+ m_diagonalOpposedPoint->setY(getBottomRightCorner().x());
+ } else if (m_corner == TOPRIGHT) {
+ m_diagonalOpposedPoint->setX(getBottomLeftCorner().x());
+ m_diagonalOpposedPoint->setY(getBottomLeftCorner().y());
+ } else if (m_corner == BOTTOMLEFT) {
+ m_diagonalOpposedPoint->setX(getTopRightCorner().x());
+ m_diagonalOpposedPoint->setY(getTopRightCorner().y());
+ } else if (m_corner == BOTTOMRIGHT) {
+ m_diagonalOpposedPoint->setX(getTopLeftCorner().x());
+ m_diagonalOpposedPoint->setY(getTopLeftCorner().y());
+ }
+}
+
+void RectangleView::calculateResize(QGraphicsSceneMouseEvent *event)
+{
+ qreal xmin = std::min(event->pos().x(),m_diagonalOpposedPoint->x());
+ qreal xmax = std::max(event->pos().x(),m_diagonalOpposedPoint->x());
+ qreal ymin = std::min(event->pos().y(),m_diagonalOpposedPoint->y());
+ qreal ymax = std::max(event->pos().y(),m_diagonalOpposedPoint->y());
+
+ m_item->setRegisteredProperty(RectangleItem::P_WIDTH, xmax - xmin);
+ m_item->setRegisteredProperty(RectangleItem::P_HEIGHT, ymax - ymin);
+
+ m_item->setRegisteredProperty(RectangleItem::P_POSX, xmin);
+ m_item->setRegisteredProperty(RectangleItem::P_POSY, ymin);
+}
+
+qreal RectangleView::getRotationAngle(QGraphicsSceneMouseEvent *event)
+{
+ QPointF middlePoint
+ = mapToScene(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() / 2,
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() / 2);
+ qreal lengthOfHypotenuse
+ = sqrt(pow(m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() / 2, 2)
+ + pow(m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() / 2, 2));
+ qreal offsetAngle = acos((m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() / 2)
+ / lengthOfHypotenuse) * 180 / M_PI;
+ qreal radians = atan((event->scenePos().y() - middlePoint.y())
+ / (event->scenePos().x() - middlePoint.x()));
+
+ if (m_corner == TOPLEFT) {
+ m_item->setRegisteredProperty(RectangleItem::P_ANGLE, radians * 180 / M_PI - offsetAngle);
+ return radians * 180 / M_PI - offsetAngle;
+
+ } else if (m_corner == TOPRIGHT) {
+ m_item->setRegisteredProperty(RectangleItem::P_ANGLE, radians * 180 / M_PI + offsetAngle - 180);
+ return radians * 180 / M_PI + offsetAngle - 180;
+
+ } else if (m_corner == BOTTOMLEFT) {
+ m_item->setRegisteredProperty(RectangleItem::P_ANGLE, radians * 180 / M_PI + offsetAngle - 180);
+ return radians * 180 / M_PI + offsetAngle - 180;
+
+ } else if (m_corner == BOTTOMRIGHT) {
+ m_item->setRegisteredProperty(RectangleItem::P_ANGLE, radians * 180 / M_PI - offsetAngle);
+ return radians * 180 / M_PI - offsetAngle;
+ }
+ return 0.0;
+}
+
+void RectangleView::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+
+ if (event->button() == Qt::LeftButton) {
+ setSelectedCorner(event->pos());
+
+ if (m_corner == NONE) {
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ m_block_mode = false;
+ QGraphicsItem::mousePressEvent(event);
+ }
+ else {
+ setDiagonalOpposedPoint();
+ }
+ }
+
+}
+
+void RectangleView::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+ // check which mode is active and process with the active mode
+ if (m_mode == RESIZE && m_corner != NONE) {
+ calculateResize(event);
+ m_block_mode = true;
+ } else if (m_corner != NONE && m_mode == ROTATION) {
+ QTransform transform;
+ transform.translate(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() * 0.5,
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() * 0.5);
+ transform.rotate(getRotationAngle(event));
+ transform.translate(-(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() * 0.5),
+ -(m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() * 0.5));
+ setTransform(transform);
+ m_block_mode = true;
+
+// process as usual
+ } else {
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ m_block_mode = false;
+ QGraphicsItem::mouseMoveEvent(event);
+ }
+}
+
+void RectangleView::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+ if(!m_block_mode && m_corner == NONE) {
+ if ((m_mode == RESIZE)) {
+ m_mode = ROTATION;
+ } else if ((m_mode == ROTATION)) {
+ m_mode = RESIZE;
+ }
+ }
+ m_block_mode = false;
+ m_corner = NONE;
+ setCursor(Qt::ArrowCursor);
+ QGraphicsItem::mouseReleaseEvent(event);
+}
+
+void RectangleView::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
+{
+ setSelectedCorner(event->pos());
+ m_corner = NONE;
+}
+
+void RectangleView::setInclude()
+{
+ m_item->setRegisteredProperty(RectangleItem::P_COLOR, 0);
+}
+
+void RectangleView::setExclude()
+{
+ m_item->setRegisteredProperty(RectangleItem::P_COLOR, 1);
+}
+
+
+QRectF RectangleView::getTopLeftCorner()
+{
+ return QRectF(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal() - OffsetPosition,
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal() - OffsetPosition,
+ widthAndHeight, widthAndHeight);
+}
+
+QRectF RectangleView::getTopRightCorner()
+{
+ return QRectF(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() - OffsetPosition,
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal() - OffsetPosition,
+ widthAndHeight, widthAndHeight);
+}
+
+QRectF RectangleView::getBottomLeftCorner()
+{
+ return QRectF(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal() - OffsetPosition,
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() - OffsetPosition,
+ widthAndHeight, widthAndHeight);
+}
+
+QRectF RectangleView::getBottomRightCorner()
+{
+ return QRectF(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() - OffsetPosition,
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() - OffsetPosition,
+ widthAndHeight, widthAndHeight);
+}
+
+void RectangleView::setParameterizedItem(ParameterizedItem *item)
+{
+ m_item = item;
+ setRotation(m_item->getRegisteredProperty(RectangleItem::P_ANGLE).toReal());
+ connect(m_item, SIGNAL(propertyChanged(const QString &)), this,
+ SLOT(onPropertyChange(const QString &)));
+ initializeArrows();
+}
+
+void RectangleView::onChangedX()
+{
+ m_block_mode = true;
+}
+
+void RectangleView::onChangedY()
+{
+ m_block_mode = true;
+}
+
+void RectangleView::onPropertyChange(const QString &propertyName)
+{
+ if(propertyName == RectangleItem::P_POSX) {
+ m_block_mode = true;
+ }
+ else if(propertyName == RectangleItem::P_POSY) {
+ m_block_mode = true;
+ }
+ else if(propertyName == RectangleItem::P_ANGLE) {
+ QTransform transform;
+ transform.translate(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() * 0.5,
+ m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() * 0.5);
+ transform.rotate(m_item->getRegisteredProperty(RectangleItem::P_ANGLE).toReal());
+ transform.translate(-(m_item->getRegisteredProperty(RectangleItem::P_POSX).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_WIDTH).toReal() * 0.5),
+ -(m_item->getRegisteredProperty(RectangleItem::P_POSY).toReal()
+ + m_item->getRegisteredProperty(RectangleItem::P_HEIGHT).toReal() * 0.5));
+ setTransform(transform);
+ }
+}
+
+ParameterizedItem *RectangleView::getParameterizedItem()
+{
+ return m_item;
+}
+
+void RectangleView::setSelectedCorner(QPointF currentMousePosition)
+{
+ if (getTopLeftCorner().contains(currentMousePosition)) {
+ qDebug() << "TOPLEFT";
+ m_corner = TOPLEFT;
+ if(m_mode == RESIZE)
+ setCursor(Qt::SizeFDiagCursor);
+ } else if (getTopRightCorner().contains(currentMousePosition)) {
+ qDebug() << "TOPRIGHT";
+ m_corner = TOPRIGHT;
+ if(m_mode == RESIZE)
+ setCursor(Qt::SizeBDiagCursor);
+ } else if (getBottomLeftCorner().contains(currentMousePosition)) {
+ qDebug() << "BOTTOMLEFT";
+ m_corner = BOTTOMLEFT;
+ if(m_mode == RESIZE)
+ setCursor(Qt::SizeBDiagCursor);
+ } else if (getBottomRightCorner().contains(currentMousePosition)) {
+ qDebug() << "BOTTOMRIGHT";
+ m_corner = BOTTOMRIGHT;
+ if(m_mode == RESIZE)
+ setCursor(Qt::SizeFDiagCursor);
+ } else {
+ m_corner = NONE;
+ setCursor(QCursor());
+ }
+
+ if (m_mode == ROTATION && m_corner != NONE) {
+ setCursor(QCursor(QPixmap(":/images/rotationArrow.png")));
+ }
+}
+
+void RectangleView::updateArrows()
+{
+ // 0 - 3 are rotation arrows
+ childItems()[0]->setPos(getTopLeftCorner().x(), getTopLeftCorner().y());
+ childItems()[1]->setPos(getTopRightCorner().x(), getTopRightCorner().y());
+ childItems()[2]->setPos(getBottomLeftCorner().x(), getBottomLeftCorner().y());
+ childItems()[3]->setPos(getBottomRightCorner().x(), getBottomRightCorner().y());
+
+ // 4 - 7 are resize arrows
+ childItems()[4]->setPos(getTopLeftCorner().x(), getTopLeftCorner().y());
+ childItems()[5]->setPos(getTopRightCorner().x(), getTopRightCorner().y());
+ childItems()[6]->setPos(getBottomLeftCorner().x(), getBottomLeftCorner().y());
+ childItems()[7]->setPos(getBottomRightCorner().x(), getBottomRightCorner().y());
+
+
+ if(isSelected() == false) {
+ for(int i = 0; i < childItems().length(); ++i) {
+ childItems()[i]->setVisible(false);
+ }
+
+ }
+ else if(m_mode == RESIZE) {
+ for(int i = 0; i < childItems().length(); ++i) {
+ if(i < 4) {
+ childItems()[i]->setVisible(false);
+ }
+ else {
+ childItems()[i]->setVisible(true);
+ }
+ }
+ } else if(m_mode == ROTATION) {
+ for(int i = 0; i < childItems().length(); ++i) {
+ if(i < 4) {
+ childItems()[i]->setVisible(true);
+ }
+ else {
+ childItems()[i]->setVisible(false);
+ }
+ }
+ }
+}
+
+void RectangleView::initializeArrows()
+{
+ RotationArrow *topLeftRotationArrow = new RotationArrow(this);
+ RotationArrow *topRightRotationArrow = new RotationArrow(this);
+ RotationArrow *bottomLeftRotationArrow = new RotationArrow(this);
+ RotationArrow *bottomRightRotationArrow = new RotationArrow(this);
+
+ ResizeArrow *topLeftResizeArrow = new ResizeArrow(this);
+ ResizeArrow *topRightResizeArrow = new ResizeArrow(this);
+ ResizeArrow *bottomLeftResizeArrow = new ResizeArrow(this);
+ ResizeArrow *bottomRightResizeArrow = new ResizeArrow(this);
+
+
+ topRightRotationArrow->setRotation(90);
+ bottomLeftRotationArrow->setRotation(270);
+ bottomRightRotationArrow->setRotation(180);
+
+ topRightResizeArrow->setRotation(90);
+ bottomLeftResizeArrow->setRotation(270);
+ bottomRightResizeArrow->setRotation(180);
+
+ topRightRotationArrow->setVisible(false);
+ topLeftRotationArrow->setVisible(false);
+ bottomLeftRotationArrow->setVisible(false);
+ bottomRightRotationArrow->setVisible(false);
+
+ topRightResizeArrow->setVisible(false);
+ topLeftResizeArrow->setVisible(false);
+ bottomLeftResizeArrow->setVisible(false);
+ bottomRightResizeArrow->setVisible(false);
+}
+
+
+
diff --git a/GUI/coregui/Views/MaskWidgets/RectangleView.h b/GUI/coregui/Views/MaskWidgets/RectangleView.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdb662d2c57849259c4f8aa3e89715bbd3828ac5
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/RectangleView.h
@@ -0,0 +1,129 @@
+#ifndef RECTANGLEVIEW_H
+#define RECTANGLEVIEW_H
+
+#include "IView.h"
+
+class QPainter;
+class ParameterizedItem;
+class QGraphicsSceneMouseEvent;
+class QPointF;
+
+class RectangleView : public IView
+{
+ Q_OBJECT
+
+public:
+ RectangleView();
+
+ //! describes the corners
+ enum Corner { NONE, TOPLEFT, TOPRIGHT, BOTTOMLEFT, BOTTOMRIGHT };
+
+ //! current active mode
+ enum Mode { ROTATION, RESIZE };
+
+ //! Type of this item
+ enum { Type = UserType + 1 };
+
+ //! boundingbox of this item
+ QRectF boundingRect() const;
+
+ //! returns the type of this item
+ //! @return number of type
+ int type() const
+ {
+ return Type;
+ }
+
+ //! rectangle is including an area and it's color is changing to red
+ void setInclude();
+
+ //! rectangle is excluding an area and it's color is changing to blue
+ void setExclude();
+
+ //! get current rectangle item
+ //! @return rectangle item as parameterized item
+ ParameterizedItem *getParameterizedItem();
+
+ //! set rectangle item
+ //! @param rectangle item to be drawn
+ void setParameterizedItem(ParameterizedItem *item);
+
+public slots:
+ //! called when x-value changed
+ void onChangedX();
+
+ //! called when x-value changed
+ void onChangedY();
+
+ //! called when property of rectangle changed
+ void onPropertyChange(const QString &propertyName);
+
+protected:
+ //! paintEvent paints Rectangle and corners
+ void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *);
+
+ //! manages mouse press events
+ //! @param event from scene
+ void mousePressEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages mouse move events
+ //! @param event from scene
+ void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages mouse release events
+ //! @param event from scene
+ void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+
+ //! manages hover events
+ //! @param event from scene
+ void hoverMoveEvent(QGraphicsSceneHoverEvent *event);
+
+private:
+ ParameterizedItem *m_item; //!< rectangle item
+ Corner m_corner; //!< enum with all corners
+ Mode m_mode; //!< current active mode
+ bool m_block_mode; //!< blocking modes from changing
+ QPointF *m_diagonalOpposedPoint; //!< diagonally opposite point from current selected corner
+
+ //! set diagonally opposite point from current selected corner
+ void setDiagonalOpposedPoint();
+
+ //! @return diagonally opposite point from current selected corner
+ QPointF getDiagonalOpposedPoint();
+
+ //! calculates resized rectangle
+ //! @param event to receive current mouse position
+ void calculateResize(QGraphicsSceneMouseEvent *event);
+
+ //! calculates angle for rotation
+ //! @return angle between selected corner and mouse
+ //! @param event to receive current mouse position
+ qreal getRotationAngle(QGraphicsSceneMouseEvent *event);
+
+ //! verfies clicked corner
+ //! @param current mouse position
+ void setSelectedCorner(QPointF currentMousePosition);
+
+ //! updates all arrows;
+ void updateArrows();
+
+ //! initialize all arrows
+ void initializeArrows();
+
+ //! returns corner of rectangle
+ //! @return top left corner
+ QRectF getTopLeftCorner();
+
+ //! returns corner of rectangle
+ //! @return top right corner
+ QRectF getTopRightCorner();
+
+ //! returns corner of rectangle
+ //! @return bottom left corner
+ QRectF getBottomLeftCorner();
+
+ //! returns corner of rectangle
+ //! @return bottom right corner
+ QRectF getBottomRightCorner();
+};
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/ResizeArrow.cpp b/GUI/coregui/Views/MaskWidgets/ResizeArrow.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..45d89d9a5a4b57df62b06be0dc88ed3eb6cbf840
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/ResizeArrow.cpp
@@ -0,0 +1,42 @@
+#include "ResizeArrow.h"
+#include <QPainter>
+
+
+ResizeArrow::ResizeArrow(QGraphicsItem *parent)
+{
+ this->setParentItem(parent);
+}
+
+QRectF ResizeArrow::boundingRect() const
+{
+ return QRect(-25,-25,20,20);
+}
+
+
+void ResizeArrow::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+{
+ painter->setRenderHints(QPainter::Antialiasing);
+ prepareGeometryChange();
+
+ QPainterPath upperArrowHead;
+ upperArrowHead.moveTo(-20, -20);
+ upperArrowHead.lineTo(-17.5, -12.5);
+ upperArrowHead.lineTo(-12.5, -17.5);
+ upperArrowHead.lineTo(-20, -20);
+ painter->fillPath(upperArrowHead, Qt::black);
+
+ QPainterPath lowerArrowHead;
+ lowerArrowHead.moveTo(-7.5, -7.5);
+ lowerArrowHead.lineTo(-10, -15);
+ lowerArrowHead.lineTo(-15, -10);
+ lowerArrowHead.lineTo(-7.5, -7.5);
+ painter->fillPath(lowerArrowHead, Qt::black);
+
+ QPen pen;
+ pen.setWidth(2);
+ painter->setPen(pen);
+ painter->drawLine(QPointF(-17.5, -17.5), QPointF(-10,-10));
+
+
+
+}
diff --git a/GUI/coregui/Views/MaskWidgets/ResizeArrow.h b/GUI/coregui/Views/MaskWidgets/ResizeArrow.h
new file mode 100644
index 0000000000000000000000000000000000000000..42bb2bab4325674b800923d1d3ceee54a0b6c5db
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/ResizeArrow.h
@@ -0,0 +1,22 @@
+#ifndef RESIZEARROW_H
+#define RESIZEARROW_H
+
+#include <QGraphicsItem>
+
+class ResizeArrow : public QGraphicsItem
+{
+public:
+ ResizeArrow(QGraphicsItem *parent = 0);
+
+ //! bounding box of rectangle
+ QRectF boundingRect() const;
+
+protected:
+ //! paintEvent paints Rectangle and corners
+ void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *);
+};
+
+
+
+
+#endif
diff --git a/GUI/coregui/Views/MaskWidgets/RotationArrow.cpp b/GUI/coregui/Views/MaskWidgets/RotationArrow.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f0317755df4747203e0390efebf794d80059999e
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/RotationArrow.cpp
@@ -0,0 +1,44 @@
+#include "RotationArrow.h"
+#include <QPainter>
+
+
+RotationArrow::RotationArrow(QGraphicsItem *parent)
+{
+ this->setParentItem(parent);
+}
+
+QRectF RotationArrow::boundingRect() const
+{
+ return QRect(-25,-25,15,15);
+}
+
+
+void RotationArrow::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+{
+ painter->setRenderHints(QPainter::Antialiasing);
+ prepareGeometryChange();
+ QPen pen;
+
+ QPainterPath lineBetweenArrowHeads;
+ lineBetweenArrowHeads.arcMoveTo(-20,-20,10,10,90);
+ lineBetweenArrowHeads.arcTo(-20,-20,10,10,90, 90);
+ pen.setWidth(2);
+ painter->setPen(pen);
+ painter->drawPath(lineBetweenArrowHeads);
+ pen.setWidth(1);
+ painter->setPen(pen);
+
+
+ QPainterPath upperArrowHead;
+ upperArrowHead.moveTo(-15, -25);
+ upperArrowHead.lineTo(-15, -15);
+ upperArrowHead.lineTo(-10, -20);
+ painter->fillPath(upperArrowHead, Qt::black);
+
+ QPainterPath lowerArrowHead;
+ lowerArrowHead.moveTo(-25, -15);
+ lowerArrowHead.lineTo(-15, -15);
+ lowerArrowHead.lineTo(-20, -10);
+ painter->fillPath(lowerArrowHead, Qt::black);
+
+}
diff --git a/GUI/coregui/Views/MaskWidgets/RotationArrow.h b/GUI/coregui/Views/MaskWidgets/RotationArrow.h
new file mode 100644
index 0000000000000000000000000000000000000000..1b62dd4790de5bc208b899d26c4ba7cfebd9fe62
--- /dev/null
+++ b/GUI/coregui/Views/MaskWidgets/RotationArrow.h
@@ -0,0 +1,22 @@
+#ifndef ROTATIONARROW_H
+#define ROTATIONARROW_H
+
+#include <QGraphicsItem>
+
+class RotationArrow : public QGraphicsItem
+{
+public:
+ RotationArrow(QGraphicsItem *parent = 0);
+
+ //! bounding box of rectangle
+ QRectF boundingRect() const;
+
+protected:
+ //! paintEvent paints Rectangle and corners
+ void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *);
+};
+
+
+
+
+#endif
diff --git a/GUI/coregui/Views/Rectangle.cpp b/GUI/coregui/Views/Rectangle.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..58acf5497eeee189200a8c20e605ece43d40de09
--- /dev/null
+++ b/GUI/coregui/Views/Rectangle.cpp
@@ -0,0 +1,272 @@
+
+#include "Rectangle.h"
+#include <iostream>
+#include <cmath>
+
+Rectangle::Rectangle(qreal posX, qreal posY, qreal width, qreal heigth)
+ : m_posX(posX), m_posY(posY), m_width(width), m_heigth(heigth),
+ m_topLeftCorner(QRectF (m_posX - 5, m_posY - 5, 10, 10)),
+ m_bottomLeftCorner(QRectF (m_posX + m_width - 5, m_posY - 5, 10, 10)),
+ m_topRightCorner(QRectF (m_posX + m_width - 5, m_posY - 5, 10, 10)),
+ m_bottomRightCorner(QRectF (m_posX + m_width - 5, m_posY + m_heigth - 5, 10, 10)),
+ m_resizeMode(false), m_rotationMode(false)
+{
+ this->setFlag(QGraphicsItem::ItemIsSelectable);
+ this->setFlag(QGraphicsItem::ItemIsMovable);
+}
+
+void Rectangle::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
+{
+
+ // paint rectangle
+ painter->setRenderHints(QPainter::Antialiasing);
+ this->prepareGeometryChange();
+ if(m_color == INCLUDE) {
+ QBrush transRed(QColor(0xFF, 0, 0, 0x80));
+ painter->fillRect(m_posX, m_posY, m_width, m_heigth,transRed);
+ }
+ else {
+ QBrush transBlue(QColor(0, 0, 0xFF, 0x80));
+ painter->fillRect(m_posX, m_posY, m_width, m_heigth,transBlue);
+ }
+
+ // paint corner rectangles only if this item is selected
+ if (this->isSelected()) {
+
+ // set values for corners
+ m_topLeftCorner.setRect(m_posX - 5, m_posY - 5, 10, 10);
+ m_bottomLeftCorner.setRect(m_posX - 5, m_posY + m_heigth - 5, 10, 10);
+ m_topRightCorner.setRect(m_posX + m_width - 5, m_posY - 5, 10, 10);
+ m_bottomRightCorner.setRect(m_posX + m_width - 5, m_posY + m_heigth - 5, 10, 10);
+
+ painter->setBrush(Qt::green);
+ painter->drawRect(m_topLeftCorner);
+ painter->drawRect(m_topRightCorner);
+ painter->drawRect(m_bottomLeftCorner);
+ painter->drawRect(m_bottomRightCorner);
+ }
+}
+
+QRectF Rectangle::boundingRect() const
+{
+ return QRectF(m_posX - 10, m_posY - 10, m_width + 20, m_heigth + 20);
+}
+
+void Rectangle::checkResizeRules(QGraphicsSceneMouseEvent *event)
+{
+ if (m_corner == TOPLEFT) {
+ if (m_posX + m_width <= event->pos().x()) {
+ m_corner = TOPRIGHT;
+ setCursor(Qt::SizeBDiagCursor);
+
+ } else if (m_posY + m_heigth <= event->pos().y()) {
+ m_corner = BOTTOMLEFT;
+ setCursor(Qt::SizeBDiagCursor);
+ }
+ } else if (m_corner == TOPRIGHT) {
+ if (event->pos().x() <= m_posX) {
+ m_corner = TOPLEFT;
+ setCursor(Qt::SizeFDiagCursor);
+
+ } else if (m_posY + m_heigth <= event->pos().y()) {
+ m_corner = BOTTOMRIGHT;
+ setCursor(Qt::SizeFDiagCursor);
+ }
+ } else if (m_corner == BOTTOMLEFT) {
+ if (m_posX + m_width <= event->pos().x()) {
+ m_corner = BOTTOMRIGHT;
+ setCursor(Qt::SizeFDiagCursor);
+
+ } else if (event->pos().y() <= m_posY) {
+ m_corner = TOPLEFT;
+ setCursor(Qt::SizeFDiagCursor);
+ }
+ } else if (m_corner == BOTTOMRIGHT) {
+ if (event->pos().x() <= m_posX) {
+ m_corner = BOTTOMLEFT;
+ setCursor(Qt::SizeBDiagCursor);
+
+ } else if (event->pos().y() <= m_posY) {
+ m_corner = TOPRIGHT;
+ setCursor(Qt::SizeBDiagCursor);
+ }
+ }
+}
+
+void Rectangle::calculateResize(QGraphicsSceneMouseEvent *event)
+{
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+ checkResizeRules(event);
+
+ if (m_corner == TOPLEFT) {
+ m_width = m_posX + m_width - event->pos().x();
+ m_heigth = m_posY + m_heigth - event->pos().y();
+ m_posX = event->pos().x();
+ m_posY = event->pos().y();
+
+ } else if (m_corner == BOTTOMLEFT) {
+ m_width = m_posX + m_width - event->pos().x();
+ m_heigth = event->pos().y() - m_posY;
+ m_posX = event->pos().x();
+
+ } else if (m_corner == TOPRIGHT) {
+ m_width = event->pos().x() - m_posX;
+ m_heigth = m_posY + m_heigth - event->pos().y();
+ m_posY = event->pos().y();
+ }
+
+ else if (m_corner == BOTTOMRIGHT) {
+ m_width = event->pos().x() - m_posX;
+ m_heigth = event->pos().y() - m_posY;
+ }
+}
+
+qreal Rectangle::calculateRotation(QGraphicsSceneMouseEvent *event)
+{
+ qreal lengthOfHypotenuse = sqrt(pow(m_width / 2, 2) + pow(m_heigth / 2, 2));
+ qreal offsetAngle = acos((m_width / 2) / lengthOfHypotenuse) * 180 / M_PI;
+ qreal radians = atan(
+ (event->scenePos().y() - this->mapToScene(m_posX + m_width / 2, m_posY + m_heigth / 2).y())
+ / (event->scenePos().x()
+ - this->mapToScene(m_posX + m_width / 2, m_posY + m_heigth / 2).x()));
+
+ if (m_corner == TOPLEFT) {
+ return radians * 180 / M_PI - offsetAngle;
+
+ } else if (m_corner == TOPRIGHT) {
+ return radians * 180 / M_PI + offsetAngle - 180;
+
+ } else if (m_corner == BOTTOMLEFT) {
+ return radians * 180 / M_PI + offsetAngle - 180;
+
+ } else if (m_corner == BOTTOMRIGHT) {
+ return radians * 180 / M_PI - offsetAngle;
+ }
+ return 0;
+}
+
+void Rectangle::setWidth(qreal width)
+{
+ m_width = width;
+}
+
+void Rectangle::setHeigth(qreal heigth)
+{
+ m_heigth = heigth;
+}
+
+void Rectangle::mousePressEvent(QGraphicsSceneMouseEvent *event)
+{
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+
+ //if one of the corners is clicked then go in to resize Mode
+ if (event->button() == Qt::LeftButton && m_topLeftCorner.contains(event->pos())) {
+ m_resizeMode = true;
+ m_corner = TOPLEFT;
+ setCursor(Qt::SizeFDiagCursor);
+
+ } else if (event->button() == Qt::LeftButton && m_bottomLeftCorner.contains(event->pos())) {
+ m_resizeMode = true;
+ m_corner = BOTTOMLEFT;
+ setCursor(Qt::SizeBDiagCursor);
+
+ } else if (event->button() == Qt::LeftButton && m_topRightCorner.contains(event->pos())) {
+ m_resizeMode = true;
+ m_corner = TOPRIGHT;
+ setCursor(Qt::SizeBDiagCursor);
+ }
+
+ else if (event->button() == Qt::LeftButton && m_bottomRightCorner.contains(event->pos())) {
+ m_resizeMode = true;
+ m_corner = BOTTOMRIGHT;
+ setCursor(Qt::SizeFDiagCursor);
+
+ // process as usual
+ } else {
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ QGraphicsItem::mousePressEvent(event);
+ }
+}
+
+void Rectangle::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
+{
+ //check which mode is active and process with the active mode
+ if (m_corner != NONE && m_resizeMode) {
+ calculateResize(event);
+
+ } else if (m_corner != NONE && m_rotationMode) {
+ QTransform transform;
+ transform.translate(m_posX + m_width * 0.5, m_posY + m_heigth * 0.5);
+ transform.rotate(calculateRotation(event));
+ transform.translate(-(m_posX + m_width * 0.5), -(m_posY + m_heigth * 0.5));
+ setTransform(transform);
+
+ // process as usual
+ } else {
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ QGraphicsItem::mouseMoveEvent(event);
+ }
+}
+
+void Rectangle::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
+{
+ // set all modes off, change cursor and process as usual
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ m_resizeMode = false;
+ m_rotationMode = false;
+ setCursor(Qt::ArrowCursor);
+ QGraphicsItem::mouseReleaseEvent(event);
+}
+
+void Rectangle::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
+{
+ //activate rotation mode
+ if (event->button() == Qt::LeftButton && m_topLeftCorner.contains(event->pos())) {
+ m_resizeMode = false;
+ m_rotationMode = true;
+ m_corner = TOPLEFT;
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+ setCursor(Qt::ClosedHandCursor);
+
+ } else if (event->button() == Qt::LeftButton && m_bottomLeftCorner.contains(event->pos())) {
+ m_resizeMode = false;
+ m_rotationMode = true;
+ m_corner = BOTTOMLEFT;
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+ setCursor(Qt::ClosedHandCursor);
+
+ } else if (event->button() == Qt::LeftButton && m_topRightCorner.contains(event->pos())) {
+ m_resizeMode = false;
+ m_rotationMode = true;
+ m_corner = TOPRIGHT;
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+ setCursor(Qt::ClosedHandCursor);
+ }
+
+ else if (event->button() == Qt::LeftButton && m_bottomRightCorner.contains(event->pos())) {
+ m_resizeMode = false;
+ m_rotationMode = true;
+ m_corner = BOTTOMRIGHT;
+ this->setFlag(QGraphicsItem::ItemIsMovable, false);
+ setCursor(Qt::ClosedHandCursor);
+
+ } else {
+ m_resizeMode = false;
+ m_rotationMode = false;
+ this->setFlag(QGraphicsItem::ItemIsMovable, true);
+ QGraphicsItem::mouseDoubleClickEvent(event);
+ }
+}
+
+void Rectangle::setInclude()
+{
+ m_color = INCLUDE;
+ update();
+}
+
+void Rectangle::setExclude()
+{
+ m_color = EXCLUDE;
+ update();
+}
+
diff --git a/GUI/coregui/Views/Rectangle.h b/GUI/coregui/Views/Rectangle.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1e2111711e436f779037406a32bb921c6ad2eab
--- /dev/null
+++ b/GUI/coregui/Views/Rectangle.h
@@ -0,0 +1,73 @@
+
+#include <QWidget>
+#include <QGraphicsProxyWidget>
+#include <QGraphicsItem>
+#include <QGraphicsScene>
+#include "DistributionEditor.h"
+#include <QGraphicsView>
+#include <QPainterPath>
+
+#ifndef RECTANGLE_H
+#define RECTANGLE_H
+
+class Rectangle : public QGraphicsItem
+{
+
+public:
+ //! describes corner
+ enum Corner { NONE, TOPLEFT, TOPRIGHT, BOTTOMLEFT, BOTTOMRIGHT };
+ enum {Type = UserType + 1};
+ enum Color {INCLUDE, EXCLUDE};
+
+ //! create Rectangle
+ //! @param posX x position in scene
+ //! @param posY y position in scene
+ //! @param width of rectangle
+ //! @param heigth of rectangle
+ Rectangle(qreal posX, qreal poxY, qreal width, qreal heigth);
+
+ //! bounding box of rectangle
+ QRectF boundingRect() const;
+
+ //! check if resize rules are correct
+ //! @param event mouse event to check if resizes correct
+ void checkResizeRules(QGraphicsSceneMouseEvent *event);
+
+ //! calculates resized rectangle
+ //! @param event mouse event to set new coordinates
+ void calculateResize(QGraphicsSceneMouseEvent *event);
+
+ //! calculates rotated rectangle
+ //! @param event mouse event to set new coordinates
+ //! @return degree of rotation
+ qreal calculateRotation(QGraphicsSceneMouseEvent *event);
+
+ int type() const {return Type;}
+
+ void setHeigth(qreal heigth);
+ void setWidth(qreal width);
+ void setInclude();
+ void setExclude();
+protected:
+ //! paintEvent paints Rectangle and corners
+ void paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *);
+ void mousePressEvent(QGraphicsSceneMouseEvent *event);
+ void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+ void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+ void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
+
+private:
+ qreal m_posX; //!< x position of rectangle
+ qreal m_posY; //!< y position of rectangle
+ qreal m_width; //!< width of rectangle
+ qreal m_heigth; //!< height of rectangle
+ QRectF m_topLeftCorner; //!< rectangle in the top left corner
+ QRectF m_bottomLeftCorner; //!< rectangle in the bottom left corner
+ QRectF m_topRightCorner; //!< rectangle in the top right corner
+ QRectF m_bottomRightCorner; //!< rectangle in the bottom right corner
+ bool m_resizeMode; //!< activates resize mode
+ bool m_rotationMode; //!< activiates rotation mode
+ Corner m_corner; //!< enum with all corners
+ Color m_color; //!< current color
+};
+#endif
diff --git a/GUI/coregui/Views/SampleDesigner/DesignerHelper.cpp b/GUI/coregui/Views/SampleDesigner/DesignerHelper.cpp
index e1c9ff94b56eaf231283ed53d81d0a164027d8bd..2abaf275af2bebe33a33481a4d887abdb8bed67a 100644
--- a/GUI/coregui/Views/SampleDesigner/DesignerHelper.cpp
+++ b/GUI/coregui/Views/SampleDesigner/DesignerHelper.cpp
@@ -185,7 +185,14 @@ QColor DesignerHelper::getDefaultColor(const QString &name)
return QColor(210, 223, 237);
} else if (name.startsWith("InterferenceFunction")) {
return QColor(255, 236, 139);
- } else {
+ }
+ else if(name == "Transparant red") {
+ return QColor(0xFF, 0, 0, 0x80);
+ }
+ else if(name == "Transparant blue") {
+ return QColor(0, 0, 0xFF, 0x80);
+ }
+ else {
return QColor(Qt::lightGray);
}
}
diff --git a/GUI/coregui/Views/SampleDesigner/SampleViewFactory.cpp b/GUI/coregui/Views/SampleDesigner/SampleViewFactory.cpp
index 37f83912107f2ba812ca358ecd74912760a458aa..1b7da53d783434bbbb01a8143b72d7f52c19ac14 100644
--- a/GUI/coregui/Views/SampleDesigner/SampleViewFactory.cpp
+++ b/GUI/coregui/Views/SampleDesigner/SampleViewFactory.cpp
@@ -25,6 +25,9 @@
#include "ParticleDistributionView.h"
#include "InterferenceFunctionViews.h"
#include "GUIHelpers.h"
+#include "RectangleView.h"
+#include "EllipseView.h"
+#include "PolygonView.h"
#include <QDebug>
@@ -39,7 +42,8 @@ QStringList SampleViewFactory::m_valid_item_names = QStringList()
<< Constants::ParticleDistributionType
<< Constants::InterferenceFunctionRadialParaCrystalType
<< Constants::InterferenceFunction2DParaCrystalType
- << Constants::InterferenceFunction2DLatticeType;
+ << Constants::InterferenceFunction2DLatticeType
+ << Constants::RectangleType;
bool SampleViewFactory::isValidItemName(const QString &name)
@@ -87,6 +91,15 @@ IView *SampleViewFactory::createSampleView(const QString &name)
else if (name==Constants::InterferenceFunction2DLatticeType) {
return new InterferenceFunction2DLatticeView();
}
+ else if(name==Constants::RectangleType) {
+ return new RectangleView();
+ }
+ else if(name==Constants::EllipseType) {
+ return new EllipseView();
+ }
+ else if(name==Constants::PolygonType) {
+ return new PolygonView();
+ }
else {
//qDebug() << "SampleViewFactory::createSampleView() -> Error! Can't create a view for" << name;
throw GUIHelpers::Error("SampleViewFactory::createSampleView() -> Error! Can't create a view for " + name);
diff --git a/GUI/coregui/Views/TestView.cpp b/GUI/coregui/Views/TestView.cpp
index 7c7e6944cbf8f45000e685cc7d9e1347292074b6..d44d0553ff875d30017bd56765939d4c46d08b0f 100644
--- a/GUI/coregui/Views/TestView.cpp
+++ b/GUI/coregui/Views/TestView.cpp
@@ -13,6 +13,7 @@
//
// ************************************************************************** //
+
#include "TestView.h"
#include "TestItem.h"
#include "LayerItem.h"
@@ -24,62 +25,93 @@
#include <QDebug>
#include "DistributionEditor.h"
#include "qgroupbox.h"
+#include "MaskEditor.h"
+#include "MaskModel.h"
+#include "RectangleItem.h"
+#include "Rectangle.h"
+
TestView::TestView(QWidget *parent)
: QWidget(parent)
- , m_item(0)
+// , m_item(0)
{
- setMinimumSize(128, 128);
- setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+ setMouseTracking(true);
-// BeamWavelengthItem *item = new BeamWavelengthItem;
-// DistributionEditor *distributionEditor = new DistributionEditor;
-// distributionEditor->setItem(item);
-// m_propertyEditor = new AwesomePropertyEditor(this);
+// QGraphicsScene *scene = new QGraphicsScene;
+// QGraphicsPolygonItem *polygonItem = new QGraphicsPolygonItem(
+// QPolygonF(QVector<QPointF>() << QPointF(10, 10) << QPointF(0, 90) << QPointF(40, 70)
+// << QPointF(80, 110) << QPointF(70, 20)),0);
+// polygonItem->setPen(QPen(Qt::darkGreen));
+// polygonItem->setBrush(Qt::transparent);
+// this->setScene(scene);
+// scene->itemsBoundingRect();
- // main layout
- QVBoxLayout *mainLayout = new QVBoxLayout;
+// DistributionEditor *editor = new DistributionEditor;
+// editor->setItem(new BeamWavelengthItem);
+// editor->resize(800,600);
+// GraphicsProxyWidget *widget = new GraphicsProxyWidget;
+// widget->setWidget(editor);
+// scene->addItem(widget);
-// mainLayout->addWidget(m_propertyEditor);
-// mainLayout->addWidget(distributionEditor);
- setLayout(mainLayout);
-}
+// Rectangle *rectangle = new Rectangle(0,0,200,200);
+// scene->addItem(rectangle);
+// rectangle->setFlag(QGraphicsItem::ItemIsMovable);
+
+
+// polygonItem->setFlag(QGraphicsItem::ItemIsMovable);
+// Ellipse *ellipse = new Ellipse(0,0,100,50);
+// scene->addItem(ellipse);
+// ellipse->setFlag(QGraphicsItem::ItemIsMovable);
-//TestView::TestView(QWidget *parent)
-// : QWidget(parent)
-//{
-// setMinimumSize(128, 128);
-// setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+ MaskModel *maskModel = new MaskModel;
+// ParameterizedItem *rectangle1 = maskModel->insertNewItem(Constants::RectangleType);
+// rectangle1->setRegisteredProperty(RectangleItem::P_WIDTH, 100.0);
+// rectangle1->setRegisteredProperty(RectangleItem::P_HEIGHT, 200.0);
+// rectangle1->setItemName("rect1");
+// ParameterizedItem *rectangle2 = maskModel->insertNewItem(Constants::RectangleType);
+// rectangle2->setRegisteredProperty(RectangleItem::P_WIDTH, 120.0);
+// rectangle2->setRegisteredProperty(RectangleItem::P_HEIGHT, 220.0);
+// rectangle2->setItemName("rect2");
+// ParameterizedItem *rectangle3 = maskModel->insertNewItem(Constants::RectangleType);
+// rectangle3->setRegisteredProperty(RectangleItem::P_WIDTH, 120.0);
+// rectangle3->setRegisteredProperty(RectangleItem::P_HEIGHT, 220.0);
+// rectangle3->setItemName("rect3");
-// QGroupBox *groupBox = new QGroupBox("Beam Parameters");
-// QVBoxLayout *groupLayout = new QVBoxLayout;
-// groupBox->setLayout(groupLayout);
-// // whole content is represented as grid layout
-// QGridLayout *gridLayout = new QGridLayout;
+// QModelIndex itemIndex = maskModel->index(1, 0, QModelIndex());
+// ParameterizedItem *item = maskModel->itemForIndex(itemIndex);
+// maskModel->moveParameterizedItem(item, 0, 3);
-// AwesomePropertyEditor *editor1 = new AwesomePropertyEditor(this);
-// editor1->setMinimumSize(256, 256);
-// AwesomePropertyEditor *editor2 = new AwesomePropertyEditor(this, AwesomePropertyEditor::BROWSER_GROUPBOX_TYPE);
+// for (int i_row = 0; i_row < maskModel->rowCount(QModelIndex()); ++i_row) {
+// QModelIndex itemIndex = maskModel->index(i_row, 0, QModelIndex());
-// TestItem *item1 = new TestItem;
-// LayerItem *layer = new LayerItem();
-// editor1->addItemProperty(layer, LayerItem::P_THICKNESS, "MyGroup");
-// editor1->addItemProperties(item1, "MyGroup");
+// if (ParameterizedItem *item = maskModel->itemForIndex(itemIndex)) {
-//// editor2->addItemProperty(layer, LayerItem::P_THICKNESS, "MyGroup");
-// editor2->addItemProperties(item1, QString(), AwesomePropertyEditor::INSERT_AFTER);
+// qDebug() << i_row << item->itemName();
+// }
-// gridLayout->addWidget(editor1, 0, 0);
-// gridLayout->addWidget(editor2, 0, 1);
-// groupLayout->addLayout(gridLayout);
+// Q_ASSERT(0);
-// // main layout
-// QVBoxLayout *mainLayout = new QVBoxLayout;
-// mainLayout->addWidget(groupBox);
-// setLayout(mainLayout);
+// ParameterizedItem *polygon = maskModel->insertNewItem(Constants::PolygonType);
+// maskModel->insertNewItem(Constants::PointType, maskModel->indexOfItem(polygon));
+// maskModel->save("masks.xml");
-//}
+// Q_ASSERT(0);
+
+ MaskEditor *maskEditor = new MaskEditor;
+ maskEditor->setModel(maskModel);
+
+ QVBoxLayout *mainLayout = new QVBoxLayout;
+ this->setLayout(mainLayout);
+// Rectangle *rectangle = new Rectangle(300,300,100,100);
+// QGraphicsScene *scene = new QGraphicsScene();
+// scene->addItem(rectangle);
+// QGraphicsView *view = new QGraphicsView;
+// view->setScene(scene);
+// scene->setSceneRect(view->rect());
+ mainLayout->addWidget(maskEditor);
+
+}
diff --git a/GUI/coregui/Views/TestView.h b/GUI/coregui/Views/TestView.h
index c41b21b3ab6a716112933820b524c9592fded765..6f3d112cdca7a5e38b82adecaa903444efc22dcc 100644
--- a/GUI/coregui/Views/TestView.h
+++ b/GUI/coregui/Views/TestView.h
@@ -12,12 +12,17 @@
//! @authors C. Durniak, M. Ganeva, G. Pospelov, W. Van Herck, J. Wuttke
//
// ************************************************************************** //
+#include <QWidget>
+#include <QGraphicsProxyWidget>
+#include <QGraphicsItem>
+#include <QGraphicsScene>
+#include "DistributionEditor.h"
+#include <QGraphicsView>
+#include <QPainterPath>
#ifndef TESTVIEW_H
#define TESTVIEW_H
-#include <QWidget>
-
class ParameterizedItem;
class AwesomePropertyEditor;
@@ -25,18 +30,20 @@ class TestView : public QWidget
{
Q_OBJECT
public:
-
TestView(QWidget *parent = 0);
- virtual ~TestView() {}
+ virtual ~TestView()
+ {
+ }
void setItem(ParameterizedItem *item);
void plotItem(ParameterizedItem *item);
private slots:
-// void onPropertyChanged(const QString &property_name);
-// void onSubItemChanged(const QString &property_name);
-// void onSubItemPropertyChanged(const QString &property_group, const QString &property_name);
+ // void onPropertyChanged(const QString &property_name);
+ // void onSubItemChanged(const QString &property_name);
+ // void onSubItemPropertyChanged(const QString &property_group, const QString
+ // &property_name);
private:
AwesomePropertyEditor *m_propertyEditor;
diff --git a/GUI/coregui/coregui.qrc b/GUI/coregui/coregui.qrc
index 655ea71a887c4dc537e765910ece01a2cdd406de..d57ffd30914008b637557dd9a2929d3e2b83fa2d 100644
--- a/GUI/coregui/coregui.qrc
+++ b/GUI/coregui/coregui.qrc
@@ -49,5 +49,15 @@
<file>images/warning.png</file>
<file>images/magnifier.png</file>
<file>images/warning_64x64.png</file>
+ <file>images/rotationArrow.png</file>
+ <file>images/rectangle.png</file>
+ <file>images/mouseCursor.png</file>
+ <file>images/ellipse.png</file>
+ <file>images/polygon.png</file>
+ <file>images/bringToFront.png</file>
+ <file>images/sendToBack.png</file>
+ <file>images/include.png</file>
+ <file>images/exclude.png</file>
+ <file>images/jTxpL5ELc.png</file>
</qresource>
</RCC>
diff --git a/GUI/coregui/images/bringToFront.png b/GUI/coregui/images/bringToFront.png
new file mode 100644
index 0000000000000000000000000000000000000000..41a42cb5f65f28fdf7748cc09157fc046da93436
Binary files /dev/null and b/GUI/coregui/images/bringToFront.png differ
diff --git a/GUI/coregui/images/ellipse.png b/GUI/coregui/images/ellipse.png
new file mode 100644
index 0000000000000000000000000000000000000000..eb66ea086aba79c62dadd45d4632a45b8d70b926
Binary files /dev/null and b/GUI/coregui/images/ellipse.png differ
diff --git a/GUI/coregui/images/exclude.png b/GUI/coregui/images/exclude.png
new file mode 100644
index 0000000000000000000000000000000000000000..67d87b22b24ca85dadb1af211d85401891398512
Binary files /dev/null and b/GUI/coregui/images/exclude.png differ
diff --git a/GUI/coregui/images/image3191.png b/GUI/coregui/images/image3191.png
new file mode 100644
index 0000000000000000000000000000000000000000..4c2ac1ca7dcb29e4ba84927aac4e28f9058cbb2e
Binary files /dev/null and b/GUI/coregui/images/image3191.png differ
diff --git a/GUI/coregui/images/include.png b/GUI/coregui/images/include.png
new file mode 100644
index 0000000000000000000000000000000000000000..53496abe2a50c3e755189f9b5d5e2302c2c0cc00
Binary files /dev/null and b/GUI/coregui/images/include.png differ
diff --git a/GUI/coregui/images/jTxpL5ELc.png b/GUI/coregui/images/jTxpL5ELc.png
new file mode 100644
index 0000000000000000000000000000000000000000..d48e9b70ea471a6fa246c4c27f7e05e446e51e12
Binary files /dev/null and b/GUI/coregui/images/jTxpL5ELc.png differ
diff --git a/GUI/coregui/images/mouseCursor.png b/GUI/coregui/images/mouseCursor.png
new file mode 100644
index 0000000000000000000000000000000000000000..c2f9a7fdcf75e551a74624415c506aa3d7458290
Binary files /dev/null and b/GUI/coregui/images/mouseCursor.png differ
diff --git a/GUI/coregui/images/polygon.png b/GUI/coregui/images/polygon.png
new file mode 100644
index 0000000000000000000000000000000000000000..4e0cf1c62a48d7fad904af801cde75579c48bfc6
Binary files /dev/null and b/GUI/coregui/images/polygon.png differ
diff --git a/GUI/coregui/images/rectangle.png b/GUI/coregui/images/rectangle.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b8feab36f82677a4a8b9c4544fac2c475d4f551
Binary files /dev/null and b/GUI/coregui/images/rectangle.png differ
diff --git a/GUI/coregui/images/rotationArrow.png b/GUI/coregui/images/rotationArrow.png
new file mode 100644
index 0000000000000000000000000000000000000000..6500741ebaac49ee22035dcbb7999994ed628018
Binary files /dev/null and b/GUI/coregui/images/rotationArrow.png differ
diff --git a/GUI/coregui/images/sendToBack.png b/GUI/coregui/images/sendToBack.png
new file mode 100644
index 0000000000000000000000000000000000000000..60b7ff0924cf8d3b1bef635d9fd8892acecbadd8
Binary files /dev/null and b/GUI/coregui/images/sendToBack.png differ
diff --git a/GUI/coregui/images/sf.tar.gz.png b/GUI/coregui/images/sf.tar.gz.png
new file mode 100644
index 0000000000000000000000000000000000000000..8e04c25731c7aaa666bad963041c7af6c9c752e1
Binary files /dev/null and b/GUI/coregui/images/sf.tar.gz.png differ