logic: Use ControllerProxy in Bookmarking UI classes instead of messaging

* changed ControllerProxy to template class
* allow passing method pointers and arguments to ControllerProxy
* replaced some messages with ControllerProxy calls
* moved logic from BookmarkView into BookmarkController

src/lib/CMakeLists.txt

@@ -383,17 +383,10 @@ add_files(
 	utility/messaging/type/MessageClearStatusView.h
 	utility/messaging/type/MessageCodeReference.h
 	utility/messaging/type/MessageColorSchemeTest.h
-	utility/messaging/type/MessageCreateBookmark.h
-	utility/messaging/type/MessageCreateBookmarkCategory.h
 	utility/messaging/type/MessageDeactivateEdge.h
-	utility/messaging/type/MessageDeleteBookmark.h
-	utility/messaging/type/MessageDeleteBookmarkCategory.h
-	utility/messaging/type/MessageDeleteBookmarkForActiveTokens.h
 	utility/messaging/type/MessageDispatchWhenLicenseValid.h
 	utility/messaging/type/MessageDisplayBookmarkCreator.h
-	utility/messaging/type/MessageDisplayBookmarkEditor.h
 	utility/messaging/type/MessageDisplayBookmarks.h
-	utility/messaging/type/MessageEditBookmark.h
 	utility/messaging/type/MessageEnteredLicense.h
 	utility/messaging/type/MessageErrorFilterChanged.h
 	utility/messaging/type/MessageFind.h

src/lib/component/controller/BookmarkController.cpp

@@ -1,26 +1,26 @@
 #include "BookmarkController.h"
 
+#include "Application.h"
 #include "component/view/BookmarkView.h"
-
 #include "data/access/StorageAccess.h"
 #include "data/bookmark/Bookmark.h"
+#include "data/bookmark/EdgeBookmark.h"
+#include "data/bookmark/NodeBookmark.h"
 
 #include "utility/messaging/type/MessageActivateEdge.h"
 #include "utility/messaging/type/MessageActivateNodes.h"
-
 #include "utility/logging/logging.h"
 #include "utility/utilityString.h"
 #include "utility/utility.h"
 
-#include "data/bookmark/EdgeBookmark.h"
-#include "data/bookmark/NodeBookmark.h"
-
 const std::string BookmarkController::s_edgeSeperatorToken = " => ";
 const std::string BookmarkController::s_defaultCategoryName = "default";
 
 BookmarkController::BookmarkController(StorageAccess* storageAccess)
 	: m_storageAccess(storageAccess)
 	, m_bookmarkCache(storageAccess)
+	, m_filter(Bookmark::FILTER_ALL)
+	, m_order(Bookmark::ORDER_DATE_DESCENDING)
 {
 }
 
@@ -36,18 +36,326 @@ void BookmarkController::clear()
 	getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CANNOT_CREATE);
 }
 
-std::vector<std::shared_ptr<Bookmark>> BookmarkController::getBookmarks(
-	const MessageDisplayBookmarks::BookmarkFilter& filter, const MessageDisplayBookmarks::BookmarkOrder& order) const
+void BookmarkController::displayBookmarks()
 {
-	LOG_INFO_STREAM(<< "Retrieving bookmarks with filter \"" << std::to_string(filter) << "\" and order \"" << std::to_string(order) << "\"");
+	getView<BookmarkView>()->displayBookmarks(getBookmarks(m_filter, m_order));
+}
 
-	std::vector<std::shared_ptr<Bookmark>> bookmarks = getAllBookmarks();
+void BookmarkController::displayBookmarksFor(Bookmark::BookmarkFilter filter, Bookmark::BookmarkOrder order)
+{
+	if (filter != Bookmark::FILTER_UNKNOWN)
+	{
+		m_filter = filter;
+	}
 
-	bookmarks = getFilteredBookmarks(bookmarks, filter);
+	if (order != Bookmark::ORDER_NONE)
+	{
+		m_order = order;
+	}
 
-	bookmarks = getOrderedBookmarks(bookmarks, order);
+	displayBookmarks();
+}
 
