Merge GH-1653

Major rework of Map's template API and of TemplateListWidget

Author: dg0yt

code-check-wrapper.sh

@@ -94,6 +94,7 @@ for I in \
   template_list_widget.cpp \
   template_map.cpp \
   template_placeholder.cpp \
+  template_table_model.cpp \
   template_tool \
   template_track.cpp \
   text_brwoser_dialog \

src/CMakeLists.txt

@@ -166,6 +166,7 @@ set(Mapper_Common_SRCS
   templates/template_placeholder.cpp
   templates/template_position_dock_widget.cpp
   templates/template_positioning_dialog.cpp
+  templates/template_table_model.cpp
   templates/template_tool_move.cpp
   templates/template_tool_paint.cpp
   templates/template_track.cpp

src/core/map.cpp

@@ -26,6 +26,7 @@
 #include <iterator>
 #include <memory>
 #include <type_traits>
+#include <utility>
 
 #include <Qt>
 #include <QtGlobal>
@@ -37,6 +38,7 @@
 #include <QPainter>
 #include <QPoint>
 #include <QPointF>
+#include <QSignalBlocker>
 #include <QTimer>
 #include <QTranslator>
 
@@ -446,13 +448,8 @@ void Map::clear()
 {
 	undo_manager->clear();
 
-	for (auto temp : templates)
-		delete temp;
 	templates.clear();
 	first_front_template = 0;
-	
-	for (auto temp : closed_templates)
-		delete temp;
 	closed_templates.clear();
 
 	object_selection.clear();
@@ -1774,31 +1771,105 @@ void Map::updateSymbolIconZoom()
 
 
 
-void Map::setTemplate(Template* temp, int pos)
+void Map::setFirstFrontTemplate(int pos)
 {
-	templates[pos] = temp;
-	emit templateChanged(pos, templates[pos]);
+	if (getFirstFrontTemplate() == pos)
+		return;
+	
+	auto first = begin(templates) + std::min(getNumTemplates(), pos);
+	auto last  = begin(templates) + std::min(getNumTemplates(), getFirstFrontTemplate());
+	if (getFirstFrontTemplate() < pos)
+	{
+		using std::swap;
+		swap(first, last);
+	}
+	auto const old_pos = first_front_template;
+	std::for_each(first, last, [](auto& templ) { templ->setTemplateAreaDirty(); });
+	emit firstFrontTemplateAboutToBeChanged(old_pos, pos);
+	first_front_template = pos;
+	emit firstFrontTemplateChanged(old_pos, pos);
+	std::for_each(first, last, [](auto& templ) { templ->setTemplateAreaDirty(); });
+	setTemplatesDirty();
 }
 
-void Map::addTemplate(Template* temp, int pos)
+std::unique_ptr<Template> Map::setTemplate(int pos, std::unique_ptr<Template> temp)
 {
-	templates.insert(templates.begin() + pos, temp);
-	emit templateAdded(pos, temp);
+	using std::swap;
+	auto const it = begin(templates) + pos;
+	(*it)->setTemplateAreaDirty();
+	swap(temp, *it);
+	emit templateChanged(pos, it->get());
+	(*it)->setTemplateAreaDirty();
+	setTemplatesDirty();
+	return temp;
 }
 
-void Map::removeTemplate(int pos)
+void Map::addTemplate(int pos, std::unique_ptr<Template> temp)
 {
-	auto it = templates.begin() + pos;
-	Template* temp = *it;
+	auto front = getFirstFrontTemplate();
+	auto in_background = pos < front;
+	if (in_background)
+	{
+		if (pos < 0)
+			pos = front;
+		++front;
+	}
+	auto it = begin(templates) + pos;
+	emit templateAboutToBeAdded(pos, temp.get(), in_background);
+	it = templates.insert(it, std::move(temp));
+	{
+		QSignalBlocker block(this);
+		setFirstFrontTemplate(front);
+	}
+	emit templateAdded(pos, it->get());
+	setTemplatesDirty();
+}
+
+void Map::moveTemplate(int old_pos, int new_pos)
+{
+	if (old_pos == new_pos)
+		return;
+	
+	auto* temp = getTemplate(old_pos);
+	temp->setTemplateAreaDirty();
+	emit templateAboutToBeMoved(old_pos, new_pos, temp);
+	
+	auto old_it = begin(templates) + old_pos;
+	auto new_it = begin(templates) + new_pos;
+	if (old_pos < new_pos)
+		std::rotate(old_it, old_it + 1, new_it + 1);
+	else
+		std::rotate(new_it, old_it, old_it + 1);
+	
+	emit templateMoved(old_pos, new_pos, temp);
+	temp->setTemplateAreaDirty();
+	setTemplatesDirty();
+}
+
+std::unique_ptr<Template> Map::removeTemplate(int pos)
+{
+	auto front = getFirstFrontTemplate();
+	if (pos < front || getNumTemplates() < front)
+	{
+		--front;
+	}
+	auto const it = begin(templates) + pos;
+	(*it)->setTemplateAreaDirty();
+	emit templateAboutToBeDeleted(pos, it->get());
+	auto temp = std::move(*it);
 	templates.erase(it);
-	emit templateDeleted(pos, temp);
+	{
+		QSignalBlocker block(this);
+		setFirstFrontTemplate(front);
+	}
+	emit templateDeleted(pos, temp.get());
+	setTemplatesDirty();
+	return temp;
 }
 
 void Map::deleteTemplate(int pos)
 {
-	Template* temp = getTemplate(pos);
-	removeTemplate(pos);
-	delete temp;
+	void(removeTemplate(pos));
 }
 
 void Map::setTemplateAreaDirty(Template* temp, const QRectF& area, int pixel_border)
@@ -1813,24 +1884,20 @@ void Map::setTemplateAreaDirty(Template* temp, const QRectF& area, int pixel_bor
 	}
 }
 
-void Map::setTemplateAreaDirty(int i)
+void Map::setTemplateAreaDirty(int pos)
 {
-	if (i == -1)
+	if (pos == -1)
 		return;	// no assert here as convenience, so setTemplateAreaDirty(-1) can be called without effect for the map part
-	Q_ASSERT(i >= 0 && i < (int)templates.size());
-	
-	templates[i]->setTemplateAreaDirty();
+	Q_ASSERT(pos < getNumTemplates());
+	getTemplate(pos)->setTemplateAreaDirty();
 }
 
 int Map::findTemplateIndex(const Template* temp) const
 {
-	int size = (int)templates.size();
-	for (int i = 0; i < size; ++i)
-	{
-		if (templates[i] == temp)
-			return i;
-	}
-	return -1;
+	auto const first = begin(templates);
+	auto const last = end(templates);
+	auto const it = std::find_if(first, last, [temp](auto const& t) { return t.get() == temp; });
+	return it == last ? -1 : int(std::distance(first, it));
 }
 
 void Map::setTemplatesDirty()
@@ -1841,6 +1908,7 @@ void Map::setTemplatesDirty()
 
 void Map::emitTemplateChanged(Template* temp)
 {
+	setTemplatesDirty();
 	auto const pos = findTemplateIndex(temp);
 	if (pos >= 0)
 		emit templateChanged(pos, temp);
@@ -1851,56 +1919,52 @@ void Map::clearClosedTemplates()
 	if (closed_templates.empty())
 		return;
 
-	for (Template* temp : closed_templates)
-		delete temp;
-	
 	closed_templates.clear();
 	setTemplatesDirty();
 	emit closedTemplateAvailabilityChanged();
 }
 
-void Map::closeTemplate(int i)
+void Map::closeTemplate(int pos)
 {
-	Template* temp = getTemplate(i);
-	removeTemplate(i);
+	auto temp = removeTemplate(pos);
 
 	if (temp->getTemplateState() == Template::Loaded)
 		temp->unloadTemplateFile();
 
-	closed_templates.push_back(temp);
+	closed_templates.push_back(std::move(temp));
 	setTemplatesDirty();
 	if (closed_templates.size() == 1)
 		emit closedTemplateAvailabilityChanged();
 }
 
 bool Map::reloadClosedTemplate(int i, int target_pos, QWidget* dialog_parent, const QString& map_path)
 {
-	Template* temp = closed_templates[i];
+	auto const it_closed = begin(closed_templates) + i;
+	auto temp = std::move(*it_closed);
+	closed_templates.erase(it_closed);
 
 	// Try to find and load the template again
-	if (temp->getTemplateState() != Template::Loaded)
+	if (temp->getTemplateState() != Template::Loaded
+	    && !temp->tryToFindAndReloadTemplateFile(map_path))
 	{
-		if (!temp->tryToFindAndReloadTemplateFile(map_path))
-		{
-			if (!temp->execSwitchTemplateFileDialog(dialog_parent))
-				return false;
-		}
+		temp->execSwitchTemplateFileDialog(dialog_parent);
 	}
 
-	// If successfully loaded, add to template list again
-	if (temp->getTemplateState() == Template::Loaded)
+	// If not loaded successfully, re-add to list of closed templates
+	if (temp->getTemplateState() != Template::Loaded)
 	{
-		closed_templates.erase(closed_templates.begin() + i);
-		addTemplate(temp, target_pos);
-		temp->setTemplateAreaDirty();
-		setTemplatesDirty();
-		if (closed_templates.empty())
-			emit closedTemplateAvailabilityChanged();
-		return true;
+		closed_templates.push_back(std::move(temp));
+		return false;
 	}
-	return false;
+	
+	addTemplate(target_pos, std::move(temp));
+	if (closed_templates.empty())
+		emit closedTemplateAvailabilityChanged();
+	return true;
 }
 
+
+
 void Map::push(UndoStep *step)
 {
 	undo_manager->push(std::unique_ptr<UndoStep>(step));
@@ -2090,9 +2154,9 @@ QRectF Map::calculateExtent(bool include_helper_symbols, bool include_templates,
 	// Templates
 	if (include_templates)
 	{
-		for (const Template* temp : templates)
+		for (const auto& temp : templates)
 		{
-			if (view && !view->isTemplateVisible(temp))
+			if (view && !view->isTemplateVisible(temp.get()))
 				continue;
 			if (temp->getTemplateState() != Template::Loaded)
 				continue;