Include default argument setters/getters

Include the ToolPointer enum to all setter and getter Functions with the
default being "current".

src/control/ToolHandler.cpp

@@ -159,17 +159,20 @@ void ToolHandler::fireToolChanged() {
 
 auto ToolHandler::getTool(ToolType type) -> Tool& { return *(this->tools[type - TOOL_PEN]); }
 
-auto ToolHandler::getToolType() -> ToolType { return this->currentTool->type; }
+auto ToolHandler::getToolType(ToolPointer toolPointer) -> ToolType {
+    Tool* tool = getToolPointer(toolPointer);
+    return tool->type;
+}
 
-auto ToolHandler::hasCapability(ToolCapabilities cap, bool mainTool) -> bool {
-    if (mainTool == false) {
-        return (currentTool->capabilities & cap) != 0;
-    } else {
-        return (toolbarSelectedTool->capabilities & cap) != 0;
-    }
+auto ToolHandler::hasCapability(ToolCapabilities cap, ToolPointer toolPointer) -> bool {
+    Tool* tool = getToolPointer(toolPointer);
+    return (tool->capabilities & cap) != 0;
 }
 
-auto ToolHandler::getSize() -> ToolSize { return this->currentTool->getSize(); }
+auto ToolHandler::getSize(ToolPointer toolPointer) -> ToolSize {
+    Tool* tool = getToolPointer(toolPointer);
+    return tool->getSize();
+}
 
 auto ToolHandler::getPenSize() -> ToolSize { return tools[TOOL_PEN - TOOL_PEN]->getSize(); }
 
@@ -229,23 +232,23 @@ void ToolHandler::setHilighterFill(int alpha) { this->tools[TOOL_HILIGHTER - TOO
 
 auto ToolHandler::getHilighterFill() -> int { return this->tools[TOOL_HILIGHTER - TOOL_PEN]->getFillAlpha(); }
 
-auto ToolHandler::getThickness() -> double {
-    if (this->currentTool->thickness) {
-        return this->currentTool->thickness[this->currentTool->getSize()];
+auto ToolHandler::getThickness(ToolPointer toolPointer) -> double {
+    Tool* tool = getToolPointer(toolPointer);
+    if (tool->thickness) {
+        return tool->thickness[tool->getSize()];
     }
 
-
-    g_warning("Request size of \"%s\"", this->currentTool->getName().c_str());
+    g_warning("Request size of \"%s\"", tool->getName().c_str());
     return 0;
 }
 
-void ToolHandler::setSize(ToolSize size) {
+void ToolHandler::setSize(ToolSize size, ToolPointer toolPointer) {
+    Tool* tool = getToolPointer(toolPointer);
     if (size < TOOL_SIZE_VERY_FINE || size > TOOL_SIZE_VERY_THICK) {
         g_warning("ToolHandler::setSize: Invalid size! %i", size);
         return;
     }
-
-    this->currentTool->setSize(size);
+    tool->setSize(size);
     this->listener->toolSizeChanged();
 }
 
@@ -275,24 +278,37 @@ void ToolHandler::setColor(Color color, bool userSelection) {
     this->listener->setCustomColorSelected();
 }
 
-auto ToolHandler::getColor() -> Color { return currentTool->getColor(); }
+auto ToolHandler::getColor(ToolPointer toolPointer) -> Color {
+    Tool* tool = getToolPointer(toolPointer);
+    return tool->getColor();
+}
 
 /**
  * @return -1 if fill is disabled, else the fill alpha value
  */
-auto ToolHandler::getFill() -> int {
-    if (!currentTool->getFill()) {
+auto ToolHandler::getFill(ToolPointer toolPointer) -> int {
+    Tool* tool = getToolPointer(toolPointer);
+    if (!tool->getFill()) {
         return -1;
     }
-
-    return currentTool->getFillAlpha();
+    return tool->getFillAlpha();
 }
 
-auto ToolHandler::getLineStyle() -> const LineStyle& { return currentTool->getLineStyle(); }
+auto ToolHandler::getLineStyle(ToolPointer toolPointer) -> const LineStyle& {
+    Tool* tool = getToolPointer(toolPointer);
+    return tool->getLineStyle();
+}
 
-auto ToolHandler::getDrawingType() -> DrawingType { return currentTool->getDrawingType(); }
+auto ToolHandler::getDrawingType(ToolPointer toolPointer) -> DrawingType {
+    Tool* tool = getToolPointer(toolPointer);
+    return tool->getDrawingType();
+}
 
-void ToolHandler::setDrawingType(DrawingType drawingType) { currentTool->setDrawingType(drawingType); }
+// TODO
+void ToolHandler::setDrawingType(DrawingType drawingType, ToolPointer toolPointer) {
+    Tool* tool = getToolPointer(toolPointer);
+    tool->setDrawingType(drawingType);
+}
 
 auto ToolHandler::getTools() const -> std::array<std::unique_ptr<Tool>, TOOL_COUNT> const& { return tools; }
 
@@ -466,9 +482,9 @@ void ToolHandler::setSelectionEditTools(bool setColor, bool setSize, bool setFil
     }
 }
 
-auto ToolHandler::isSinglePageTool() -> bool {
-    ToolType toolType = this->getToolType();
-    DrawingType drawingType = this->getDrawingType();
+auto ToolHandler::isSinglePageTool(ToolPointer toolPointer) -> bool {
+    ToolType toolType = this->getToolType(toolPointer);
+    DrawingType drawingType = this->getDrawingType(toolPointer);
 
     return toolType == (TOOL_PEN && (drawingType == DRAWING_TYPE_ARROW || drawingType == DRAWING_TYPE_CIRCLE ||
                                      drawingType == DRAWING_TYPE_COORDINATE_SYSTEM ||
@@ -478,3 +494,16 @@ auto ToolHandler::isSinglePageTool() -> bool {
            toolType == TOOL_DRAW_COORDINATE_SYSTEM || toolType == TOOL_DRAW_ARROW ||
            toolType == TOOL_FLOATING_TOOLBOX || toolType == TOOL_DRAW_SPLINE;
 }
+
+auto ToolHandler::getToolPointer(ToolPointer toolpointer) -> Tool* {
+    switch (toolpointer) {
+        case ToolPointer::current:
+            return this->currentTool;
+        case ToolPointer::toolbar:
+            return this->toolbarSelectedTool;
+        case ToolPointer::button:
+            return this->buttonSelectedTool;
+        default:
+            g_error("This ToolPointer does not exist.");
+    }
+}

src/control/ToolHandler.h

@@ -23,6 +23,7 @@
 #include "Tool.h"
 #include "XournalType.h"
 
+enum ToolPointer { current, toolbar, button };
 
 class ToolListener {
 public:
@@ -53,21 +54,21 @@ public:
      * 			and therefore should not be applied to a selection
      */
     void setColor(Color color, bool userSelection);
-    Color getColor();
+    Color getColor(ToolPointer toolpointer = ToolPointer::current);
 
     /**
      * @return -1 if fill is disabled, else the fill alpha value
      */
-    int getFill();
+    int getFill(ToolPointer toolpointer = ToolPointer::current);
 
-    DrawingType getDrawingType();
-    void setDrawingType(DrawingType drawingType);
+    DrawingType getDrawingType(ToolPointer toolpointer = ToolPointer::current);
+    void setDrawingType(DrawingType drawingType, ToolPointer toolpointer = ToolPointer::current);
 
-    const LineStyle& getLineStyle();
+    const LineStyle& getLineStyle(ToolPointer toolpointer = ToolPointer::current);
 
-    ToolSize getSize();
-    void setSize(ToolSize size);
-    double getThickness();
+    ToolSize getSize(ToolPointer toolpointer = ToolPointer::current);
+    void setSize(ToolSize size, ToolPointer toolpointer = ToolPointer::current);
+    double getThickness(ToolPointer toolpointer = ToolPointer::current);
 
     void setLineStyle(const LineStyle& style);
 
@@ -89,7 +90,7 @@ public:
     int getHilighterFill();
 
     void selectTool(ToolType type, bool fireToolChanged = true, bool stylus = false);
-    ToolType getToolType();
+    ToolType getToolType(ToolPointer toolpointer = ToolPointer::current);
     void fireToolChanged();
 
     Tool& getTool(ToolType type);
@@ -98,7 +99,7 @@ public:
     EraserType getEraserType();
     void eraserTypeChanged();
 
-    bool hasCapability(ToolCapabilities cap, bool mainTool = false);
+    bool hasCapability(ToolCapabilities cap, ToolPointer toolpointer = ToolPointer::current);
 
     void saveSettings();
     void loadSettings();
@@ -120,7 +121,7 @@ public:
      * pointer moves to another
      * @return
      */
-    bool isSinglePageTool();
+    bool isSinglePageTool(ToolPointer toolpointer = ToolPointer::current);
 
     bool triggeredByButton = false;
 
@@ -129,6 +130,9 @@ protected:
 
 private:
     std::array<std::unique_ptr<Tool>, TOOL_COUNT> tools;
+
+    // get Pointer based on Enum used for public setters and getters
+    Tool* getToolPointer(ToolPointer toolpointer);
     Tool* currentTool = nullptr;
 
     /**

src/gui/toolbarMenubar/ColorToolItem.cpp

@@ -106,7 +106,8 @@ void ColorToolItem::showColorchooser() {
  * Enable / Disable the tool item
  */
 void ColorToolItem::enable(bool enabled) {
-    if (!enabled && !toolHandler->hasCapability(TOOL_CAP_COLOR) && toolHandler->hasCapability(TOOL_CAP_COLOR, true)) {
+    if (!enabled && !toolHandler->hasCapability(TOOL_CAP_COLOR, ToolPointer::current) &&
+        toolHandler->hasCapability(TOOL_CAP_COLOR, ToolPointer::toolbar)) {
         if (this->icon && toolHandler->triggeredByButton) {
             // allow changes if currentTool has no colour capability
             // and mainTool has Colour capability