-	return bookmarks;
+void BookmarkController::createBookmark(
+	const std::string& name, const std::string& comment, const std::string& category, Id nodeId
+){
+	LOG_INFO_STREAM(<< "Attempting to create new bookmark");
+
+	BookmarkCategory bookmarkCategory(0, category.empty() ? s_defaultCategoryName : category);
+
+	if (!m_activeEdgeIds.empty())
+	{
+		LOG_INFO_STREAM(<< "Creating Edge Bookmark");
+
+		EdgeBookmark bookmark(0, name, comment, TimeStamp::now(), bookmarkCategory);
+		bookmark.setEdgeIds(m_activeEdgeIds);
+
+		if (!m_activeNodeIds.empty())
+		{
+			bookmark.setActiveNodeId(m_activeNodeIds.front());
+		}
+		else
+		{
+			LOG_ERROR("Cannot create bookmark for edge if no active node exists");
+		}
+
+		m_storageAccess->addEdgeBookmark(bookmark);
+	}
+	else
+	{
+		LOG_INFO_STREAM(<< "Creating Node Bookmark");
+
+		NodeBookmark bookmark(0, name, comment, TimeStamp::now(), bookmarkCategory);
+		if (nodeId)
+		{
+			bookmark.addNodeId(nodeId);
+		}
+		else
+		{
+			bookmark.setNodeIds(m_activeNodeIds);
+		}
+		m_storageAccess->addNodeBookmark(bookmark);
+	}
+
+	m_bookmarkCache.clear();
+
+	if (!nodeId || (m_activeNodeIds.size() == 1 && m_activeNodeIds[0] == nodeId))
+	{
+		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
+	}
+
+	update();
+}
+
+void BookmarkController::editBookmark(
+	Id bookmarkId, const std::string& name, const std::string& comment, const std::string& category
+){
+	LOG_INFO_STREAM(<< "Attempting to update Bookmark " << bookmarkId);
+
+	m_storageAccess->updateBookmark(bookmarkId, name, comment, category.size() ? category : s_defaultCategoryName);
+
+	cleanBookmarkCategories();
+
+	update();
+}
+
+void BookmarkController::deleteBookmark(Id bookmarkId)
+{
+	LOG_INFO_STREAM(<< "Attempting to delete Bookmark " << bookmarkId);
+
+	m_storageAccess->removeBookmark(bookmarkId);
+
+	cleanBookmarkCategories();
+
+	if (!getBookmarkForActiveToken())
+	{
+		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+	}
+
+	update();
+}
+
+void BookmarkController::deleteBookmarkCategory(Id categoryId)
+{
+	m_storageAccess->removeBookmarkCategory(categoryId);
+
+	m_bookmarkCache.clear();
+
+	if (!getBookmarkForActiveToken())
+	{
+		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+	}
+
+	update();
+}
+
+void BookmarkController::deleteBookmarkForActiveTokens()
+{
+	if (std::shared_ptr<Bookmark> bookmark = getBookmarkForActiveToken())
+	{
+		LOG_INFO_STREAM(<< "Deleting bookmark " << bookmark->getName());
+
+		m_storageAccess->removeBookmark(bookmark->getId());
+
+		cleanBookmarkCategories();
+
+		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+		update();
+	}
+	else
+	{
+		LOG_WARNING_STREAM(<< "No Bookmark to delete for active tokens.");
+	}
+}
+
+void BookmarkController::activateBookmark(const std::shared_ptr<Bookmark> bookmark)
+{
+	LOG_INFO_STREAM(<< "Attempting to activate Bookmark");
+
+	if (std::shared_ptr<EdgeBookmark> edgeBookmark = std::dynamic_pointer_cast<EdgeBookmark>(bookmark))
+	{
+		if (!edgeBookmark->getEdgeIds().empty())
+		{
+			const Id firstEdgeId = edgeBookmark->getEdgeIds().front();
+			const StorageEdge storageEdge = m_storageAccess->getEdgeById(firstEdgeId);
+
+			const NameHierarchy sourceName = m_storageAccess->getNameHierarchyForNodeId(storageEdge.sourceNodeId);
+			const NameHierarchy targetName = m_storageAccess->getNameHierarchyForNodeId(storageEdge.targetNodeId);
+
+			if (edgeBookmark->getEdgeIds().size() == 1)
+			{
+				Id activeNodeId = edgeBookmark->getActiveNodeId();
+				if (activeNodeId)
+				{
+					MessageActivateNodes activateNodes;
+					activateNodes.addNode(activeNodeId, m_storageAccess->getNameHierarchyForNodeId(activeNodeId));
+					activateNodes.dispatch();
+				}
+
+				MessageActivateEdge(firstEdgeId, Edge::intToType(storageEdge.type), sourceName, targetName).dispatch();
+			}
+			else
+			{
+				MessageActivateEdge activateEdge(0, Edge::EdgeType::EDGE_AGGREGATION, sourceName, targetName);
+				for (const Id aggregatedEdgeId: edgeBookmark->getEdgeIds())
+				{
+					activateEdge.aggregationIds.push_back(aggregatedEdgeId);
+				}
+				activateEdge.dispatch();
+			}
+		}
+		else
+		{
+			LOG_ERROR_STREAM(<< "Failed to activate bookmark, did not find edges to activate");
+		}
+	}
+	else if (std::shared_ptr<NodeBookmark> nodeBookmark = std::dynamic_pointer_cast<NodeBookmark>(bookmark))
+	{
+		MessageActivateNodes activateNodes;
+
+		for (Id nodeId: nodeBookmark->getNodeIds())
+		{
+			activateNodes.addNode(nodeId, m_storageAccess->getNameHierarchyForNodeId(nodeId));
+		}
+
+		activateNodes.dispatch();
+	}
+}
+
+void BookmarkController::showBookmarkCreator(Id nodeId)
+{
+	if (!canCreateBookmark() && !nodeId)
+	{
+		return;
+	}
+
+	BookmarkView* view = getView<BookmarkView>();
+
+	if (nodeId)
+	{
+		std::shared_ptr<Bookmark> bookmark = getBookmarkForNodeId(nodeId);
+		if (bookmark != nullptr)
+		{
+			view->displayBookmarkEditor(bookmark, getAllBookmarkCategories());
+		}
+		else
+		{
+			view->displayBookmarkCreator(getDisplayNamesForNodeId(nodeId), getAllBookmarkCategories(), nodeId);
+		}
+	}
+	else
+	{
+		std::shared_ptr<Bookmark> bookmark = getBookmarkForActiveToken();
+		if (bookmark != nullptr)
+		{
+			view->displayBookmarkEditor(bookmark, getAllBookmarkCategories());
+		}
+		else
+		{
+			view->displayBookmarkCreator(getActiveTokenDisplayNames(), getAllBookmarkCategories(), 0);
+		}
+	}
+}
+
+void BookmarkController::showBookmarkEditor(const std::shared_ptr<Bookmark> bookmark)
+{
+	getView<BookmarkView>()->displayBookmarkEditor(bookmark, getAllBookmarkCategories());
+}
+
+BookmarkController::BookmarkCache::BookmarkCache(StorageAccess* storageAccess)
+	: m_storageAccess(storageAccess)
+{
+}
+
+void BookmarkController::BookmarkCache::clear()
+{
+	m_nodeBookmarksValid = false;
+	m_edgeBookmarksValid = false;
+}
+
+std::vector<NodeBookmark> BookmarkController::BookmarkCache::getAllNodeBookmarks()
+{
+	if (!m_nodeBookmarksValid)
+	{
+		m_nodeBookmarks = m_storageAccess->getAllNodeBookmarks();
+		m_nodeBookmarksValid = true;
+	}
+	return m_nodeBookmarks;
+}
+
+std::vector<EdgeBookmark> BookmarkController::BookmarkCache::getAllEdgeBookmarks()
+{
+	if (!m_edgeBookmarksValid)
+	{
+		m_edgeBookmarks = m_storageAccess->getAllEdgeBookmarks();
+		m_edgeBookmarksValid = true;
+	}
+	return m_edgeBookmarks;
+}
+
+void BookmarkController::handleMessage(MessageActivateAll* message)
+{
+	clear();
+}
+
+void BookmarkController::handleMessage(MessageActivateBookmark* message)
+{
+	activateBookmark(message->bookmark);
+}
+
+void BookmarkController::handleMessage(MessageActivateTokens* message)
+{
+	m_activeEdgeIds.clear();
+
+	if (message->isEdge || message->isAggregation)
+	{
+		m_activeEdgeIds = message->tokenIds;
+
+		if (getBookmarkForActiveToken())
+		{
+			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
+		}
+		else
+		{
+			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+		}
+	}
+	else if (!message->isEdge)
+	{
+		m_activeNodeIds = message->tokenIds;
+
+		if (getBookmarkForActiveToken())
+		{
+			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
+		}
+		else
+		{
+			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+		}
+	}
+}
+
+void BookmarkController::handleMessage(MessageDisplayBookmarks* message)
+{
+	displayBookmarksFor(message->filter, message->order);
+}
+
+void BookmarkController::handleMessage(MessageDisplayBookmarkCreator* message)
+{
+	showBookmarkCreator(message->nodeId);
+}
+
+void BookmarkController::handleMessage(MessageFinishedParsing* message)
+{
+	m_bookmarkCache.clear();
+	getView<BookmarkView>()->enableDisplayBookmarks(true);
+
+	update();
+}
+
+void BookmarkController::handleMessage(MessageShowErrors* message)
+{
+	clear();
 }
 
 std::vector<std::string> BookmarkController::getActiveTokenDisplayNames() const
