fixed some issues

improvied editing
changed toolbox

IndoorMap.pro

@@ -149,7 +149,13 @@ HEADERS  += MainWindow.h \
     mapview/model/MMFloorGroundTruthPoints.h \
     mapview/model/MMFloorGroundTruthPoint.h \
     mapview/2D/MV2DElementGroundTruthPoint.h \
-    misc/LINTView.h
+    misc/LINTView.h \
+    mapview/2D/tools/ToolNewElement.h \
+    mapview/2D/tools/ToolNewDoor.h \
+    mapview/2D/tools/ToolNewWall.h \
+    mapview/2D/tools/ToolNewStair.h \
+    mapview/2D/tools/ToolNewElevator.h \
+    mapview/2D/tools/ToolNewOutline.h
 
 
 FORMS    += MainWindow.ui

MainController.cpp

@@ -66,8 +66,8 @@ MainController::MainController() {
 	mapView2D->getTools().addBackground(mapZoom);
 	mapView2D->getTools().addBackground(ruler);
 
-	mapView2D->getTools().setMain(mapSelector);
+	mapView2D->getTools().setDefaultMainTool(mapSelector);
-
+	mapView2D->getTools().setMainDefault();
 
 	//connect(layerTree, SIGNAL(activated(QModelIndex)), this, SLOT(layerSelected(QModelIndex)));
 	//connect(layerTree->getTree()->selectionModel(), SIGNAL(currentChanged(QModelIndex, QModelIndex)), this, SLOT(layerSelected(QModelIndex)));

MainWindow.cpp

@@ -82,7 +82,7 @@ MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWi
 	statusBar = new QStatusBar(); this->setStatusBar(statusBar);
 	QHBoxLayout* layStatus = new QHBoxLayout(statusBar); statusBar->setLayout(layStatus);
 	statusBarText1 = new QLabel(statusBar); layStatus->addWidget(statusBarText1);
-	statusBarText1->setMinimumWidth(200);
+	statusBarText1->setMinimumWidth(400);
 
 	// tools
 	connect(&mapView2D->getTools(), &Tools::onHelpTextChange, [&] (QString txt) {

mapview/2D/MapView2D.cpp

@@ -1,4 +1,4 @@
-#include "2D/MapView2D.h"
+#include "MapView2D.h"
 
 #include <QPainter>
 #include <QOpenGLFunctions>
@@ -7,8 +7,8 @@
 
 #include <iostream>
 
-#include "model/MapModelElement.h"
+#include "../model/MapModelElement.h"
-#include "model/MapModel.h"
+#include "../model/MapModel.h"
 
 MapView2D::MapView2D(QWidget* parent) : QOpenGLWidget(parent) {
 

mapview/2D/tools/ToolMeasure.h

@@ -25,7 +25,6 @@ protected:
 
 	/** register this tool into the given tools-queue */
 	Tools& tools;
-	Tool* oldMainTool;
 
 	std::vector<Point2> pts_m;
 
@@ -33,17 +32,12 @@ public:
 
 	/** ctor */
 	ToolMeasure(Tools& tools) : tools(tools) {
-
-		oldMainTool = tools.getMain();		// keep the current tool to reset it later
-		tools.setMain(this);
-
 		resetMe();
-
 	}
 
 	/** dtor */
 	virtual ~ToolMeasure() {
-		tools.setMain(oldMainTool);			// reset to the previous tool
+		tools.setMainDefault();
 	}
 
 	const std::string getName() const {

mapview/2D/tools/ToolMoveMap.h

@@ -6,6 +6,7 @@
 
 /**
  * this tool allows moving the 2D map
+ * using the mouse
  */
 class ToolMoveMap : public Tool {
 

mapview/2D/tools/ToolNewDoor.h

@@ -0,0 +1,61 @@
+#ifndef TOOLNEWDOOR_H
+#define TOOLNEWDOOR_H
+
+#include "ToolNewElement.h"
+
+class ToolNewDoor : public ToolNewElement<Floorplan::FloorObstacleDoor, MMFloorObstacleDoor> {
+
+private:
+
+	/** currently edited line node (has 2) */
+	int idx = 0;
+
+public:
+
+	ToolNewDoor(Tools& tools, MapLayer* layer) : ToolNewElement(tools, layer) {
+		create();
+	}
+
+	const std::string getName() const override {
+		return "new Door";
+	}
+
+	void createEmptyElement() override {
+
+		foEL = new Floorplan::FloorObstacleDoor(Floorplan::DoorType::SWING, Floorplan::Material::WOOD, Point2(0, 0), Point2(0, 0));
+		MMFloorObstacles* obs = (MMFloorObstacles*)layer;
+		mmEL = obs->createDoor(foEL);
+
+	}
+
+	/** mouse is currently moved */
+	void moving(const Point2 mapPoint) override {
+
+		if (idx == 0) {	foEL->from = mapPoint; foEL->to = mapPoint; }
+		if (idx == 1) { foEL->to = mapPoint; }
+
+	}
+
+	/** next point */
+	void leftMouse() override {
+
+		if (++idx == 2) {
+			finalizeCurrent();
+			if (addAnother) {
+				idx = 0;
+				create();
+			} else {
+				disableMe();
+			}
+		}
+
+	}
+
+	void rightMouse() override {
+
+	}
+
+};
+
+
+#endif // TOOLNEWDOOR_H

mapview/2D/tools/ToolNewElement.h

@@ -0,0 +1,122 @@
+#ifndef TOOLNEWELEMENT_H
+#define TOOLNEWELEMENT_H
+
+#include "Tool.h"
+#include "Tools.h"
+#include "../../model/MapLayer.h"
+#include <Indoor/floorplan/v2/Floorplan.h>
+
+/**
+ * this is a helper class
+ * for all tools within the toolbox,
+ * that create new elements: new door, new wall, ...
+ */
+template <typename FloorplanElement, typename MapModelElement> class ToolNewElement : public Tool {
+
+protected:
+
+	/** add another line after this one? */
+	bool addAnother = true;
+
+	/** register this tool into the given tools-queue */
+	Tools& tools;
+
+	/** the layer to add the new element to */
+	MapLayer* layer = nullptr;
+
+	/** currently edited element */
+	FloorplanElement* foEL = nullptr;
+	MapModelElement* mmEL = nullptr;
+
+public:
+
+	ToolNewElement(Tools& tools, MapLayer* layer) : tools(tools), layer(layer) {
+
+	}
+
+	virtual ~ToolNewElement() {
+		tools.setMainDefault();
+	}
+
+	virtual bool mousePressEvent(MapView2D* m, QMouseEvent* e) override {
+		if (e->button() == Qt::MouseButton::LeftButton) {
+			(void) m; (void) e;
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	virtual bool mouseMoveEvent(MapView2D* m, QMouseEvent* e) override {
+		const Point2 onScreen(e->x(), e->y());
+		Point2 onMap = m->getScaler().sm(onScreen);
+		onMap = m->getScaler().snap(onMap);
+		moving(onMap);
+		return true;
+	}
+
+	virtual bool mouseReleaseEvent(MapView2D* m, QMouseEvent* e) override {
+		(void) m;
+		if (e->button() == Qt::MouseButton::LeftButton) {
+			leftMouse();
+			return true;
+		} else if (e->button() == Qt::MouseButton::RightButton) {
+			rightMouse();
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	virtual bool keyPressEvent(MapView2D* m, QKeyEvent* e) override {
+		(void) m;
+		if (e->key() == Qt::Key_Escape) {
+			deleteCurrent();
+			disableMe();
+			return true;
+		}
+		return false;
+	}
+
+protected:
+
+	/** all subclasses must create a new, empty element here */
+	virtual void createEmptyElement() = 0;
+
+	/** mouse is currently moved */
+	virtual void moving(const Point2 mapPoint) = 0;
+
+	/** left mouse: usually: next part */
+	virtual void leftMouse() = 0;
+
+	/** right mouse: usually: done */
+	virtual void rightMouse() = 0;
+
+protected:
+
+	void create() {
+		createEmptyElement();
+		mmEL->getMV2D()->focus();
+	}
+
+	/** delete the currently edited element */
+	void deleteCurrent() {
+		if (mmEL) {mmEL->deleteMe();}
+	}
+
+	/** finalize the current element (if any) */
+	void finalizeCurrent() {
+		if (!mmEL) {return;}
+		mmEL->getMV2D()->unfocus();
+		mmEL = nullptr;
+	}
+
+	/** finish creating new elements */
+	void disableMe() {
+		finalizeCurrent();
+		delete this;			// see dtor!
+	}
+
+};
+
+#endif // TOOLNEWELEMENT_H

mapview/2D/tools/ToolNewElevator.h

@@ -0,0 +1,85 @@
+#ifndef TOOLNEWELEVATOR_H
+#define TOOLNEWELEVATOR_H
+
+#include "ToolNewElement.h"
+#include "../../model/MMFloorElevators.h"
+
+class ToolNewElevator : public ToolNewElement<Floorplan::Elevator, MMFloorElevator> {
+
+private:
+
+	/** currently edited line node (has multiple) */
+	int idx = 0;
+	Point2 p1;
+	Point2 p2;
+	Point2 p3;
+
+public:
+
+	ToolNewElevator(Tools& tools, MapLayer* layer) : ToolNewElement(tools, layer) {
+		create();
+	}
+
+	const std::string getName() const override {
+		return "new Elevator";
+	}
+
+	void becomesActive() override {
+		showHelp();
+	}
+
+	void createEmptyElement() override {
+
+		foEL = new Floorplan::Elevator();
+		MMFloorElevators* elevators = (MMFloorElevators*)layer;
+		mmEL = elevators->create(foEL);
+
+	}
+
+	/** mouse is currently moved */
+	void moving(const Point2 mapPoint) override {
+
+		if (idx == 0) {
+			p1 = mapPoint;
+			p2 = mapPoint;
+			p3 = mapPoint;
+		} else if (idx == 1) {
+			p2 = mapPoint;
+			p3 = mapPoint;
+		} else if (idx == 2) {
+			p3 = mapPoint;
+		}
+
+		foEL->center = (p1+p3)/2;
+		foEL->width = p1.getDistance(p2);
+		foEL->depth = p2.getDistance(p3);
+		foEL->rotation = std::atan2(p2.y-p1.y, p2.x-p1.x);
+
+	}
+
+	/** next point */
+	void leftMouse() override {
+		++idx;
+		if (idx == 3) {
+			finalizeCurrent();
+			disableMe();
+		}
+		showHelp();
+	}
+
+	void rightMouse() override {
+		;
+	}
+
+	void showHelp() {
+		switch (idx) {
+		case 0: emit onHelpTextChange("click at the right side of the elevator's door"); break;
+		case 1: emit onHelpTextChange("click at the left side of the elevator's door"); break;
+		case 2: emit onHelpTextChange("click at the left backside of the elevator"); break;
+		}
+	}
+
+};
+
+
+#endif // TOOLNEWELEVATOR_H

mapview/2D/tools/ToolNewOutline.h

@@ -0,0 +1,66 @@
+#ifndef TOOLNEWOUTLINE_H
+#define TOOLNEWOUTLINE_H
+
+#include "ToolNewElement.h"
+#include "../../model/MMFloorOutline.h"
+#include "../../model/MMFloorOutlinePolygon.h"
+
+class ToolNewOutline : public ToolNewElement<Floorplan::FloorOutlinePolygon, MMFloorOutlinePolygon> {
+
+private:
+
+	/** currently edited line node (has multiple) */
+	int idx = 0;
+
+public:
+
+	ToolNewOutline(Tools& tools, MapLayer* layer) : ToolNewElement(tools, layer) {
+		create();
+	}
+
+	const std::string getName() const override {
+		return "new Outline";
+	}
+
+	void becomesActive() override {
+		emit onHelpTextChange("left-click for each edge of the outline. right-click to end");
+	}
+
+	void createEmptyElement() override {
+
+		foEL = new Floorplan::FloorOutlinePolygon();
+		foEL->poly.points.resize(1);
+		foEL->outdoor = false;
+		foEL->method = Floorplan::OutlineMethod::ADD;
+
+		MMFloorOutline* outlines = (MMFloorOutline*)layer;
+		mmEL = outlines->create(foEL);
+
+	}
+
+	/** mouse is currently moved */
+	void moving(const Point2 mapPoint) override {
+		foEL->poly.points[idx] = mapPoint;
+	}
+
+	/** next point */
+	void leftMouse() override {
+		++idx;
+		foEL->poly.points.resize(idx+1);
+		foEL->poly.points.back() = foEL->poly.points[idx-1];
+		emit onHelpTextChange("left-click to add, right-click to end");
+	}
+
+	void rightMouse() override {
+		if (idx >= 3) {
+			finalizeCurrent();
+		} else {
+			deleteCurrent();
+		}
+		disableMe();
+	}
+
+
+};
+
+#endif // TOOLNEWOUTLINE_H

mapview/2D/tools/ToolNewStair.h

@@ -0,0 +1,77 @@
+#ifndef TOOLNEWSTAIR_H
+#define TOOLNEWSTAIR_H
+
+#include "ToolNewElement.h"
+#include "../../model/MMFloorStairs.h"
+
+class ToolNewStair : public ToolNewElement<Floorplan::StairFreeform, MMFloorStair> {
+
+private:
+
+	/** currently edited line node (has multiple) */
+	int idx = 0;
+
+public:
+
+	ToolNewStair(Tools& tools, MapLayer* layer) : ToolNewElement(tools, layer) {
+		create();
+	}
+
+	const std::string getName() const override {
+		return "new Stair";
+	}
+
+	void becomesActive() override {
+		emit onHelpTextChange("click for the stair's starting point");
+	}
+
+	void createEmptyElement() override {
+
+		foEL = new Floorplan::StairFreeform();
+		foEL->parts.resize(1);
+		MMFloorStairs* stairs = (MMFloorStairs*)layer;
+		mmEL = stairs->create(foEL);
+
+	}
+
+	/** mouse is currently moved */
+	void moving(const Point2 mapPoint) override {
+
+		if (idx == 0) {
+
+			Floorplan::StairPart& part = foEL->parts[0];
+			part.connectWithPrev = false;
+			part.width = 1.5;
+			part.start = Point3(mapPoint.x, mapPoint.y, 0);
+			part.end = part.start;
+
+		} else if (idx == 1) {
+			Floorplan::StairPart& part = foEL->parts[0];
+			part.end = Point3(mapPoint.x, mapPoint.y, 0);
+
+		} else {
+			Floorplan::StairPart& p1 = foEL->parts[idx-2];
+			Floorplan::StairPart& p2 = foEL->parts[idx-1];
+			p2.width = 1.5;
+			p2.start = p1.end;
+			p2.end = Point3(mapPoint.x, mapPoint.y, 0);
+
+		}
+
+	}
+
+	/** next point */
+	void leftMouse() override {
+		++idx;
+		foEL->parts.resize(idx);
+		emit onHelpTextChange("right-click: set end + start new part, left-click set end + finish");
+	}
+
+	void rightMouse() override {
+		finalizeCurrent();
+		disableMe();
+	}
+
+};
+
+#endif // TOOLNEWSTAIR_H

mapview/2D/tools/ToolNewWall.h

@@ -0,0 +1,63 @@
+#ifndef TOOLNEWWALL_H
+#define TOOLNEWWALL_H
+
+#include "ToolNewElement.h"
+#include "../../model/MMFloorObstacles.h"
+#include "../../model/MMFloorObstacleLine.h"
+
+class ToolNewWall : public ToolNewElement<Floorplan::FloorObstacleLine, MMFloorObstacleLine> {
+
+private:
+
+	/** currently edited line node (has 2) */
+	int idx = 0;
+
+public:
+
+	ToolNewWall(Tools& tools, MapLayer* layer) : ToolNewElement(tools, layer) {
+		create();
+	}
+
+	const std::string getName() const override {
+		return "new Wall";
+	}
+
+	void createEmptyElement() override {
+
+		foEL = new Floorplan::FloorObstacleLine(Floorplan::ObstacleType::WALL, Floorplan::Material::DRYWALL, Point2(0, 0), Point2(0, 0));
+		MMFloorObstacles* obs = (MMFloorObstacles*)layer;
+		mmEL = obs->createLine(foEL);
+
+	}
+
+	/** mouse is currently moved */
+	void moving(const Point2 mapPoint) override {
+
+		if (idx == 0) {	foEL->from = mapPoint; foEL->to = mapPoint; }
+		if (idx == 1) { foEL->to = mapPoint; }
+
+	}
+
+	/** next point */
+	void leftMouse() override {
+
+		if (++idx == 2) {
+			finalizeCurrent();
+			if (addAnother) {
+				idx = 0;
+				create();
+			} else {
+				disableMe();
+			}
+		}
+
+	}
+
+	void rightMouse() override {
+
+	}
+
+};
+
+
+#endif // TOOLNEWWALL_H

mapview/2D/tools/Tools.h

@@ -15,8 +15,12 @@ private:
 
 	/** all added tools */
 	std::vector<Tool*> backgroundTools;
+
 	Tool* mainTool = nullptr;
 
+	/** the main tool to use whenever other tools are done: usually the select tool */
+	Tool* defaultMainTool = nullptr;
+
 
 signals:
 
@@ -66,11 +70,20 @@ public:
 		}
 	}
 
+	/** set the currently active main tool back to the default */
+	void setMainDefault() {
+		setMain(defaultMainTool);
+	}
+
 	/** get the current main tool */
 	Tool* getMain() {
 		return this->mainTool;
 	}
 
+	/** set the default main tool to use whenever other tools are done */
+	void setDefaultMainTool(Tool* t) {
+		this->defaultMainTool = t;
+	}
 
 
 

mapview/model/MMFloorElevators.h

@@ -31,13 +31,15 @@ public:
 	std::string getLayerName() const override {return "Elevators";}
 
 	//TODO: check
-	void create(Floorplan::Elevator* elevator) {
+	MMFloorElevator* create(Floorplan::Elevator* elevator) {
 
 		// add to underlying model
 		floor->elevators.push_back(elevator);
 
 		// add to myself as element
-		addElement(new MMFloorElevator(this, floor, elevator));
+		MMFloorElevator* mm = new MMFloorElevator(this, floor, elevator);
+		addElement(mm);
+		return mm;
 
 	}
 

mapview/model/MMFloorOutline.h

@@ -41,13 +41,15 @@ public:
 	Floorplan::Floor* getFloor() {return floor;}
 
 	//TODO: check
-	void create(Floorplan::FloorOutlinePolygon* poly) {
+	MMFloorOutlinePolygon* create(Floorplan::FloorOutlinePolygon* poly) {
 
 		// add to underlying model
 		floor->outline.push_back(poly);
 
 		// add to myself as element
-		addElement(new MMFloorOutlinePolygon(this, floor, poly));
+		MMFloorOutlinePolygon* mm = new MMFloorOutlinePolygon(this, floor, poly);
+		addElement(mm);
+		return mm;
 
 	}
 

mapview/model/MMFloorStairs.h

@@ -29,13 +29,15 @@ public:
 
 	}
 
-	void create(Floorplan::StairFreeform* stair) {
+	MMFloorStair* create(Floorplan::StairFreeform* stair) {
 
 		// add to underlying model
 		floor->stairs.push_back(stair);
 
 		// add to myself as element
-		addElement(new MMFloorStair(this, floor, stair));
+		MMFloorStair* mm = new MMFloorStair(this, floor, stair);
+		addElement(mm);
+		return mm;
 
 	}
 

params/ToolBox.cpp

@@ -15,6 +15,13 @@
 #include "../mapview/model/MMFloorGroundTruthPoints.h"
 
 #include "../mapview/2D/tools/ToolMeasure.h"
+#include "../mapview/2D/tools/ToolSelector.h"
+#include "../mapview/2D/tools/ToolNewElement.h"
+#include "../mapview/2D/tools/ToolNewWall.h"
+#include "../mapview/2D/tools/ToolNewDoor.h"
+#include "../mapview/2D/tools/ToolNewStair.h"
+#include "../mapview/2D/tools/ToolNewElevator.h"
+#include "../mapview/2D/tools/ToolNewOutline.h"
 
 #include "../UIHelper.h"
 
@@ -124,6 +131,12 @@ ToolBoxWidget::ToolBoxWidget(MapView2D* view, QWidget *parent) : QWidget(parent)
     lay->addWidget(btnGTP, r++, 0, 1,1,Qt::AlignTop);
     connect(btnGTP, SIGNAL(clicked(bool)), this, SLOT(onNewGTP()));
 
+
+
+	// what to do when the main-tool is changed
+	connect(&view->getTools(), SIGNAL(mainToolChanged()), this, SLOT(onMainToolChanged()));
+
+
 	// FILL
 	lay->addItem(new QSpacerItem(0,0,QSizePolicy::Minimum, QSizePolicy::MinimumExpanding), r, 0);
 
@@ -132,6 +145,27 @@ ToolBoxWidget::ToolBoxWidget(MapView2D* view, QWidget *parent) : QWidget(parent)
 
 }
 
+
+void ToolBoxWidget::onMainToolChanged() {
+
+	// get the currently active Main-Tool
+	Tool* t = view->getTools().getMain();
+
+	QString styleSel = "background-color: #bbbbff;";
+	QString styleNor = "";
+
+	// highlight the corresponding button
+	btnSelect->setStyleSheet( dynamic_cast<ToolSelector*>(t) ? styleSel : styleNor );
+	btnMeasure->setStyleSheet( dynamic_cast<ToolMeasure*>(t) ? styleSel : styleNor );
+
+	btnGround->setStyleSheet( dynamic_cast<ToolNewOutline*>(t) ? styleSel : styleNor );
+
+	btnDoor->setStyleSheet( dynamic_cast<ToolNewDoor*>(t) ? styleSel : styleNor );
+	btnWall->setStyleSheet( dynamic_cast<ToolNewWall*>(t) ? styleSel : styleNor );
+	btnElevator->setStyleSheet( dynamic_cast<ToolNewElevator*>(t) ? styleSel : styleNor );
+
+}
+
 void ToolBoxWidget::setSelectedLayer(MapLayer *ml) {
 
 	this->curLayer = ml;
@@ -158,249 +192,42 @@ void ToolBoxWidget::setSelectedLayer(MapLayer *ml) {
 
 void ToolBoxWidget::onNewGround() {
 
-	const Point2 center = view->getScaler().getCenter();
+//	const Point2 center = view->getScaler().getCenter();
-	float s = view->getScaler().sm(50);
+//	float s = view->getScaler().sm(50);
 
-	Floorplan::FloorOutlinePolygon* poly = new 	Floorplan::FloorOutlinePolygon();
+//	Floorplan::FloorOutlinePolygon* poly = new 	Floorplan::FloorOutlinePolygon();
-	poly->name = "new";
+//	poly->name = "new";
-	poly->poly.points.push_back(Point2(center.x-s, center.y-s));
+//	poly->poly.points.push_back(Point2(center.x-s, center.y-s));
-	poly->poly.points.push_back(Point2(center.x+s, center.y-s));
+//	poly->poly.points.push_back(Point2(center.x+s, center.y-s));
-	poly->poly.points.push_back(Point2(center.x, center.y+s));
+//	poly->poly.points.push_back(Point2(center.x, center.y+s));
 
 
-	MMFloorOutline* ml = (MMFloorOutline*)curLayer;
+//	MMFloorOutline* ml = (MMFloorOutline*)curLayer;
-	ml->create(poly);
+//	ml->create(poly);
+
+//	view->getModel()->reselect();
+
+	view->getTools().setMain(new ToolNewOutline(view->getTools(), curLayer));
 
-	view->getModel()->reselect();
 
 }
 
 
 
-template <typename FloorplanElement, typename MapModelElement> class NewElementTool : public Tool {
-
-protected:
-
-	/** add another line after this one? */
-	bool addAnother = true;
-
-	/** register this tool into the given tools-queue */
-	Tools& tools;
-	Tool* oldMainTool;
-
-	/** the layer to add the new element to */
-	MapLayer* layer = nullptr;
-
-	/** currently edited element */
-	FloorplanElement* foEL = nullptr;
-	MapModelElement* mmEL = nullptr;
-
-public:
-
-	NewElementTool(Tools& tools, MapLayer* layer) : tools(tools), layer(layer) {
-		oldMainTool = tools.getMain();		// keep the current tool to reset it later
-		tools.setMain(this);
-	}
-
-	virtual ~NewElementTool() {
-		tools.setMain(oldMainTool);			// reset to the previous tool
-	}
-
-	virtual bool mousePressEvent(MapView2D* m, QMouseEvent* e) override {
-		if (e->button() == Qt::MouseButton::LeftButton) {
-			(void) m; (void) e;
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	virtual bool mouseMoveEvent(MapView2D* m, QMouseEvent* e) override {
-		const Point2 onScreen(e->x(), e->y());
-		Point2 onMap = m->getScaler().sm(onScreen);
-		onMap = m->getScaler().snap(onMap);
-		moving(onMap);
-		return true;
-	}
-
-	virtual bool mouseReleaseEvent(MapView2D* m, QMouseEvent* e) override {
-		if (e->button() == Qt::MouseButton::LeftButton) {
-			(void) m; (void) e;
-			next();
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	virtual bool keyPressEvent(MapView2D* m, QKeyEvent* e) override {
-		(void) m;
-		if (e->key() == Qt::Key_Escape) {
-			deleteCurrent();
-			disableMe();
-			return true;
-		}
-		return false;
-	}
-
-protected:
-
-	/** all subclasses must create a new, empty element here */
-	virtual void createEmptyElement() = 0;
-
-	/** mouse is currently moved */
-	virtual void moving(const Point2 mapPoint) = 0;
-
-	/** next pont */
-	virtual void next() = 0;
-
-protected:
-
-	void create() {
-		createEmptyElement();
-		mmEL->getMV2D()->focus();
-	}
-
-	/** delete the currently edited element */
-	void deleteCurrent() {
-		if (mmEL) {mmEL->deleteMe();}
-	}
-
-	/** finalize the current element (if any) */
-	void finalizeCurrent() {
-		if (!mmEL) {return;}
-		mmEL->getMV2D()->unfocus();
-		mmEL = nullptr;
-	}
-
-	/** finish creating new elements */
-	void disableMe() {
-		finalizeCurrent();
-		delete this;			// see dtor!
-	}
-
-};
-
-class NewWallTool : public NewElementTool<Floorplan::FloorObstacleLine, MMFloorObstacleLine> {
-
-private:
-
-	/** currently edited line node (has 2) */
-	int idx = 0;
-
-public:
-
-	NewWallTool(Tools& tools, MapLayer* layer) : NewElementTool(tools, layer) {
-		create();
-	}
-
-	const std::string getName() const override {
-		return "new Wall";
-	}
-
-	void createEmptyElement() override {
-
-		foEL = new Floorplan::FloorObstacleLine(Floorplan::ObstacleType::WALL, Floorplan::Material::DRYWALL, Point2(0, 0), Point2(0, 0));
-		MMFloorObstacles* obs = (MMFloorObstacles*)layer;
-		mmEL = obs->createLine(foEL);
-
-	}
-
-	/** mouse is currently moved */
-	void moving(const Point2 mapPoint) override {
-
-		if (idx == 0) {	foEL->from = mapPoint; foEL->to = mapPoint; }
-		if (idx == 1) { foEL->to = mapPoint; }
-
-	}
-
-	/** next pont */
-	void next() override {
-
-		if (++idx == 2) {
-			finalizeCurrent();
-			if (addAnother) {
-				idx = 0;
-				create();
-			} else {
-				disableMe();
-			}
-		}
-
-	}
-
-};
-
-
-class NewDoorTool : public NewElementTool<Floorplan::FloorObstacleDoor, MMFloorObstacleDoor> {
-
-private:
-
-	/** currently edited line node (has 2) */
-	int idx = 0;
-
-public:
-
-	NewDoorTool(Tools& tools, MapLayer* layer) : NewElementTool(tools, layer) {
-		create();
-	}
-
-	const std::string getName() const override {
-		return "new Door";
-	}
-
-	void createEmptyElement() override {
-
-		foEL = new Floorplan::FloorObstacleDoor(Floorplan::DoorType::SWING, Floorplan::Material::WOOD, Point2(0, 0), Point2(0, 0));
-		MMFloorObstacles* obs = (MMFloorObstacles*)layer;
-		mmEL = obs->createDoor(foEL);
-
-	}
-
-	/** mouse is currently moved */
-	void moving(const Point2 mapPoint) override {
-
-		if (idx == 0) {	foEL->from = mapPoint; foEL->to = mapPoint; }
-		if (idx == 1) { foEL->to = mapPoint; }
-
-	}
-
-	/** next pont */
-	void next() override {
-
-		if (++idx == 2) {
-			finalizeCurrent();
-			if (addAnother) {
-				idx = 0;
-				create();
-			} else {
-				disableMe();
-			}
-		}
-
-	}
-
-};
-
-
 void ToolBoxWidget::onSelect() {
-
+	view->getTools().setMainDefault();
-
 }
 
 void ToolBoxWidget::onMeasure() {
-
+	view->getTools().setMain(new ToolMeasure(view->getTools()));
-	new ToolMeasure(view->getTools());
-
 }
 
-
-
 void ToolBoxWidget::onNewWall() {
+	view->getTools().setMain(new ToolNewWall(view->getTools(), curLayer));
+}
 
-	new NewWallTool(view->getTools(), curLayer);
+void ToolBoxWidget::onNewDoor() {
-	//view->getModel()->reselect();
+	view->getTools().setMain(new ToolNewDoor(view->getTools(), curLayer));
-
 }
 
 void ToolBoxWidget::onNewPillar() {
@@ -421,37 +248,35 @@ void ToolBoxWidget::onNewPillar() {
 
 }
 
-void ToolBoxWidget::onNewDoor() {
 
-	new NewDoorTool(view->getTools(), curLayer);
-
-}
 
 void ToolBoxWidget::onNewStair() {
 
-	const Point2 center = view->getScaler().getCenter();
+	view->getTools().setMain(new ToolNewStair(view->getTools(), curLayer));
 
-	Floorplan::StairFreeform* stair = new Floorplan::StairFreeform();
-	Floorplan::StairPart part(Point3(center.x-3, center.y, 0), Point3(center.x+3, center.y, 3), 3);
-	stair->parts.push_back( part );
 
-	MMFloorStairs* stairs = (MMFloorStairs*)curLayer;
+//	const Point2 center = view->getScaler().getCenter();
-	stairs->create(stair);
+
+//	Floorplan::StairFreeform* stair = new Floorplan::StairFreeform();
+//	Floorplan::StairPart part(Point3(center.x-3, center.y, 0), Point3(center.x+3, center.y, 3), 3);
+//	stair->parts.push_back( part );
+
+//	MMFloorStairs* stairs = (MMFloorStairs*)curLayer;
+//	stairs->create(stair);
 
-	//view->getModel()->reselect();
 
 }
 
 void ToolBoxWidget::onNewElevator() {
 
-	const Point2 center = view->getScaler().getCenter();
+//	const Point2 center = view->getScaler().getCenter();
 
-	Floorplan::Elevator* elevator = new Floorplan::Elevator(center);
+//	Floorplan::Elevator* elevator = new Floorplan::Elevator(center);
 
-	MMFloorElevators* elevators = (MMFloorElevators*)curLayer;
+//	MMFloorElevators* elevators = (MMFloorElevators*)curLayer;
-	elevators->create(elevator);
+//	elevators->create(elevator);
 
-	//view->getModel()->reselect();
+	view->getTools().setMain(new ToolNewElevator(view->getTools(), curLayer));
 
 }
 

params/ToolBoxWidget.h

@@ -71,6 +71,8 @@ private slots:
 
 	void onNewImage();
 
+	void onMainToolChanged();
+
 
 };