Fix GitHub Issue #206: An option to change the size of the arrows

- Toolbar now includes a spinner widget to set the arrow size

Author: juzzlin

CHANGELOG

@@ -7,6 +7,9 @@ New features:
 
 * Add German translations
 
+* Fix GitHub Issue #206: An option to change the size of the arrows
+  - Toolbar now includes a spinner widget to set the arrow size
+
 Bug fixes:
 
 * Fix GitHub Issue #205: Click dragging from an existing node, 

src/alz_serializer.cpp

@@ -40,6 +40,8 @@ namespace MindMap {
 
 const auto APPLICATION_VERSION = "version";
 
+const auto ARROW_SIZE = "arrow-size";
+
 const auto COLOR = "color";
 
 const auto CORNER_RADIUS = "corner-radius";
@@ -446,6 +448,9 @@ std::unique_ptr<MindMapData> fromXml(QDomDocument document)
     readChildren(root, { { QString(DataKeywords::MindMap::GRAPH), [&data](const QDomElement & e) {
                               readGraph(e, *data);
                           } },
+                         { QString(DataKeywords::MindMap::ARROW_SIZE), [&data](const QDomElement & e) {
+                              data->setArrowSize(readFirstTextNodeContent(e).toDouble() / SCALE);
+                          } },
                          { QString(DataKeywords::MindMap::COLOR), [&data](const QDomElement & e) {
                               data->setBackgroundColor(readColorElement(e));
                           } },
@@ -505,6 +510,10 @@ QDomDocument toXml(MindMapData & mindMapData)
 
     writeColor(root, doc, mindMapData.gridColor(), DataKeywords::MindMap::GRID_COLOR);
 
+    auto arrowSizeElement = doc.createElement(DataKeywords::MindMap::ARROW_SIZE);
+    arrowSizeElement.appendChild(doc.createTextNode(QString::number(static_cast<int>(mindMapData.arrowSize() * SCALE))));
+    root.appendChild(arrowSizeElement);
+
     auto edgeWidthElement = doc.createElement(DataKeywords::MindMap::EDGE_THICKNESS);
     edgeWidthElement.appendChild(doc.createTextNode(QString::number(static_cast<int>(mindMapData.edgeWidth() * SCALE))));
     root.appendChild(edgeWidthElement);

src/application.cpp

@@ -155,13 +155,13 @@ Application::Application(int & argc, char ** argv)
 
     // Connect views and StateMachine together
     connect(this, &Application::actionTriggered, m_stateMachine.get(), &StateMachine::calculateState);
-    connect(m_editorView, &EditorView::actionTriggered, [this](StateMachine::Action action) {
+    connect(m_editorView, &EditorView::actionTriggered, m_stateMachine.get(), [this](StateMachine::Action action) {
         m_stateMachine->calculateState(action);
     });
     connect(m_mainWindow.get(), &MainWindow::actionTriggered, m_stateMachine.get(), &StateMachine::calculateState);
     connect(m_stateMachine.get(), &StateMachine::stateChanged, this, &Application::runState);
 
-    connect(m_editorData.get(), &EditorData::isModifiedChanged, [=](bool isModified) {
+    connect(m_editorData.get(), &EditorData::isModifiedChanged, m_mainWindow.get(), [=](bool isModified) {
         m_mainWindow->enableSave(isModified || m_mediator->canBeSaved());
     });
 
@@ -171,12 +171,13 @@ Application::Application(int & argc, char ** argv)
     connect(m_mediator.get(), &Mediator::pngExportFinished, m_pngExportDialog.get(), &PngExportDialog::finishExport);
     connect(m_mediator.get(), &Mediator::svgExportFinished, m_svgExportDialog.get(), &SvgExportDialog::finishExport);
 
+    connect(m_mainWindow.get(), &MainWindow::arrowSizeChanged, m_mediator.get(), &Mediator::setArrowSize);
     connect(m_mainWindow.get(), &MainWindow::cornerRadiusChanged, m_mediator.get(), &Mediator::setCornerRadius);
     connect(m_mainWindow.get(), &MainWindow::edgeWidthChanged, m_mediator.get(), &Mediator::setEdgeWidth);
     connect(m_mainWindow.get(), &MainWindow::fontChanged, m_mediator.get(), &Mediator::changeFont);
     connect(m_mainWindow.get(), &MainWindow::textSizeChanged, m_mediator.get(), &Mediator::setTextSize);
     connect(m_mainWindow.get(), &MainWindow::gridSizeChanged, m_mediator.get(), &Mediator::setGridSize);
-    connect(m_mainWindow.get(), &MainWindow::gridVisibleChanged, [this](int state) {
+    connect(m_mainWindow.get(), &MainWindow::gridVisibleChanged, m_editorView, [this](int state) {
         bool visible = state == Qt::Checked;
         m_editorView->setGridVisible(visible);
     });

src/constants.hpp

@@ -51,14 +51,16 @@ static constexpr auto TRANSLATIONS_RESOURCE_BASE = ":/translations/heimer_";
 
 namespace Edge {
 
-static const double ARROW_LENGTH = 10;
+static const double ARROW_SIZE_STEP = 5;
 
 static const double ARROW_OPENING = 150;
 
 static const double CORNER_RADIUS_SCALE = 0.3;
 
 static const QVector DASH_PATTERN { qreal(5), qreal(5) };
 
+static const double DEFAULT_ARROW_SIZE = 10;
+
 static const QColor DOT_COLOR { 255, 0, 0, 192 };
 
 static const int DOT_DURATION = 2000;
@@ -69,11 +71,15 @@ static const QColor LABEL_COLOR { 0xff, 0xee, 0xaa };
 
 static const int LABEL_DURATION = 2000;
 
-static const double MIN_SIZE = 0.1;
+static const double MIN_ARROW_SIZE = 5;
+
+static const double MAX_ARROW_SIZE = 99;
+
+static const double MIN_EDGE_WIDTH = 0.1;
 
-static const double MAX_SIZE = 5.0;
+static const double MAX_EDGE_WIDTH = 5.0;
 
-static const double STEP = 0.1;
+static const double EDGE_WIDTH_STEP = 0.1;
 
 static const int TEXT_EDIT_ANIMATION_DURATION = 150;
 

src/edge.cpp

@@ -69,7 +69,7 @@ Edge::Edge(NodeP sourceNode, NodeP targetNode, bool enableAnimations, bool enabl
         m_label->setZValue(static_cast<int>(Layers::EdgeLabel));
         m_label->setBackgroundColor(Constants::Edge::LABEL_COLOR);
 
-        connect(m_label, &TextEdit::textChanged, [=](const QString & text) {
+        connect(m_label, &TextEdit::textChanged, this, [=](const QString & text) {
             updateLabel();
             m_text = text;
         });
@@ -79,7 +79,7 @@ Edge::Edge(NodeP sourceNode, NodeP targetNode, bool enableAnimations, bool enabl
         m_labelVisibilityTimer.setSingleShot(true);
         m_labelVisibilityTimer.setInterval(Constants::Edge::LABEL_DURATION);
 
-        connect(&m_labelVisibilityTimer, &QTimer::timeout, [=] {
+        connect(&m_labelVisibilityTimer, &QTimer::timeout, this, [=] {
             setLabelVisible(false);
         });
     }
@@ -120,7 +120,7 @@ void Edge::hoverLeaveEvent(QGraphicsSceneHoverEvent * event)
 
 QPen Edge::buildPen(bool ignoreDashSetting) const
 {
-    QPen pen { QBrush { QColor { m_color.red(), m_color.green(), m_color.blue() } }, m_width };
+    QPen pen { QBrush { QColor { m_color.red(), m_color.green(), m_color.blue() } }, m_edgeWidth };
     pen.setCapStyle(Qt::PenCapStyle::RoundCap);
     if (!ignoreDashSetting && m_dashedLine) {
         pen.setDashPattern(Constants::Edge::DASH_PATTERN);
@@ -199,9 +199,9 @@ void Edge::setLabelVisible(bool visible, EdgeTextEdit::VisibilityChangeReason vc
     }
 }
 
-void Edge::setWidth(double width)
+void Edge::setEdgeWidth(double edgeWidth)
 {
-    m_width = width;
+    m_edgeWidth = edgeWidth;
 
     updateLine();
 }
@@ -216,6 +216,13 @@ void Edge::setArrowMode(ArrowMode arrowMode)
     }
 }
 
+void Edge::setArrowSize(double arrowSize)
+{
+    m_arrowSize = arrowSize;
+
+    updateLine();
+}
+
 void Edge::setColor(const QColor & color)
 {
     m_color = color;
@@ -299,10 +306,10 @@ void Edge::updateArrowhead()
     case ArrowMode::Single: {
         lineL0.setP1(point0);
         const auto angleL = qDegreesToRadians(angle0 + Constants::Edge::ARROW_OPENING);
-        lineL0.setP2(point0 + QPointF(std::cos(angleL), std::sin(angleL)) * Constants::Edge::ARROW_LENGTH);
+        lineL0.setP2(point0 + QPointF(std::cos(angleL), std::sin(angleL)) * m_arrowSize);
         lineR0.setP1(point0);
         const auto angleR = qDegreesToRadians(angle0 - Constants::Edge::ARROW_OPENING);
-        lineR0.setP2(point0 + QPointF(std::cos(angleR), std::sin(angleR)) * Constants::Edge::ARROW_LENGTH);
+        lineR0.setP2(point0 + QPointF(std::cos(angleR), std::sin(angleR)) * m_arrowSize);
         m_arrowheadL0->setLine(lineL0);
         m_arrowheadR0->setLine(lineR0);
         m_arrowheadL0->show();
@@ -314,20 +321,20 @@ void Edge::updateArrowhead()
     case ArrowMode::Double: {
         lineL0.setP1(point0);
         const auto angleL0 = qDegreesToRadians(angle0 + Constants::Edge::ARROW_OPENING);
-        lineL0.setP2(point0 + QPointF(std::cos(angleL0), std::sin(angleL0)) * Constants::Edge::ARROW_LENGTH);
+        lineL0.setP2(point0 + QPointF(std::cos(angleL0), std::sin(angleL0)) * m_arrowSize);
         lineR0.setP1(point0);
         const auto angleR0 = qDegreesToRadians(angle0 - Constants::Edge::ARROW_OPENING);
-        lineR0.setP2(point0 + QPointF(std::cos(angleR0), std::sin(angleR0)) * Constants::Edge::ARROW_LENGTH);
+        lineR0.setP2(point0 + QPointF(std::cos(angleR0), std::sin(angleR0)) * m_arrowSize);
         lineL1.setP1(point1);
         m_arrowheadL0->setLine(lineL0);
         m_arrowheadR0->setLine(lineR0);
         m_arrowheadL0->show();
         m_arrowheadR0->show();
         const auto angleL1 = qDegreesToRadians(angle1 + Constants::Edge::ARROW_OPENING);
-        lineL1.setP2(point1 + QPointF(std::cos(angleL1), std::sin(angleL1)) * Constants::Edge::ARROW_LENGTH);
+        lineL1.setP2(point1 + QPointF(std::cos(angleL1), std::sin(angleL1)) * m_arrowSize);
         lineR1.setP1(point1);
         const auto angleR1 = qDegreesToRadians(angle1 - Constants::Edge::ARROW_OPENING);
-        lineR1.setP2(point1 + QPointF(std::cos(angleR1), std::sin(angleR1)) * Constants::Edge::ARROW_LENGTH);
+        lineR1.setP2(point1 + QPointF(std::cos(angleR1), std::sin(angleR1)) * m_arrowSize);
         m_arrowheadL1->setLine(lineL1);
         m_arrowheadR1->setLine(lineR1);
         m_arrowheadL1->show();
@@ -424,7 +431,7 @@ void Edge::updateLine()
     setLine(QLineF(
       p1 + (nearestPoints.first.isCorner ? Constants::Edge::CORNER_RADIUS_SCALE * (direction1 * static_cast<float>(sourceNode().cornerRadius())).toPointF() : QPointF { 0, 0 }),
       p2 + (nearestPoints.second.isCorner ? Constants::Edge::CORNER_RADIUS_SCALE * (direction2 * static_cast<float>(targetNode().cornerRadius())).toPointF() : QPointF { 0, 0 }) - //
-        (direction2 * static_cast<float>(m_width)).toPointF() * Constants::Edge::WIDTH_SCALE));
+        (direction2 * static_cast<float>(m_edgeWidth)).toPointF() * Constants::Edge::WIDTH_SCALE));
 
     updateDots();
     updateLabel(LabelUpdateReason::EdgeGeometryChanged);

src/edge.hpp

@@ -22,6 +22,7 @@
 #include <map>
 #include <memory>
 
+#include "constants.hpp"
 #include "edge_point.hpp"
 #include "edge_text_edit.hpp"
 #include "types.hpp"
@@ -90,11 +91,13 @@ public slots:
 
     void setArrowMode(ArrowMode arrowMode);
 
+    void setArrowSize(double arrowSize);
+
     void setColor(const QColor & color);
 
     void setDashedLine(bool enable);
 
-    void setWidth(double width);
+    void setEdgeWidth(double edgeWidth);
 
     void setText(const QString & text);
 
@@ -137,7 +140,9 @@ public slots:
 
     QString m_text;
 
-    double m_width = 2;
+    double m_arrowSize = Constants::Edge::DEFAULT_ARROW_SIZE;
+
+    double m_edgeWidth = Constants::MindMap::DEFAULT_EDGE_WIDTH;
 
     int m_textSize = 11; // Not sure if we should set yet another default value here..
 

src/editor_view.cpp

@@ -408,8 +408,9 @@ void EditorView::showDummyDragEdge(bool show)
         }
     }
 
+    m_dummyDragEdge->setArrowSize(m_arrowSize);
     m_dummyDragEdge->setColor(m_edgeColor);
-    m_dummyDragEdge->setWidth(m_edgeWidth);
+    m_dummyDragEdge->setEdgeWidth(m_edgeWidth);
     m_dummyDragEdge->setVisible(show);
 }
 
@@ -456,38 +457,43 @@ void EditorView::saveZoom()
     m_savedZoom = { scene()->sceneRect(), mapToScene(viewport()->rect().center()), m_scale };
 }
 
+void EditorView::setArrowSize(double arrowSize)
+{
+    m_arrowSize = arrowSize;
+}
+
 void EditorView::setCornerRadius(int cornerRadius)
 {
     m_cornerRadius = cornerRadius;
 }
 
-void EditorView::setGridSize(int size)
+void EditorView::setEdgeColor(const QColor & edgeColor)
 {
-    m_grid.setSize(size);
-    if (scene())
-        scene()->update();
+    m_edgeColor = edgeColor;
 }
 
-void EditorView::setGridVisible(bool visible)
+void EditorView::setEdgeWidth(double edgeWidth)
 {
-    m_gridVisible = visible;
-    if (scene())
-        scene()->update();
+    m_edgeWidth = edgeWidth;
 }
 
-void EditorView::setEdgeColor(const QColor & edgeColor)
+void EditorView::setGridSize(int size)
 {
-    m_edgeColor = edgeColor;
+    m_grid.setSize(size);
+    if (scene())
+        scene()->update();
 }
 
 void EditorView::setGridColor(const QColor & gridColor)
 {
     m_mediator.mindMapData()->setGridColor(gridColor);
 }
 
-void EditorView::setEdgeWidth(double edgeWidth)
+void EditorView::setGridVisible(bool visible)
 {
-    m_edgeWidth = edgeWidth;
+    m_gridVisible = visible;
+    if (scene())
+        scene()->update();
 }
 
 void EditorView::wheelEvent(QWheelEvent * event)

src/editor_view.hpp

@@ -16,6 +16,7 @@
 #ifndef EDITOR_VIEW_HPP
 #define EDITOR_VIEW_HPP
 
+#include "constants.hpp"
 #include "grid.hpp"
 #include "main_context_menu.hpp"
 #include "state_machine.hpp"
@@ -67,15 +68,16 @@ class EditorView : public QGraphicsView
     QString dropFile() const;
 
 public slots:
+    void setArrowSize(double arrowSize);
 
     void setCornerRadius(int cornerRadius);
 
     void setEdgeColor(const QColor & edgeColor);
 
-    void setGridColor(const QColor & edgeColor);
-
     void setEdgeWidth(double edgeWidth);
 
+    void setGridColor(const QColor & edgeColor);
+
     void setGridSize(int size);
 
     void setGridVisible(bool visible);
@@ -169,8 +171,11 @@ public slots:
 
     int m_cornerRadius = 0;
 
+    // Arrow size for the dummy drag edge
+    double m_arrowSize = Constants::Edge::DEFAULT_ARROW_SIZE;
+
     // Width for the dummy drag edge
-    double m_edgeWidth = 1.5;
+    double m_edgeWidth = Constants::MindMap::DEFAULT_EDGE_WIDTH;
 
     QColor m_edgeColor;
 

src/main_window.cpp

@@ -127,6 +127,8 @@ void MainWindow::connectToolBar()
 {
     connect(m_toolBar, &ToolBar::gridVisibleChanged, this, &MainWindow::gridVisibleChanged);
 
+    connect(m_toolBar, &ToolBar::arrowSizeChanged, this, &MainWindow::arrowSizeChanged);
+
     connect(m_toolBar, &ToolBar::cornerRadiusChanged, this, &MainWindow::cornerRadiusChanged);
 
     connect(m_toolBar, &ToolBar::edgeWidthChanged, this, &MainWindow::edgeWidthChanged);
@@ -491,6 +493,11 @@ void MainWindow::enableWidgetSignals(bool enable)
     m_toolBar->enableWidgetSignals(enable);
 }
 
+void MainWindow::setArrowSize(double value)
+{
+    m_toolBar->setArrowSize(value);
+}
+
 void MainWindow::setCornerRadius(int value)
 {
     m_toolBar->setCornerRadius(value);

src/main_window.hpp

@@ -91,6 +91,8 @@ public slots:
 
     void enableSave(bool enable);
 
+    void setArrowSize(double value);
+
     void setCornerRadius(int value);
 
     void setEdgeWidth(double value);
@@ -106,6 +108,8 @@ public slots:
 
     void actionTriggered(StateMachine::Action action);
 
+    void arrowSizeChanged(double arrowSize);
+
     void cornerRadiusChanged(int size);
 
     void edgeWidthChanged(double width);