@@ -117,259 +425,6 @@ bool BookmarkController::canCreateBookmark() const
 	return m_activeNodeIds.size() || m_activeEdgeIds.size();
 }
 
-BookmarkController::BookmarkCache::BookmarkCache(StorageAccess* storageAccess)
-	: m_storageAccess(storageAccess)
-{
-}
-
-void BookmarkController::BookmarkCache::clear()
-{
-	m_nodeBookmarksValid = false;
-	m_edgeBookmarksValid = false;
-}
-
-std::vector<NodeBookmark> BookmarkController::BookmarkCache::getAllNodeBookmarks()
-{
-	if (!m_nodeBookmarksValid)
-	{
-		m_nodeBookmarks = m_storageAccess->getAllNodeBookmarks();
-		m_nodeBookmarksValid = true;
-	}
-	return m_nodeBookmarks;
-}
-
-std::vector<EdgeBookmark> BookmarkController::BookmarkCache::getAllEdgeBookmarks()
-{
-	if (!m_edgeBookmarksValid)
-	{
-		m_edgeBookmarks = m_storageAccess->getAllEdgeBookmarks();
-		m_edgeBookmarksValid = true;
-	}
-	return m_edgeBookmarks;
-}
-
-void BookmarkController::handleMessage(MessageActivateAll* message)
-{
-	clear();
-}
-
-void BookmarkController::handleMessage(MessageActivateBookmark* message)
-{
-	LOG_INFO_STREAM(<< "Attempting to activate Bookmark");
-
-	if (std::shared_ptr<EdgeBookmark> bookmark = std::dynamic_pointer_cast<EdgeBookmark>(message->bookmark))
-	{
-		if (!bookmark->getEdgeIds().empty())
-		{
-			const Id firstEdgeId = bookmark->getEdgeIds().front();
-			const StorageEdge storageEdge = m_storageAccess->getEdgeById(firstEdgeId);
-
-			const NameHierarchy sourceName = m_storageAccess->getNameHierarchyForNodeId(storageEdge.sourceNodeId);
-			const NameHierarchy targetName = m_storageAccess->getNameHierarchyForNodeId(storageEdge.targetNodeId);
-
-			if (bookmark->getEdgeIds().size() == 1)
-			{
-				Id activeNodeId = bookmark->getActiveNodeId();
-				if (activeNodeId)
-				{
-					MessageActivateNodes activateNodes;
-					activateNodes.addNode(activeNodeId, m_storageAccess->getNameHierarchyForNodeId(activeNodeId));
-					activateNodes.dispatch();
-				}
-
-				MessageActivateEdge(firstEdgeId, Edge::intToType(storageEdge.type), sourceName, targetName).dispatch();
-			}
-			else
-			{
-				MessageActivateEdge activateEdge(0, Edge::EdgeType::EDGE_AGGREGATION, sourceName, targetName);
-				for (const Id aggregatedEdgeId: bookmark->getEdgeIds())
-				{
-					activateEdge.aggregationIds.push_back(aggregatedEdgeId);
-				}
-				activateEdge.dispatch();
-			}
-		}
-		else
-		{
-			LOG_ERROR_STREAM(<< "Failed to activate bookmark, did not find edges to activate");
-		}
-	}
-	else if (std::shared_ptr<NodeBookmark> bookmark = std::dynamic_pointer_cast<NodeBookmark>(message->bookmark))
-	{
-		MessageActivateNodes activateNodes;
-
-		for (Id nodeId: bookmark->getNodeIds())
-		{
-			activateNodes.addNode(nodeId, m_storageAccess->getNameHierarchyForNodeId(nodeId));
-		}
-
-		activateNodes.dispatch();
-	}
-}
-
-void BookmarkController::handleMessage(MessageActivateTokens* message)
-{
-	m_activeEdgeIds.clear();
-
-	if (message->isEdge || message->isAggregation)
-	{
-		m_activeEdgeIds = message->tokenIds;
-
-		if (getBookmarkForActiveToken())
-		{
-			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
-		}
-		else
-		{
-			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
-		}
-	}
-	else if (!message->isEdge)
-	{
-		m_activeNodeIds = message->tokenIds;
-
-		if (getBookmarkForActiveToken())
-		{
-			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
-		}
-		else
-		{
-			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
-		}
-	}
-}
-
-void BookmarkController::handleMessage(MessageCreateBookmark* message)
-{
-	LOG_INFO_STREAM(<< "Attempting to create new bookmark");
-
-	BookmarkCategory category(0, message->categoryName.empty() ? s_defaultCategoryName : message->categoryName);
-
-	if (!m_activeEdgeIds.empty())
-	{
-		LOG_INFO_STREAM(<< "Creating Edge Bookmark");
-
-		EdgeBookmark bookmark(0, message->displayName, message->comment, TimeStamp::now(), category);
-		bookmark.setEdgeIds(m_activeEdgeIds);
-
-		if (!m_activeNodeIds.empty())
-		{
-			bookmark.setActiveNodeId(m_activeNodeIds.front());
-		}
-		else
-		{
-			LOG_ERROR("Cannot create bookmark for edge if no active node exists");
-		}
-
-		m_storageAccess->addEdgeBookmark(bookmark);
-	}
-	else
-	{
-		LOG_INFO_STREAM(<< "Creating Node Bookmark");
-
-		NodeBookmark bookmark(0, message->displayName, message->comment, TimeStamp::now(), category);
-		if (message->nodeId)
-		{
-			bookmark.addNodeId(message->nodeId);
-		}
-		else
-		{
-			bookmark.setNodeIds(m_activeNodeIds);
-		}
-		m_storageAccess->addNodeBookmark(bookmark);
-	}
-
-	m_bookmarkCache.clear();
-
-	if (!message->nodeId || (m_activeNodeIds.size() == 1 && m_activeNodeIds[0] == message->nodeId))
-	{
-		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
-	}
-
-	getView<BookmarkView>()->update();
-}
-
-void BookmarkController::handleMessage(MessageCreateBookmarkCategory* message)
-{
-	const std::string& categoryName = message->name.empty() ? s_defaultCategoryName : message->name;
-	LOG_INFO_STREAM(<< "Attempting to create new Bookmark category \"" << categoryName << "\"");
-	m_storageAccess->addBookmarkCategory(categoryName);
-}
-
-void BookmarkController::handleMessage(MessageDeleteBookmark* message)
-{
-	LOG_INFO_STREAM(<< "Attempting to delete Bookmark " << std::to_string(message->bookmarkId));
-
-	m_storageAccess->removeBookmark(message->bookmarkId);
-
-	cleanBookmarkCategories();
-
-	if (!getBookmarkForActiveToken())
-	{
-		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
-	}
-
-	getView<BookmarkView>()->update();
-}
-
-void BookmarkController::handleMessage(MessageDeleteBookmarkCategory* message)
-{
-	m_storageAccess->removeBookmarkCategory(message->categoryId);
-
-	m_bookmarkCache.clear();
-
-	if (!getBookmarkForActiveToken())
-	{
-		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
-	}
-
-	getView<BookmarkView>()->update();
-}
-
-void BookmarkController::handleMessage(MessageDeleteBookmarkForActiveTokens* message)
-{
-	if (std::shared_ptr<Bookmark> bookmark = getBookmarkForActiveToken())
-	{
-		LOG_INFO_STREAM(<< "Deleting bookmark " << bookmark->getName());
-
-		m_storageAccess->removeBookmark(bookmark->getId());
-
-		cleanBookmarkCategories();
-
-		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
-		getView<BookmarkView>()->update();
-	}
-	else
-	{
-		LOG_WARNING_STREAM(<< "No Bookmark to delete for active tokens.");
-	}
-}
-
-void BookmarkController::handleMessage(MessageEditBookmark* message)
-{
-	LOG_INFO_STREAM(<< "Attempting to update Bookmark " << std::to_string(message->bookmarkId));
-
-	const std::string& categoryName = message->categoryName.empty() ? s_defaultCategoryName : message->categoryName;
-	m_storageAccess->updateBookmark(message->bookmarkId, message->displayName, message->comment, categoryName);
-
-	cleanBookmarkCategories();
-
-	getView<BookmarkView>()->update();
-}
-
-void BookmarkController::handleMessage(MessageFinishedParsing* message)
-{
-	m_bookmarkCache.clear();
-	getView<BookmarkView>()->enableDisplayBookmarks(true);
-
-	getView<BookmarkView>()->update();
-}
-
-void BookmarkController::handleMessage(MessageShowErrors* message)
-{
-	clear();
-}
-
 std::vector<std::shared_ptr<Bookmark>> BookmarkController::getAllBookmarks() const
 {
 	LOG_INFO_STREAM(<< "Retrieving all bookmarks");
@@ -408,6 +463,17 @@ std::vector<std::shared_ptr<EdgeBookmark>> BookmarkController::getAllEdgeBookmar
 	return bookmarks;
 }
 
+std::vector<std::shared_ptr<Bookmark>> BookmarkController::getBookmarks(
+	Bookmark::BookmarkFilter filter, Bookmark::BookmarkOrder order
+) const {
+	LOG_INFO_STREAM(<< "Retrieving bookmarks with filter \"" << filter << "\" and order \"" << order << "\"");
+
+	std::vector<std::shared_ptr<Bookmark>> bookmarks = getAllBookmarks();
+	bookmarks = getFilteredBookmarks(bookmarks, filter);
+	bookmarks = getOrderedBookmarks(bookmarks, order);
+	return bookmarks;
+}
+
 std::vector<std::string> BookmarkController::getActiveNodeDisplayNames() const
 {
 	std::vector<std::string> names;
@@ -445,15 +511,15 @@ std::string BookmarkController::getNodeDisplayName(const Id nodeId) const
 }
 
 std::vector<std::shared_ptr<Bookmark>> BookmarkController::getFilteredBookmarks(
-	const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const MessageDisplayBookmarks::BookmarkFilter& filter) const
+	const std::vector<std::shared_ptr<Bookmark>>& bookmarks, Bookmark::BookmarkFilter filter) const
 {
 	std::vector<std::shared_ptr<Bookmark>> result;
 
-	if (filter == MessageDisplayBookmarks::BookmarkFilter::ALL)
+	if (filter == Bookmark::FILTER_ALL)
 	{
 		return bookmarks;
 	}
-	else if (filter == MessageDisplayBookmarks::BookmarkFilter::NODES)
+	else if (filter == Bookmark::FILTER_NODES)
 	{
 		for (const std::shared_ptr<Bookmark>& bookmark: bookmarks)
 		{
@@ -463,7 +529,7 @@ std::vector<std::shared_ptr<Bookmark>> BookmarkController::getFilteredBookmarks(
 			}
 		}
 	}
-	else if (filter == MessageDisplayBookmarks::BookmarkFilter::EDGES)
+	else if (filter == Bookmark::FILTER_EDGES)
 	{
 		for (const std::shared_ptr<Bookmark>& bookmark: bookmarks)
 		{
@@ -478,23 +544,23 @@ std::vector<std::shared_ptr<Bookmark>> BookmarkController::getFilteredBookmarks(
 }
 
 std::vector<std::shared_ptr<Bookmark>> BookmarkController::getOrderedBookmarks(
-	const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const MessageDisplayBookmarks::BookmarkOrder& order) const
+	const std::vector<std::shared_ptr<Bookmark>>& bookmarks, Bookmark::BookmarkOrder order) const
 {
 	std::vector<std::shared_ptr<Bookmark>> result = bookmarks;
 
-	if (order == MessageDisplayBookmarks::BookmarkOrder::DATE_ASCENDING)
+	if (order == Bookmark::ORDER_DATE_ASCENDING)
 	{
 		return getDateOrderedBookmarks(result, true);
 	}
-	else if (order == MessageDisplayBookmarks::BookmarkOrder::DATE_DESCENDING)
+	else if (order == Bookmark::ORDER_DATE_DESCENDING)
 	{
 		return getDateOrderedBookmarks(result, false);
 	}
-	else if (order == MessageDisplayBookmarks::BookmarkOrder::NAME_ASCENDING)
+	else if (order == Bookmark::ORDER_NAME_ASCENDING)
 	{
 		return getNameOrderedBookmarks(result, true);
 	}
-	else if (order == MessageDisplayBookmarks::BookmarkOrder::NAME_DESCENDING)
+	else if (order == Bookmark::ORDER_NAME_DESCENDING)
 	{
 		return getNameOrderedBookmarks(result, false);
 	}
@@ -588,3 +654,22 @@ bool BookmarkController::bookmarkNameCompare(const std::shared_ptr<Bookmark> a,
 
 	return aName.length() < bName.length();
 }
+
+void BookmarkController::update()
+{
+	BookmarkView* view = getView<BookmarkView>();
+	if (view->bookmarkBrowserIsVisible())
+	{
+		view->displayBookmarks(getBookmarks(m_filter, m_order));
+	}
+
+	std::vector<std::shared_ptr<Bookmark>> bookmarks = getBookmarks(Bookmark::FILTER_ALL, Bookmark::ORDER_DATE_DESCENDING);
+
+	const size_t maxBookmarkMenuCount = 20;
+	if (bookmarks.size() > maxBookmarkMenuCount)
+	{
+		bookmarks.resize(maxBookmarkMenuCount);
+	}
+
+	Application::getInstance()->updateBookmarks(bookmarks);
+}

src/lib/component/controller/BookmarkController.h

@@ -9,13 +9,8 @@
 #include "utility/messaging/type/MessageActivateAll.h"
 #include "utility/messaging/type/MessageActivateBookmark.h"
 #include "utility/messaging/type/MessageActivateTokens.h"
-#include "utility/messaging/type/MessageCreateBookmark.h"
-#include "utility/messaging/type/MessageCreateBookmarkCategory.h"
-#include "utility/messaging/type/MessageDeleteBookmark.h"
-#include "utility/messaging/type/MessageDeleteBookmarkCategory.h"
-#include "utility/messaging/type/MessageDeleteBookmarkForActiveTokens.h"
+#include "utility/messaging/type/MessageDisplayBookmarkCreator.h"
 #include "utility/messaging/type/MessageDisplayBookmarks.h"
-#include "utility/messaging/type/MessageEditBookmark.h"
 #include "utility/messaging/type/MessageFinishedParsing.h"
 #include "utility/messaging/type/MessageShowErrors.h"
 
@@ -28,12 +23,8 @@ class BookmarkController
 	, public MessageListener<MessageActivateAll>
 	, public MessageListener<MessageActivateBookmark>
 	, public MessageListener<MessageActivateTokens>
-	, public MessageListener<MessageCreateBookmark>
-	, public MessageListener<MessageCreateBookmarkCategory>
-	, public MessageListener<MessageDeleteBookmark>
-	, public MessageListener<MessageDeleteBookmarkCategory>
-	, public MessageListener<MessageDeleteBookmarkForActiveTokens>
-	, public MessageListener<MessageEditBookmark>
+	, public MessageListener<MessageDisplayBookmarkCreator>
+	, public MessageListener<MessageDisplayBookmarks>
 	, public MessageListener<MessageFinishedParsing>
 	, public MessageListener<MessageShowErrors>
 {
@@ -43,18 +34,20 @@ public:
 
 	virtual void clear();
 
-	std::vector<std::shared_ptr<Bookmark>> getBookmarks(
-		const MessageDisplayBookmarks::BookmarkFilter& filter, const MessageDisplayBookmarks::BookmarkOrder& order) const;
+	void displayBookmarks();
+	void displayBookmarksFor(Bookmark::BookmarkFilter filter, Bookmark::BookmarkOrder order);
 
-	std::vector<std::string> getActiveTokenDisplayNames() const;
-	std::vector<std::string> getDisplayNamesForNodeId(Id nodeId) const;
+	void createBookmark(const std::string& name, const std::string& comment, const std::string& category, Id nodeId);
+	void editBookmark(Id bookmarkId, const std::string& name, const std::string& comment, const std::string& category);
 
-	std::vector<BookmarkCategory> getAllBookmarkCategories() const;
+	void deleteBookmark(Id bookmarkId);
+	void deleteBookmarkCategory(Id categoryId);
+	void deleteBookmarkForActiveTokens();
 
-	std::shared_ptr<Bookmark> getBookmarkForActiveToken() const;
-	std::shared_ptr<Bookmark> getBookmarkForNodeId(Id nodeId) const;
+	void activateBookmark(const std::shared_ptr<Bookmark> bookmark);
 
-	bool canCreateBookmark() const;
+	void showBookmarkCreator(Id nodeId = 0);
+	void showBookmarkEditor(const std::shared_ptr<Bookmark> bookmark);
 
 private:
 	class BookmarkCache
@@ -78,27 +71,35 @@ private:
 	virtual void handleMessage(MessageActivateAll* message);
 	virtual void handleMessage(MessageActivateBookmark* message);
 	virtual void handleMessage(MessageActivateTokens* message);
-	virtual void handleMessage(MessageCreateBookmark* message);
-	virtual void handleMessage(MessageCreateBookmarkCategory* message);
-	virtual void handleMessage(MessageDeleteBookmark* message);
-	virtual void handleMessage(MessageDeleteBookmarkCategory* message);
-	virtual void handleMessage(MessageDeleteBookmarkForActiveTokens* message);
-	virtual void handleMessage(MessageEditBookmark* message);
+	virtual void handleMessage(MessageDisplayBookmarkCreator* message);
+	virtual void handleMessage(MessageDisplayBookmarks* message);
 	virtual void handleMessage(MessageFinishedParsing* message);
 	virtual void handleMessage(MessageShowErrors* message);
 
+	std::vector<std::string> getActiveTokenDisplayNames() const;
+	std::vector<std::string> getDisplayNamesForNodeId(Id nodeId) const;
+
+	std::vector<BookmarkCategory> getAllBookmarkCategories() const;
+
+	std::shared_ptr<Bookmark> getBookmarkForActiveToken() const;
+	std::shared_ptr<Bookmark> getBookmarkForNodeId(Id nodeId) const;
+
+	bool canCreateBookmark() const;
+
 	std::vector<std::shared_ptr<Bookmark>> getAllBookmarks() const;
 	std::vector<std::shared_ptr<NodeBookmark>> getAllNodeBookmarks() const;
 	std::vector<std::shared_ptr<EdgeBookmark>> getAllEdgeBookmarks() const;
+	std::vector<std::shared_ptr<Bookmark>> getBookmarks(
+		Bookmark::BookmarkFilter filter, Bookmark::BookmarkOrder order) const;
 
 	std::vector<std::string> getActiveNodeDisplayNames() const;
 	std::vector<std::string> getActiveEdgeDisplayNames() const;
 	std::string getNodeDisplayName(const Id id) const;
 
 	std::vector<std::shared_ptr<Bookmark>> getFilteredBookmarks(
-		const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const MessageDisplayBookmarks::BookmarkFilter& filter) const;
+		const std::vector<std::shared_ptr<Bookmark>>& bookmarks, Bookmark::BookmarkFilter filter) const;
 	std::vector<std::shared_ptr<Bookmark>> getOrderedBookmarks(
-		const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const MessageDisplayBookmarks::BookmarkOrder& order) const;
+		const std::vector<std::shared_ptr<Bookmark>>& bookmarks, Bookmark::BookmarkOrder order) const;
 	std::vector<std::shared_ptr<Bookmark>> getDateOrderedBookmarks(
 		const std::vector<std::shared_ptr<Bookmark>>& bookmarks, const bool ascending) const;
 	std::vector<std::shared_ptr<Bookmark>> getNameOrderedBookmarks(
@@ -109,6 +110,8 @@ private:
 	static bool bookmarkDateCompare(const std::shared_ptr<Bookmark> a, const std::shared_ptr<Bookmark> b);
 	static bool bookmarkNameCompare(const std::shared_ptr<Bookmark> a, const std::shared_ptr<Bookmark> b);
 
+	void update();
+
 	static const std::string s_edgeSeperatorToken;
 	static const std::string s_defaultCategoryName;
 
@@ -117,6 +120,9 @@ private:
 
 	std::vector<Id> m_activeNodeIds;
 	std::vector<Id> m_activeEdgeIds;
+
+	Bookmark::BookmarkFilter m_filter;
+	Bookmark::BookmarkOrder m_order;
 };
 
 #endif // BOOKMARK_CONTROLLER_H

src/lib/component/controller/helper/ControllerProxy.h

@@ -7,6 +7,7 @@
 
 #include "component/view/View.h"
 
+template <typename ControllerType>
 class ControllerProxy
 {
 public:
@@ -15,7 +16,6 @@ public:
 	{
 	}
 
-	template<typename ControllerType>
 	void execute(std::function<void(ControllerType*)> callback)
 	{
 		ControllerType* controller = m_view->getController<ControllerType>();
@@ -25,16 +25,27 @@ public:
 		}
 	}
 
-	template<typename ControllerType>
 	void executeAsTask(std::function<void(ControllerType*)> callback)
 	{
 		ControllerType* controller = m_view->getController<ControllerType>();
 		if (controller)
 		{
 			Task::dispatch(std::make_shared<TaskLambda>(
-				[callback, controller]()
+				std::bind(callback, controller)
+			));
+		}
+	}
+
+	template<typename FuncType, typename... Args>
+	void executeAsTaskWithArgs(FuncType callback, const Args... args)
+	{
+		ControllerType* controller = m_view->getController<ControllerType>();
+		if (controller)
+		{
+			Task::dispatch(std::make_shared<TaskLambda>(
+				[func = std::bind(callback, controller, args...)]()
 				{
-					callback(controller);
+					func();
 				}
 			));
 		}

src/lib/component/view/BookmarkView.cpp

@@ -1,12 +1,9 @@
 #include "component/view/BookmarkView.h"
 
-#include "Application.h"
 #include "component/controller/BookmarkController.h"
 
 BookmarkView::BookmarkView(ViewLayout* viewLayout)
 	: View(viewLayout)
-	, m_filter(MessageDisplayBookmarks::BookmarkFilter::ALL)
-	, m_order(MessageDisplayBookmarks::BookmarkOrder::DATE_DESCENDING)
 {
 }
 
@@ -19,84 +16,7 @@ std::string BookmarkView::getName() const
 	return "BookmarkView";
 }
 
-void BookmarkView::update()
-{
-	if (bookmarkBrowserIsVisible())
-	{
-		displayBookmarks(getController()->getBookmarks(m_filter, m_order));
-	}
-
-	std::vector<std::shared_ptr<Bookmark>> bookmarks = getController()->getBookmarks(
-		MessageDisplayBookmarks::BookmarkFilter::ALL,
-		MessageDisplayBookmarks::BookmarkOrder::DATE_DESCENDING
-	);
-
-	const size_t maxBookmarkMenuCount = 20;
-	if (bookmarks.size() > maxBookmarkMenuCount)
-	{
-		bookmarks.resize(maxBookmarkMenuCount);
-	}
-
-	Application::getInstance()->updateBookmarks(bookmarks);
-}
-
 BookmarkController* BookmarkView::getController()
 {
 	return View::getController<BookmarkController>();
 }
-
-void BookmarkView::handleMessage(MessageDisplayBookmarks* message)
-{
-	if (bookmarkBrowserIsVisible() == true)
-	{
-		m_filter = message->filter;
-		m_order = message->order;
-
-		displayBookmarks(getController()->getBookmarks(message->filter, message->order));
-	}
-
-	displayBookmarks(getController()->getBookmarks(m_filter, m_order));
-}
-
-void BookmarkView::handleMessage(MessageDisplayBookmarkCreator* message)
-{
-	if (!getController()->canCreateBookmark() && !message->nodeId)
-	{
-		return;
-	}
-
-	if (message->nodeId)
-	{
-		if (getController()->getBookmarkForNodeId(message->nodeId) != nullptr)
-		{
-			displayBookmarkEditor(
-				getController()->getBookmarkForNodeId(message->nodeId),
-				getController()->getAllBookmarkCategories()
-			);
-		}
-		else
-		{
-			displayBookmarkCreator(
-				getController()->getDisplayNamesForNodeId(message->nodeId),
-				getController()->getAllBookmarkCategories(),
-				message->nodeId
-			);
-		}
-	}
-	else
-	{
-		if (getController()->getBookmarkForActiveToken() != nullptr)
-		{
-			displayBookmarkEditor(getController()->getBookmarkForActiveToken(), getController()->getAllBookmarkCategories());
-		}
-		else
-		{
-			displayBookmarkCreator(getController()->getActiveTokenDisplayNames(), getController()->getAllBookmarkCategories(), 0);
-		}
-	}
-}
-
-void BookmarkView::handleMessage(MessageDisplayBookmarkEditor* message)
-{
-	displayBookmarkEditor(message->bookmark, getController()->getAllBookmarkCategories());
-}

src/lib/component/view/BookmarkView.h

@@ -1,22 +1,13 @@
 #ifndef BOOKMARK_VIEW_H
 #define BOOKMARK_VIEW_H
 
-#include "data/bookmark/Bookmark.h"
-
 #include "component/view/View.h"
-
-#include "utility/messaging/MessageListener.h"
-#include "utility/messaging/type/MessageDisplayBookmarks.h"
-#include "utility/messaging/type/MessageDisplayBookmarkCreator.h"
-#include "utility/messaging/type/MessageDisplayBookmarkEditor.h"
+#include "data/bookmark/Bookmark.h"
 
 class BookmarkController;
 
 class BookmarkView
 	: public View
-	, public MessageListener<MessageDisplayBookmarks>
-	, public MessageListener<MessageDisplayBookmarkCreator>
-	, public MessageListener<MessageDisplayBookmarkEditor>
 {
 public:
 	BookmarkView(ViewLayout* viewLayout);
@@ -32,25 +23,18 @@ public:
 	};
 
 	virtual void setCreateButtonState(const CreateButtonState& state) = 0;
-	virtual void enableDisplayBookmarks(bool enable) = 0;
 
-	virtual void update();
+	virtual void displayBookmarks(const std::vector<std::shared_ptr<Bookmark>>& bookmarks) = 0;
+	virtual void displayBookmarkEditor(
+		std::shared_ptr<Bookmark> bookmark, const std::vector<BookmarkCategory>& categories) = 0;
+	virtual void displayBookmarkCreator(
+		const std::vector<std::string>& names, const std::vector<BookmarkCategory>& categories, Id nodeId) = 0;
+	virtual void enableDisplayBookmarks(bool enable) = 0;
 
 	virtual bool bookmarkBrowserIsVisible() const = 0;
 
 private:
 	BookmarkController* getController();
-
-	virtual void handleMessage(MessageDisplayBookmarks* message);
-	virtual void handleMessage(MessageDisplayBookmarkCreator* message);
-	virtual void handleMessage(MessageDisplayBookmarkEditor* message);
-
-	virtual void displayBookmarks(const std::vector<std::shared_ptr<Bookmark>>& bookmarks) = 0;
-	virtual void displayBookmarkCreator(const std::vector<std::string>& names, const std::vector<BookmarkCategory>& categories, Id nodeId) = 0;
-	virtual void displayBookmarkEditor(std::shared_ptr<Bookmark> bookmark, const std::vector<BookmarkCategory>& categories) = 0;
-
-	MessageDisplayBookmarks::BookmarkFilter m_filter;
-	MessageDisplayBookmarks::BookmarkOrder m_order;
 };
 
 #endif // BOOKMARK_VIEW_H

src/lib/component/view/View.h

@@ -8,6 +8,8 @@
 #include "component/view/ViewLayout.h"
 
 class ViewWidgetWrapper;
+
+template <typename ControllerType>
 class ControllerProxy;
 
 class View
@@ -44,7 +46,8 @@ protected:
 	void setWidgetWrapper(std::shared_ptr<ViewWidgetWrapper> widgetWrapper);
 
 private:
-	friend ControllerProxy;
+	template <typename ControllerType>
+	friend class ControllerProxy;
 
 	Component* m_component;
 	ViewLayout* const m_viewLayout;

src/lib/data/bookmark/Bookmark.h

@@ -12,6 +12,23 @@
 class Bookmark
 {
 public:
+	enum BookmarkFilter
+	{
+		FILTER_UNKNOWN = 0,
+		FILTER_ALL,
+		FILTER_NODES,
+		FILTER_EDGES
+	};
+
+	enum BookmarkOrder
+	{
+		ORDER_NONE = 0,
+		ORDER_DATE_ASCENDING,
+		ORDER_DATE_DESCENDING,
+		ORDER_NAME_ASCENDING,
+		ORDER_NAME_DESCENDING
+	};
+
 	Bookmark(const Id id, const std::string& name, const std::string& comment, const TimeStamp& timeStamp, const BookmarkCategory& category);
 	virtual ~Bookmark();
 

src/lib/utility/messaging/type/MessageCreateBookmark.h

@@ -1,33 +0,0 @@
-#ifndef MESSAGE_CREATE_BOOKMARK_H
-#define MESSAGE_CREATE_BOOKMARK_H
-
-#include "utility/messaging/Message.h"
-
-class MessageCreateBookmark
-	: public Message<MessageCreateBookmark>
-{
-public:
-	MessageCreateBookmark(const std::string& comment, const std::string& displayName, const std::string& categoryName, Id nodeId)
-		: comment(comment)
-		, displayName(displayName)
-		, categoryName(categoryName)
-		, nodeId(nodeId)
-	{
-	}
-
-	~MessageCreateBookmark()
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageCreateBookmark";
-	}
-
-	const std::string comment;
-	const std::string displayName;
-	const std::string categoryName;
-	const Id nodeId;
-};
-
-#endif // MESSAGE_CREATE_BOOKMARK_H

src/lib/utility/messaging/type/MessageCreateBookmarkCategory.h

@@ -1,23 +0,0 @@
-#ifndef MESSAGE_CREATE_BOOKMARK_CATEGORY_H
-#define MESSAGE_CREATE_BOOKMARK_CATEGORY_H
-
-#include "utility/messaging/Message.h"
-
-class MessageCreateBookmarkCategory
-	: public Message<MessageCreateBookmarkCategory>
-{
-public:
-	MessageCreateBookmarkCategory(const std::string& name)
-		: name(name)
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageCreateBookmarkCategory";
-	}
-
-	const std::string name;
-};
-
-#endif // MESSAGE_CREATE_BOOKMARK_CATEGORY_H

src/lib/utility/messaging/type/MessageDeleteBookmark.h

@@ -1,28 +0,0 @@
-#ifndef MESSAGE_DELETE_BOOKMARK_H
-#define MESSAGE_DELETE_BOOKMARK_H
-
-#include "utility/messaging/Message.h"
-#include "utility/types.h"
-
-class MessageDeleteBookmark
-	: public Message<MessageDeleteBookmark>
-{
-public:
-	MessageDeleteBookmark(const Id bookmarkId)
-		: bookmarkId(bookmarkId)
-	{
-	}
-
-	~MessageDeleteBookmark()
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageDeleteBookmark";
-	}
-
-	const Id bookmarkId;
-};
-
-#endif // MESSAGE_DELETE_BOOKMARK_H

src/lib/utility/messaging/type/MessageDeleteBookmarkCategory.h

@@ -1,28 +0,0 @@
-#ifndef MESSAGE_DELETE_BOOKMARK_CATEGORY_H
-#define MESSAGE_DELETE_BOOKMARK_CATEGORY_H
-
-#include "utility/messaging/Message.h"
-#include "utility/types.h"
-
-class MessageDeleteBookmarkCategory
-	: public Message<MessageDeleteBookmarkCategory>
-{
-public:
-	MessageDeleteBookmarkCategory(const Id id)
-		: categoryId(id)
-	{
-	}
-
-	~MessageDeleteBookmarkCategory()
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageDeleteBookmarkCategory";
-	}
-
-	const Id categoryId;
-};
-
-#endif // MESSAGE_DELETE_BOOKMARK_CATEGORY_H

src/lib/utility/messaging/type/MessageDeleteBookmarkForActiveTokens.h

@@ -1,24 +0,0 @@
-#ifndef MESSAGE_DELETE_BOOKMARK_FOR_ACTIVE_TOKENS
-#define MESSAGE_DELETE_BOOKMARK_FOR_ACTIVE_TOKENS
-
-#include "utility/messaging/Message.h"
-
-class MessageDeleteBookmarkForActiveTokens
-	: public Message<MessageDeleteBookmarkForActiveTokens>
-{
-public:
-	MessageDeleteBookmarkForActiveTokens()
-	{
-	}
-
-	~MessageDeleteBookmarkForActiveTokens()
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageDeleteBookmarkForActiveTokens";
-	}
-};
-
-#endif // MESSAGE_DELETE_BOOKMARK_FOR_ACTIVE_TOKENS

src/lib/utility/messaging/type/MessageDisplayBookmarkCreator.h

@@ -7,12 +7,7 @@ class MessageDisplayBookmarkCreator
 	: public Message<MessageDisplayBookmarkCreator>
 {
 public:
-	MessageDisplayBookmarkCreator()
-		: nodeId(0)
-	{
-	}
-
-	MessageDisplayBookmarkCreator(Id nodeId)
+	MessageDisplayBookmarkCreator(Id nodeId = 0)
 		: nodeId(nodeId)
 	{
 	}
@@ -22,7 +17,7 @@ public:
 		return "MessageDisplayBookmarkCreator";
 	}
 
-	Id nodeId;
+	const Id nodeId;
 };
 
 #endif // MESSAGE_DISPLAY_BOOKMARK_CREATOR_H

src/lib/utility/messaging/type/MessageDisplayBookmarkEditor.h

@@ -1,25 +0,0 @@
-#ifndef MESSAGE_DISPLAY_BOOKMARK_EDITOR_H
-#define MESSAGE_DISPLAY_BOOKMARK_EDITOR_H
-
-#include "data/bookmark/Bookmark.h"
-
-#include "utility/messaging/Message.h"
-
-class MessageDisplayBookmarkEditor
-	: public Message<MessageDisplayBookmarkEditor>
-{
-public:
-	MessageDisplayBookmarkEditor(std::shared_ptr<Bookmark> bookmark)
-		: bookmark(bookmark)
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageDisplayBookmarkEditor";
-	}
-
-	std::shared_ptr<Bookmark> bookmark;
-};
-
-#endif // MESSAGE_DISPLAY_BOOKMARK_EDITOR_H

src/lib/utility/messaging/type/MessageDisplayBookmarks.h

@@ -1,48 +1,29 @@
 #ifndef MESSAGE_DISPLAY_BOOKMARKS_H
 #define MESSAGE_DISPLAY_BOOKMARKS_H
 
+#include "data/bookmark/Bookmark.h"
 #include "utility/messaging/Message.h"
 
 class MessageDisplayBookmarks
 	: public Message<MessageDisplayBookmarks>
 {
 public:
-	enum BookmarkFilter
-	{
-		UNKNOWN = 0,
-		ALL,
-		NODES,
-		EDGES
-	};
-
-	enum BookmarkOrder
-	{
-		NONE = 0,
-		DATE_ASCENDING,
-		DATE_DESCENDING,
-		NAME_ASCENDING,
-		NAME_DESCENDING
-	};
-
-	MessageDisplayBookmarks(const BookmarkFilter& filter, const BookmarkOrder& order)
+	MessageDisplayBookmarks(
+		Bookmark::BookmarkFilter filter = Bookmark::FILTER_UNKNOWN,
+		Bookmark::BookmarkOrder order = Bookmark::ORDER_NONE
+	)
 		: filter(filter)
 		, order(order)
 	{
 	}
 
-	MessageDisplayBookmarks()
-		: filter(MessageDisplayBookmarks::BookmarkFilter::ALL)
-		, order(MessageDisplayBookmarks::BookmarkOrder::NONE)
-	{
-	}
-
 	static const std::string getStaticType()
 	{
 		return "MessageDisplayBookmarks";
 	}
 
-	const BookmarkFilter filter;
-	const BookmarkOrder order;
+	const Bookmark::BookmarkFilter filter;
+	const Bookmark::BookmarkOrder order;
 };
 
 #endif // MESSAGE_DISPLAY_BOOKMARKS_H

src/lib/utility/messaging/type/MessageEditBookmark.h

@@ -1,34 +0,0 @@
-#ifndef MESSAGE_EDIT_BOOKMARK_H
-#define MESSAGE_EDIT_BOOKMARK_H
-
-#include "utility/messaging/Message.h"
-#include "utility/types.h"
-
-class MessageEditBookmark
-	: public Message<MessageEditBookmark>
-{
-public:
-	MessageEditBookmark(Id id, const std::string& comment, const std::string& displayName, const std::string& categoryName)
-		: bookmarkId(id)
-		, comment(comment)
-		, displayName(displayName)
-		, categoryName(categoryName)
-	{
-	}
-
-	~MessageEditBookmark()
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageEditBookmark";
-	}
-
-	const Id bookmarkId;
-	const std::string comment;
-	const std::string displayName;
-	const std::string categoryName;
-};
-
-#endif // MESSAGE_EDIT_BOOKMARK_H