ui: Added tabs UI to top of main window (issue #215)

* Added tab bar to top of main window with UI/shortcuts similar to web browsers
* ComponentManager offers components for 2 use-cases: application and tab
* Application components: log view (status/errors), bookmarks, screen search, status bar, tabs, tooltips, dialogs and all tab views disabled
* Tab components: graph, code, history and search
* When a project is loaded there is always at least one tab, otherwise there is none
* Each tab replaces the application views of the same name in the main layout when activated
* Each tab has it's own TaskScheduler, to process tasks independent from other tabs
* The application has a global TaskScheduler for application wide tasks
* The singloton class TaskManager is responsible for managing the TaskSchedulers
* MessageListeners and Messages hold an optional schedulerId, both must be set to only send to a specific TaskScheduler
* Bookmark buttons where split off into a separate view per tab, bookmark managemement is done in the application
* History menu processing is done by the QtMainWindow now
* Screen search is an application component, the responders are always changed to the active tab
* Plugin messages are opened in a new tab
* Symbols can be opened in a new tab via middle click/context menu in graph, code, history dropdown
* Full text index creation is mutexed now in PersistenStorage to make it fully thread-safe
* All tabs are closed when switching projects
* Tab contents are only animated when visible

fortune cookie message = Catch your lucky star!

bin/app/data/color_schemes/bad_rainbow.xml

@@ -534,12 +534,21 @@
 			<background>#808080</background>
 			<border>#BEBEBE</border>
 			<button>
-				<text>white</text>
+				<text>
+					<normal>#CCC</normal>
+					<hover>#CCC</hover>
+					<press>white</press>
+				</text>
+				<border>
+					<normal>#CCC</normal>
+					<press>#EEE</press>
+				</border>
 				<background>
 					<normal>#808080</normal>
 					<hover>#505050</hover>
 					<press>#494949</press>
 				</background>
+				<icon>#CCC</icon>
 			</button>
 		</bar>
 	</tab>

bin/app/data/color_schemes/bright.xml

@@ -67,7 +67,7 @@
 					<text>black</text>
 				</normal>
 				<hover>
-					<fill>#5EA071</fill>
+					<fill>#6DB080</fill>
 					<text>black</text>
 				</hover>
 			</command>
@@ -508,12 +508,21 @@
 			<background>#E0E0E0</background>
 			<border>#BEBEBE</border>
 			<button>
-				<text>black</text>
+				<text>
+					<normal>#555</normal>
+					<hover>#555</hover>
+					<press>black</press>
+				</text>
+				<border>
+					<normal>#888</normal>
+					<press>#777</press>
+				</border>
 				<background>
 					<normal>#E0E0E0</normal>
 					<hover>#F0F0F0</hover>
 					<press>#FFFFFF</press>
 				</background>
+				<icon>#555</icon>
 			</button>
 		</bar>
 	</tab>

bin/app/data/color_schemes/dark.xml

@@ -511,12 +511,21 @@
 			<background>#555555</background>
 			<border>#BEBEBE</border>
 			<button>
-				<text>white</text>
+				<text>
+					<normal>#AAA</normal>
+					<hover>#AAA</hover>
+					<press>white</press>
+				</text>
+				<border>
+					<normal>#777</normal>
+					<press>#999</press>
+				</border>
 				<background>
 					<normal>#555555</normal>
 					<hover>#2F2F2F</hover>
 					<press>#272728</press>
 				</background>
+				<icon>#AAA</icon>
 			</button>
 		</bar>
 	</tab>

bin/app/data/gui/main/main.css

@@ -13,6 +13,10 @@ QMainWindow::separator {
 	width: 1px;
 }
 
+QToolBar {
+	border: none;
+}
+
 QDockWidget {
 	color: <color:window/dock/text>;
 	font-size: 10pt;

bin/app/data/gui/tabbed_view/tabbed_view.css

@@ -15,7 +15,7 @@ QTabBar::tab {
 	border: 1px solid <color:tab/bar/border>;
 	border-top-left-radius: 7px;
 	border-top-right-radius: 7px;
-	color: <color:tab/bar/button/text>;
+	color: <color:tab/bar/button/text/normal>;
 	font-size: <setting:font_size>px;
 	height: <setting:font_size+8>;
 	margin-left: 3px;
@@ -25,11 +25,13 @@ QTabBar::tab {
 
 QTabBar::tab:hover {
 	background-color: <color:tab/bar/button/background/hover>;
+	color: <color:tab/bar/button/text/hover>;
 }
 
 QTabBar::tab:selected, QTabBar::tab:pressed {
 	background-color:  <color:tab/bar/button/background/press>;
 	border-bottom: 1px solid <color:tab/bar/button/background/press>;
+	color: <color:tab/bar/button/text/press>;
 }
 
 QTabWidget #tab_content {

bin/app/data/gui/tabs_view/tabs_view.css

@@ -0,0 +1,81 @@
+QTabBar {
+	background-color: <color:tab/bar/background>;
+	border-bottom: 1px solid <color:tab/bar/border>;
+	font-size: <setting:font_size>px;
+	padding-left: 4px;
+	min-height: 30px;
+}
+
+QTabBar::tab {
+	background-color: <color:tab/bar/button/background/normal>;
+	border: 1px solid <color:tab/bar/border>;
+	border-top-left-radius: 11px;
+	border-top-right-radius: 11px;
+	color: <color:tab/bar/button/text/normal>;
+	min-height: 25px;
+	margin-left: 3px;
+	margin-top: 4px;
+}
+
+QTabBar::tab:hover {
+	background-color: <color:tab/bar/button/background/hover>;
+	color: <color:tab/bar/button/text/hover>;
+}
+
+QTabBar::tab:selected, QTabBar::tab:pressed {
+	background-color:  <color:tab/bar/button/background/press>;
+	border-bottom: 1px solid <color:tab/bar/button/background/press>;
+	color: <color:tab/bar/button/text/press>;
+}
+
+#side_area {
+	background-color: <color:tab/bar/background>;
+	border-bottom: 1px solid <color:tab/bar/border>;
+}
+
+#type_circle {
+	background-color: <color:tab/bar/button/background/hover>;
+	border: 1px solid <color:tab/bar/button/border/normal>;
+	border-radius: 6px;
+	margin: 0;
+	height: 10px;
+	width: 10px;
+	margin-top: 3px;
+	margin-left: 6px;
+}
+
+#type_circle[selected=true] {
+	border: 1px solid <color:tab/bar/button/border/press>;
+}
+
+#close_button {
+	background-color: transparent;
+	border: 1px solid transparent;
+	border-radius: 8px;
+	color: <color:tab/bar/button/text/normal>;
+	font-size: 12px;
+	margin: 0;
+	height: 14px;
+	width: 14px;
+	margin-top: 5px;
+	margin-right: 0px;
+}
+
+#close_button:hover {
+	border: 1px solid <color:tab/bar/border>;
+}
+
+#add_button {
+	background-color: <color:tab/bar/button/background/hover>;
+	border: 1px solid <color:tab/bar/border>;
+	border-radius: 11px;
+	color: <color:tab/bar/button/text/normal>;
+	margin: 5px 0 3px 0;
+	height: 20px;
+	width: 20px;
+}
+
+#add_button:hover {
+	background-color: <color:tab/bar/button/background/press>;
+	color: <color:tab/bar/button/text/press>;
+}

src/lib/Application.cpp

@@ -22,6 +22,8 @@
 #include "MessageForceEnterLicense.h"
 #include "MessageQuitApplication.h"
 #include "MessageStatus.h"
+#include "TabId.h"
+#include "TaskManager.h"
 #include "TaskScheduler.h"
 #include "tracing.h"
 #include "UserPaths.h"
@@ -45,7 +47,8 @@ void Application::createInstance(
 		collector->run(Application::getUUID());
 	}
 
-	TaskScheduler::getInstance();
+	TaskManager::createScheduler(TabId::app());
+	TaskManager::createScheduler(TabId::background());
 	MessageQueue::getInstance();
 
 	bool hasGui = (viewFactory != nullptr);
@@ -55,15 +58,11 @@ void Application::createInstance(
 
 	if (hasGui)
 	{
-		s_instance->m_componentManager = ComponentManager::create(viewFactory, s_instance->m_storageCache.get());
+		s_instance->m_mainView = viewFactory->createMainView(s_instance->m_storageCache.get());
-
+		s_instance->m_mainView->setup();
-		s_instance->m_mainView = viewFactory->createMainView();
 		s_instance->updateTitle();
 
-		s_instance->m_componentManager->setup(s_instance->m_mainView.get());
+		GraphViewStyle::setImpl(viewFactory->createGraphStyleImpl());
-		s_instance->m_mainView->loadLayout();
-
-		s_instance->m_componentManager->refreshViews();
 	}
 
 	if (networkFactory != nullptr)
@@ -86,7 +85,8 @@ std::shared_ptr<Application> Application::getInstance()
 void Application::destroyInstance()
 {
 	MessageQueue::getInstance()->stopMessageLoop();
-	TaskScheduler::getInstance()->stopSchedulerLoop();
+	TaskManager::destroyScheduler(TabId::background());
+	TaskManager::destroyScheduler(TabId::app());
 
 	s_instance.reset();
 }
@@ -145,6 +145,15 @@ const std::shared_ptr<Project> Application::getCurrentProject()
 	return m_project;
 }
 
+bool Application::isProjectLoaded() const
+{
+	if (m_project)
+	{
+		return m_project->isLoaded();
+	}
+	return false;
+}
+
 bool Application::hasGUI()
 {
 	return m_hasGUI;
@@ -172,17 +181,17 @@ int Application::handleDialog(const std::wstring& message, const std::vector<std
 
 std::shared_ptr<DialogView> Application::getDialogView(DialogView::UseCase useCase)
 {
-	if (m_componentManager)
+	if (m_mainView)
 	{
-		return m_componentManager->getDialogView(useCase);
+		return m_mainView->getDialogView(useCase);
 	}
 
 	return std::make_shared<DialogView>(useCase, nullptr);
 }
 
-void Application::updateHistoryMenu(const std::vector<std::shared_ptr<MessageBase>>& historyMenuItems)
+void Application::updateHistoryMenu(std::shared_ptr<MessageBase> message)
 {
-	m_mainView->updateHistoryMenu(historyMenuItems);
+	m_mainView->updateHistoryMenu(message);
 }
 
 void Application::updateBookmarks(const std::vector<std::shared_ptr<Bookmark>>& bookmarks)
@@ -209,8 +218,7 @@ void Application::handleMessage(MessageEnteredLicense* message)
 
 	if (m_hasGUI)
 	{
-		m_mainView->refreshView();
+		m_mainView->refreshViews();
-		m_componentManager->refreshViews();
 	}
 }
 
@@ -264,6 +272,13 @@ void Application::handleMessage(MessageLoadProject* message)
 
 		projectSettingsFilePath = migrateProjectSettings(projectSettingsFilePath);
 
+		m_project.reset();
+
+		if (m_hasGUI)
+		{
+			m_mainView->clear();
+		}
+
 		try
 		{
 			updateRecentProjects(projectSettingsFilePath);
@@ -297,11 +312,6 @@ void Application::handleMessage(MessageLoadProject* message)
 			MessageStatus(L"Failed to load project, unknown exception was thrown: " + projectSettingsFilePath.wstr(), true).dispatch();
 		}
 
-		if (m_hasGUI)
-		{
-			m_componentManager->clearComponents();
-		}
-
 		if (message->refreshMode != REFRESH_NONE)
 		{
 			refreshProject(message->refreshMode);
@@ -327,8 +337,7 @@ void Application::handleMessage(MessageRefreshUI* message)
 			loadStyle(ApplicationSettings::getInstance()->getColorSchemePath());
 		}
 
-		m_mainView->refreshView();
+		m_mainView->refreshViews();
-		m_componentManager->refreshViews();
 	}
 }
 
@@ -396,7 +405,8 @@ FilePath Application::migrateProjectSettings(const FilePath& projectSettingsFile
 
 void Application::startMessagingAndScheduling()
 {
-	TaskScheduler::getInstance()->startSchedulerLoopThreaded();
+	TaskManager::getScheduler(TabId::app())->startSchedulerLoopThreaded();
+	TaskManager::getScheduler(TabId::background())->startSchedulerLoopThreaded();
 
 	MessageQueue* queue = MessageQueue::getInstance().get();
 	queue->addMessageFilter(std::make_shared<MessageFilterErrorCountUpdate>());

src/lib/Application.h

@@ -3,8 +3,7 @@
 
 #include <memory>
 
-#include "ComponentManager.h"
+#include "DialogView.h"
-#include "Project.h"
 #include "MessageListener.h"
 #include "MessageIndexingFinished.h"
 #include "MessageActivateWindow.h"
@@ -14,9 +13,10 @@
 #include "MessageRefreshUI.h"
 #include "MessageSwitchColorScheme.h"
 #include "MessageWindowFocus.h"
+#include "Project.h"
+#include "TimeStamp.h"
 
 class Bookmark;
-class DialogView;
 class IDECommunicationController;
 class MainView;
 class NetworkFactory;
@@ -48,6 +48,7 @@ public:
 	~Application();
 
 	const std::shared_ptr<Project> getCurrentProject();
+	bool isProjectLoaded() const;
 
 	bool hasGUI();
 
@@ -57,7 +58,7 @@ public:
 	int handleDialog(const std::wstring& message, const std::vector<std::wstring>& options);
 	std::shared_ptr<DialogView> getDialogView(DialogView::UseCase useCase);
 
-	void updateHistoryMenu(const std::vector<std::shared_ptr<MessageBase>>& historyMenuItems);
+	void updateHistoryMenu(std::shared_ptr<MessageBase> message);
 	void updateBookmarks(const std::vector<std::shared_ptr<Bookmark>>& bookmarks);
 
 private:
@@ -92,7 +93,6 @@ private:
 	std::shared_ptr<StorageCache> m_storageCache;
 
 	std::shared_ptr<MainView> m_mainView;
-	std::shared_ptr<ComponentManager> m_componentManager;
 
 	std::shared_ptr<IDECommunicationController> m_ideCommunicationController;
 	std::shared_ptr<UpdateChecker> m_updateChecker;

src/lib/CMakeLists.txt

@@ -40,6 +40,8 @@ add_files(
 	component/controller/StatusBarController.h
 	component/controller/StatusController.cpp
 	component/controller/StatusController.h
+	component/controller/TabsController.cpp
+	component/controller/TabsController.h
 	component/controller/TooltipController.cpp
 	component/controller/TooltipController.h
 	component/controller/UndoRedoController.cpp
@@ -47,6 +49,8 @@ add_files(
 
 	component/view/helper/CodeSnippetParams.cpp
 	component/view/helper/CodeSnippetParams.h
+	component/view/BookmarkButtonsView.cpp
+	component/view/BookmarkButtonsView.h
 	component/view/BookmarkView.cpp
 	component/view/BookmarkView.h
 	component/view/CodeView.cpp
@@ -76,13 +80,14 @@ add_files(
 	component/view/StatusView.h
 	component/view/TabbedView.cpp
 	component/view/TabbedView.h
+	component/view/TabsView.cpp
+	component/view/TabsView.h
 	component/view/TooltipView.cpp
 	component/view/TooltipView.h
 	component/view/UndoRedoView.cpp
 	component/view/UndoRedoView.h
 	component/view/View.cpp
 	component/view/View.h
-	component/view/ViewFactory.cpp
 	component/view/ViewFactory.h
 	component/view/ViewLayout.cpp
 	component/view/ViewLayout.h
@@ -97,6 +102,10 @@ add_files(
 	component/ComponentManager.h
 	component/NetworkFactory.cpp
 	component/NetworkFactory.h
+	component/Tab.cpp
+	component/Tab.h
+	component/TabId.cpp
+	component/TabId.h
 
 	data/access/StorageAccess.h
 	data/access/StorageAccessProxy.cpp
@@ -424,6 +433,13 @@ add_files(
 
 	utility/messaging/type/activation/MessageActivateLegend.h
 
+	utility/messaging/type/bookmark/MessageBookmarkActivate.h
+	utility/messaging/type/bookmark/MessageBookmarkBrowse.h
+	utility/messaging/type/bookmark/MessageBookmarkButtonState.h
+	utility/messaging/type/bookmark/MessageBookmarkCreate.h
+	utility/messaging/type/bookmark/MessageBookmarkDelete.h
+	utility/messaging/type/bookmark/MessageBookmarkEdit.h
+
 	utility/messaging/type/code/MessageCodeShowDefinition.h
 
 	utility/messaging/type/error/MessageActivateErrors.h
@@ -443,9 +459,14 @@ add_files(
 	utility/messaging/type/indexing/MessageIndexingStarted.h
 	utility/messaging/type/indexing/MessageIndexingStatus.h
 
+	utility/messaging/type/tab/MessageTabClose.h
+	utility/messaging/type/tab/MessageTabOpen.h
+	utility/messaging/type/tab/MessageTabOpenWith.h
+	utility/messaging/type/tab/MessageTabSelect.h
+	utility/messaging/type/tab/MessageTabState.h
+
 	utility/messaging/type/MessageActivateAll.h
 	utility/messaging/type/MessageActivateBase.h
-	utility/messaging/type/MessageActivateBookmark.h
 	utility/messaging/type/MessageActivateEdge.h
 	utility/messaging/type/MessageActivateFile.h
 	utility/messaging/type/MessageActivateFullTextSearch.h
@@ -462,8 +483,6 @@ add_files(
 	utility/messaging/type/MessageClearStatusView.h
 	utility/messaging/type/MessageCodeReference.h
 	utility/messaging/type/MessageDeactivateEdge.h
-	utility/messaging/type/MessageDisplayBookmarkCreator.h
-	utility/messaging/type/MessageDisplayBookmarks.h
 	utility/messaging/type/MessageEnteredLicense.h
 	utility/messaging/type/MessageFind.h
 	utility/messaging/type/MessageFlushUpdates.h
@@ -540,6 +559,8 @@ add_files(
 	utility/scheduling/TaskGroupSequence.h
 	utility/scheduling/TaskLambda.cpp
 	utility/scheduling/TaskLambda.h
+	utility/scheduling/TaskManager.cpp
+	utility/scheduling/TaskManager.h
 	utility/scheduling/TaskReturnSuccessIf.h
 	utility/scheduling/TaskRunner.cpp
 	utility/scheduling/TaskRunner.h

src/lib/component/Component.cpp

@@ -6,6 +6,7 @@
 Component::Component(std::shared_ptr<View> view, std::shared_ptr<Controller> controller)
 	: m_controller(controller)
 	, m_view(view)
+	, m_tabId(0)
 {
 	if (m_controller)
 	{
@@ -40,3 +41,13 @@ View* Component::getViewPtr() const
 {
 	return m_view.get();
 }
+
+void Component::setTabId(Id tabId)
+{
+	m_tabId = tabId;
+}
+
+Id Component::getTabId() const
+{
+	return m_tabId;
+}

src/lib/component/Component.h

@@ -3,6 +3,8 @@
 
 #include <memory>
 
+#include "types.h"
+
 class View;
 class Controller;
 
@@ -22,9 +24,14 @@ public:
 
 	View* getViewPtr() const;
 
+	void setTabId(Id tabId);
+	Id getTabId() const;
+
 private:
 	const std::shared_ptr<Controller> m_controller;
 	const std::shared_ptr<View> m_view;
+
+	Id m_tabId;
 };
 
 

src/lib/component/ComponentFactory.cpp

@@ -11,6 +11,7 @@
 #include "SearchController.h"
 #include "StatusBarController.h"
 #include "StatusController.h"
+#include "TabsController.h"
 #include "TooltipController.h"
 #include "UndoRedoController.h"
 #include "BookmarkView.h"
@@ -21,25 +22,18 @@
 #include "SearchView.h"
 #include "StatusBarView.h"
 #include "StatusView.h"
+#include "TabsView.h"
 #include "TooltipView.h"
 #include "UndoRedoView.h"
 #include "ViewFactory.h"
 
-std::shared_ptr<ComponentFactory> ComponentFactory::create(ViewFactory* viewFactory, StorageAccess* storageAccess)
+ComponentFactory::ComponentFactory(const ViewFactory* viewFactory, StorageAccess* storageAccess)
-{
+	: m_viewFactory(viewFactory)
-	std::shared_ptr<ComponentFactory> ptr(new ComponentFactory());
+	, m_storageAccess(storageAccess)
-
-	ptr->m_viewFactory = viewFactory;
-	ptr->m_storageAccess = storageAccess;
-
-	return ptr;
-}
-
-ComponentFactory::~ComponentFactory()
 {
 }
 
-ViewFactory* ComponentFactory::getViewFactory() const
+const ViewFactory* ComponentFactory::getViewFactory() const
 {
 	return m_viewFactory;
 }
@@ -128,6 +122,16 @@ std::shared_ptr<Component> ComponentFactory::createStatusComponent(ViewLayout* v
 	return std::make_shared<Component>(view, controller);
 }
 
+std::shared_ptr<Component> ComponentFactory::createTabsComponent(
+	ViewLayout* viewLayout, ScreenSearchSender* screenSearchSender)
+{
+	std::shared_ptr<TabsView> view = m_viewFactory->createTabsView(viewLayout);
+	std::shared_ptr<Controller> controller = std::make_shared<TabsController>(
+		viewLayout, m_viewFactory, m_storageAccess, screenSearchSender);
+
+	return std::make_shared<Component>(view, controller);
+}
+
 std::shared_ptr<Component> ComponentFactory::createTooltipComponent(ViewLayout* viewLayout)
 {
 	std::shared_ptr<TooltipView> view = m_viewFactory->createTooltipView(viewLayout);
@@ -143,7 +147,3 @@ std::shared_ptr<Component> ComponentFactory::createUndoRedoComponent(ViewLayout*
 
 	return std::make_shared<Component>(view, controller);
 }
-
-ComponentFactory::ComponentFactory()
-{
-}

src/lib/component/ComponentFactory.h

@@ -8,15 +8,14 @@
 class Component;
 class ViewFactory;
 class ViewLayout;
+class ScreenSearchSender;
 
 class ComponentFactory
 {
 public:
-	static std::shared_ptr<ComponentFactory> create(ViewFactory* viewFactory, StorageAccess* storageAccess);
+	ComponentFactory(const ViewFactory* viewFactory, StorageAccess* storageAccess);
 
-	~ComponentFactory();
+	const ViewFactory* getViewFactory() const;
-
-	ViewFactory* getViewFactory() const;
 	StorageAccess* getStorageAccess() const;
 
 	std::shared_ptr<Component> createActivationComponent();
@@ -29,14 +28,12 @@ public:
 	std::shared_ptr<Component> createSearchComponent(ViewLayout* viewLayout);
 	std::shared_ptr<Component> createStatusBarComponent(ViewLayout* viewLayout);
 	std::shared_ptr<Component> createStatusComponent(ViewLayout* viewLayout);
+	std::shared_ptr<Component> createTabsComponent(ViewLayout* viewLayout, ScreenSearchSender* screenSearchSender);
 	std::shared_ptr<Component> createTooltipComponent(ViewLayout* viewLayout);
 	std::shared_ptr<Component> createUndoRedoComponent(ViewLayout* viewLayout);
 
 private:
-	ComponentFactory();
+	const ViewFactory* m_viewFactory;
-	ComponentFactory(const ComponentFactory&);
-
-	ViewFactory* m_viewFactory;
 	StorageAccess* m_storageAccess;
 };
 

src/lib/component/ComponentManager.cpp

@@ -1,87 +1,147 @@
 #include "ComponentManager.h"
 
-#include "logging.h"
-
-#include "Controller.h"
-#include "ScreenSearchController.h"
 #include "CompositeView.h"
+#include "Controller.h"
 #include "DialogView.h"
+#include "logging.h"
+#include "ScreenSearchController.h"
 #include "TabbedView.h"
 #include "ViewFactory.h"
+#include "BookmarkButtonsView.h"
+#include "BookmarkView.h"
+#include "CodeView.h"
+#include "GraphView.h"
+#include "RefreshView.h"
+#include "SearchView.h"
+#include "UndoRedoView.h"
 
-std::shared_ptr<ComponentManager> ComponentManager::create(ViewFactory* viewFactory, StorageAccess* storageAccess)
+ComponentManager::ComponentManager(const ViewFactory* viewFactory, StorageAccess* storageAccess)
-{
+	: m_componentFactory(viewFactory, storageAccess)
-	std::shared_ptr<ComponentManager> ptr(new ComponentManager());
-
-	ptr->m_componentFactory = ComponentFactory::create(viewFactory, storageAccess);
-
-	return ptr;
-}
-
-ComponentManager::~ComponentManager()
 {
 }
 
-void ComponentManager::setup(ViewLayout* viewLayout)
+void ComponentManager::clear()
+{
+	m_dialogViews.clear();
+	m_components.clear();
+	m_singleViews.clear();
+}
+
+void ComponentManager::setupMain(ViewLayout* viewLayout, Id appId)
 {
 	std::shared_ptr<CompositeView> compositeView =
-		m_componentFactory->getViewFactory()->createCompositeView(viewLayout, CompositeView::DIRECTION_HORIZONTAL, "Search");
+		m_componentFactory.getViewFactory()->createCompositeView(viewLayout, CompositeView::DIRECTION_HORIZONTAL, "Search");
-	m_compositeViews.push_back(compositeView);
+	m_singleViews.push_back(compositeView);
 
-	std::shared_ptr<Component> undoRedoComponent = m_componentFactory->createUndoRedoComponent(compositeView.get());
+	std::shared_ptr<UndoRedoView> undoRedoView = m_componentFactory.getViewFactory()->createUndoRedoView(compositeView.get());
-	m_components.push_back(undoRedoComponent);
+	std::shared_ptr<RefreshView> refreshView = m_componentFactory.getViewFactory()->createRefreshView(compositeView.get());
+	std::shared_ptr<SearchView> searchView = m_componentFactory.getViewFactory()->createSearchView(compositeView.get());
 
-	std::shared_ptr<Component> refreshComponent = m_componentFactory->createRefreshComponent(compositeView.get());
+	std::shared_ptr<BookmarkButtonsView> bookmarkView =
-	m_components.push_back(refreshComponent);
+		m_componentFactory.getViewFactory()->createBookmarkButtonsView(compositeView.get());
+	bookmarkView->setTabId(appId);
 
-	std::shared_ptr<Component> searchComponent = m_componentFactory->createSearchComponent(compositeView.get());
+	std::shared_ptr<GraphView> graphView = m_componentFactory.getViewFactory()->createGraphView(viewLayout);
-	m_components.push_back(searchComponent);
+	std::shared_ptr<CodeView> codeView = m_componentFactory.getViewFactory()->createCodeView(viewLayout);
 
-	std::shared_ptr<Component> bookmarkComponent = m_componentFactory->createBookmarkComponent(compositeView.get());
+	for (std::shared_ptr<View> view :
-	m_components.push_back(bookmarkComponent);
+			std::vector<std::shared_ptr<View>>({ undoRedoView, searchView, bookmarkView, graphView, codeView }))
+	{
+		view->setEnabled(false);
+	}
 
-	std::shared_ptr<Component> graphComponent = m_componentFactory->createGraphComponent(viewLayout);
+	m_singleViews.push_back(undoRedoView);
-	m_components.push_back(graphComponent);
+	m_singleViews.push_back(refreshView);
+	m_singleViews.push_back(searchView);
+	m_singleViews.push_back(bookmarkView);
+	m_singleViews.push_back(graphView);
+	m_singleViews.push_back(codeView);
 
-	std::shared_ptr<Component> codeComponent = m_componentFactory->createCodeComponent(viewLayout);
+	std::shared_ptr<Component> screenSearchComponent = m_componentFactory.createScreenSearchComponent(viewLayout);
-	m_components.push_back(codeComponent);
+	ScreenSearchController* screenSearchController = screenSearchComponent->getController<ScreenSearchController>();
+	screenSearchController->addResponder(graphView.get());
+	screenSearchController->addResponder(codeView.get());
+	m_components.push_back(screenSearchComponent);
 
-	std::shared_ptr<Component> statusBarComponent = m_componentFactory->createStatusBarComponent(viewLayout);
+	std::shared_ptr<Component> tabsComponent = m_componentFactory.createTabsComponent(viewLayout, screenSearchController);
+	m_components.push_back(tabsComponent);
+
+	std::shared_ptr<Component> statusBarComponent = m_componentFactory.createStatusBarComponent(viewLayout);
 	m_components.push_back(statusBarComponent);
 
-	std::shared_ptr<Component> activationComponent = m_componentFactory->createActivationComponent();
+	std::shared_ptr<Component> tooltipComponent = m_componentFactory.createTooltipComponent(viewLayout);
-	m_components.push_back(activationComponent);
-
-	std::shared_ptr<Component> tooltipComponent = m_componentFactory->createTooltipComponent(viewLayout);
 	m_components.push_back(tooltipComponent);
 
-	std::shared_ptr<Component> screenSearchComponent = m_componentFactory->createScreenSearchComponent(viewLayout);
-	ScreenSearchController* screenSearchController = screenSearchComponent->getController<ScreenSearchController>();
-	screenSearchController->addResponder(dynamic_cast<ScreenSearchResponder*>(graphComponent->getViewPtr()));
-	screenSearchController->addResponder(dynamic_cast<ScreenSearchResponder*>(codeComponent->getViewPtr()));
-	m_components.push_back(screenSearchComponent);
-
 	for (DialogView::UseCase useCase :
 		{ DialogView::UseCase::GENERAL, DialogView::UseCase::INDEXING, DialogView::UseCase::PROJECT_SETUP })
 	{
 		m_dialogViews.emplace(
 			useCase,
-			m_componentFactory->getViewFactory()->createDialogView(viewLayout, useCase, m_componentFactory->getStorageAccess())
+			m_componentFactory.getViewFactory()->createDialogView(viewLayout, useCase, m_componentFactory.getStorageAccess())
 		);
 	}
 
 	m_dialogViews[DialogView::UseCase::INDEXING]->setDialogsHideable(true);
 
 	std::shared_ptr<TabbedView> tabbedView =
-		m_componentFactory->getViewFactory()->createTabbedView(viewLayout, "Status");
+		m_componentFactory.getViewFactory()->createTabbedView(viewLayout, "Status");
-	m_tabbedViews.push_back(tabbedView);
+	m_singleViews.push_back(tabbedView);
 
-	std::shared_ptr<Component> statusComponent = m_componentFactory->createStatusComponent(tabbedView.get());
+	std::shared_ptr<Component> statusComponent = m_componentFactory.createStatusComponent(tabbedView.get());
 	m_components.push_back(statusComponent);
 
-	std::shared_ptr<Component> errorComponent = m_componentFactory->createErrorComponent(tabbedView.get());
+	std::shared_ptr<Component> errorComponent = m_componentFactory.createErrorComponent(tabbedView.get());
 	m_components.push_back(errorComponent);
 
+	std::shared_ptr<Component> bookmarkComponent = m_componentFactory.createBookmarkComponent(compositeView.get());
+	m_components.push_back(bookmarkComponent);
+
+	std::shared_ptr<Component> activationComponent = m_componentFactory.createActivationComponent();
+	m_components.push_back(activationComponent);
+}
+
+void ComponentManager::setupTab(ViewLayout* viewLayout, Id tabId, ScreenSearchSender* screenSearchSender)
+{
+	std::shared_ptr<CompositeView> compositeView =
+		m_componentFactory.getViewFactory()->createCompositeView(viewLayout, CompositeView::DIRECTION_HORIZONTAL, "Search");
+	m_singleViews.push_back(compositeView);
+
+	std::shared_ptr<Component> undoRedoComponent = m_componentFactory.createUndoRedoComponent(compositeView.get());
+	undoRedoComponent->setTabId(tabId);
+	m_components.push_back(undoRedoComponent);
+
+	std::shared_ptr<Component> refreshComponent = m_componentFactory.createRefreshComponent(compositeView.get());
+	refreshComponent->setTabId(tabId);
+	m_components.push_back(refreshComponent);
+
+	std::shared_ptr<Component> searchComponent = m_componentFactory.createSearchComponent(compositeView.get());
+	searchComponent->setTabId(tabId);
+	m_components.push_back(searchComponent);
+
+	std::shared_ptr<BookmarkButtonsView> bookmarkView =
+		m_componentFactory.getViewFactory()->createBookmarkButtonsView(compositeView.get());
+	bookmarkView->setTabId(tabId);
+	m_singleViews.push_back(bookmarkView);
+
+	std::shared_ptr<Component> graphComponent = m_componentFactory.createGraphComponent(viewLayout);
+	graphComponent->setTabId(tabId);
+	m_components.push_back(graphComponent);
+
+	std::shared_ptr<Component> codeComponent = m_componentFactory.createCodeComponent(viewLayout);
+	codeComponent->setTabId(tabId);
+	m_components.push_back(codeComponent);
+
+	screenSearchSender->addResponder(graphComponent->getView<GraphView>());
+	screenSearchSender->addResponder(codeComponent->getView<CodeView>());
+}
+
+void ComponentManager::teardownTab(ScreenSearchSender* screenSearchSender)
+{
+	for (const std::shared_ptr<Component>& component : m_components)
+	{
+		screenSearchSender->removeResponder(component->getView<GraphView>());
+		screenSearchSender->removeResponder(component->getView<CodeView>());
+	}
 }
 
 void ComponentManager::clearComponents()
@@ -109,12 +169,7 @@ void ComponentManager::refreshViews()
 		}
 	}
 
-	for (const std::shared_ptr<CompositeView>& view : m_compositeViews)
+	for (const std::shared_ptr<View>& view : m_singleViews)
-	{
-		view->refreshView();
-	}
-
-	for (const std::shared_ptr<TabbedView>& view : m_tabbedViews)
 	{
 		view->refreshView();
 	}
@@ -131,7 +186,3 @@ std::shared_ptr<DialogView> ComponentManager::getDialogView(DialogView::UseCase
 
 	return it->second;
 }
-
-ComponentManager::ComponentManager()
-{
-}

src/lib/component/ComponentManager.h

@@ -10,6 +10,7 @@
 
 class CompositeView;
 class DialogView;
+class ScreenSearchSender;
 class StorageAccess;
 class TabbedView;
 class View;
@@ -19,11 +20,13 @@ class ViewLayout;
 class ComponentManager
 {
 public:
-	static std::shared_ptr<ComponentManager> create(ViewFactory* viewFactory, StorageAccess* graphAccess);
+	ComponentManager(const ViewFactory* viewFactory, StorageAccess* storageAccess);
 
-	~ComponentManager();
+	void clear();
 
-	void setup(ViewLayout* viewLayout);
+	void setupMain(ViewLayout* viewLayout, Id appId);
+	void setupTab(ViewLayout* viewLayout, Id tabId, ScreenSearchSender* screenSearchSender);
+	void teardownTab(ScreenSearchSender* screenSearchSender);
 
 	void clearComponents();
 	void refreshViews();
@@ -31,13 +34,9 @@ public:
 	std::shared_ptr<DialogView> getDialogView(DialogView::UseCase useCase) const;
 
 private:
-	ComponentManager();
+	ComponentFactory m_componentFactory;
-	ComponentManager(const ComponentManager&);
 
-	std::shared_ptr<ComponentFactory> m_componentFactory;
+	std::vector<std::shared_ptr<View>> m_singleViews;
-
-	std::vector<std::shared_ptr<CompositeView>> m_compositeViews;
-	std::vector<std::shared_ptr<TabbedView>> m_tabbedViews;
 	std::vector<std::shared_ptr<Component>> m_components;
 
 	std::map<DialogView::UseCase, std::shared_ptr<DialogView>> m_dialogViews;

src/lib/component/Tab.cpp

@@ -0,0 +1,74 @@
+#include "Tab.h"
+
+Tab::Tab(Id tabId, const ViewFactory* viewFactory, StorageAccess* storageAccess, ScreenSearchSender* screenSearchSender)
+	: m_tabId(tabId)
+	, m_componentManager(viewFactory, storageAccess)
+	, m_parentLayout(nullptr)
+	, m_screenSearchSender(screenSearchSender)
+{
+	m_componentManager.setupTab(this, m_tabId, m_screenSearchSender);
+	m_componentManager.refreshViews();
+}
+
+Tab::~Tab()
+{
+	m_componentManager.teardownTab(m_screenSearchSender);
+}
+
+void Tab::setParentLayout(ViewLayout* parentLayout)
+{
+	m_parentLayout = parentLayout;
+
+	if (parentLayout)
+	{
+		for (View* view : m_views)
+		{
+			parentLayout->overrideView(view);
+		}
+	}
+}
+
+void Tab::addView(View* view)
+{
+	m_views.push_back(view);
+}
+
+void Tab::removeView(View* view)
+{
+	std::vector<View*>::iterator it = std::find(m_views.begin(), m_views.end(), view);
+	if (it == m_views.end())
+	{
+		return;
+	}
+
+	m_views.erase(it);
+}
+
+void Tab::showView(View* view)
+{
+	if (m_parentLayout)
+	{
+		m_parentLayout->showView(view);
+	}
+}
+
+void Tab::hideView(View* view)
+{
+	if (m_parentLayout)
+	{
+		m_parentLayout->hideView(view);
+	}
+}
+
+void Tab::setViewEnabled(View* view, bool enabled)
+{
+	if (m_parentLayout)
+	{
+		m_parentLayout->setViewEnabled(view, enabled);
+	}
+}
+
+void Tab::handleMessage(MessageRefreshUI* message)
+{
+	m_componentManager.refreshViews();
+}

src/lib/component/Tab.h

@@ -0,0 +1,43 @@
+#ifndef TAB_H
+#define TAB_H
+
+#include <vector>
+
+#include "ComponentManager.h"
+#include "MessageListener.h"
+#include "MessageRefreshUI.h"
+#include "View.h"
+#include "ViewLayout.h"
+
+class Tab
+	: public ViewLayout
+	, public MessageListener<MessageRefreshUI>
+{
+public:
+	Tab(Id tabId, const ViewFactory* viewFactory, StorageAccess* storageAccess, ScreenSearchSender* screenSearchSender);
+	virtual ~Tab();
+
+	void setParentLayout(ViewLayout* parentLayout);
+
+	// ViewLayout implementation
+	void addView(View* view) override;
+	void removeView(View* view) override;
+
+	void showView(View* view) override;
+	void hideView(View* view) override;
+
+	void setViewEnabled(View* view, bool enabled) override;
+
+private:
+	void handleMessage(MessageRefreshUI* message) override;
+
+	const Id m_tabId;
+
+	ComponentManager m_componentManager;
+	std::vector<View*> m_views;
+
+	ViewLayout* m_parentLayout;
+	ScreenSearchSender* m_screenSearchSender;
+};
+
+#endif // TAB_H

src/lib/component/TabId.cpp

@@ -0,0 +1,34 @@
+#include "TabId.h"
+
+Id TabId::s_nextTabId = 10;
+Id TabId::s_currentTabId = 0;
+
+Id TabId::app()
+{
+	return 1;
+}
+
+Id TabId::background()
+{
+	return 2;
+}
+
+Id TabId::ignore()
+{
+	return 3;
+}
+
+Id TabId::nextTab()
+{
+	return s_nextTabId++;
+}
+
+Id TabId::currentTab()
+{
+	return s_currentTabId;
+}
+
+void TabId::setCurrentTabId(Id currentTabId)
+{
+	s_currentTabId = currentTabId;
+}

src/lib/component/TabId.h

@@ -0,0 +1,23 @@
+#ifndef TAB_ID_H
+#define TAB_ID_H
+
+#include "types.h"
+
+class TabId
+{
+public:
+	static Id app();
+	static Id background();
+	static Id ignore();
+
+	static Id nextTab();
+	static Id currentTab();
+
+	static void setCurrentTabId(Id currentTabId);
+
+private:
+	static Id s_nextTabId;
+	static Id s_currentTabId;
+};
+
+#endif // TAB_ID_H

src/lib/component/controller/ActivationController.cpp

@@ -19,10 +19,6 @@ ActivationController::ActivationController(StorageAccess* storageAccess)
 {
 }
 
-ActivationController::~ActivationController()
-{
-}
-
 void ActivationController::clear()
 {
 }
@@ -66,12 +62,15 @@ void ActivationController::handleMessage(MessageActivateFile* message)
 			true,
 			true
 		);
+		msg.setSchedulerId(message->getSchedulerId());
 		msg.dispatchImmediately();
 	}
 
 	if (message->line > 0)
 	{
-		MessageScrollToLine(message->filePath, message->line).dispatch();
+		MessageScrollToLine msg(message->filePath, message->line);
+		msg.setSchedulerId(message->getSchedulerId());
+		msg.dispatch();
 	}
 }
 
@@ -105,12 +104,13 @@ void ActivationController::handleMessage(MessageActivateTokenIds* message)
 
 void ActivationController::handleMessage(MessageActivateSourceLocations* message)
 {
-	MessageActivateNodes m;
+	MessageActivateNodes msg;
 	for (Id nodeId : m_storageAccess->getNodeIdsForLocationIds(message->locationIds))
 	{
-		m.addNode(nodeId);
+		msg.addNode(nodeId);
 	}
-	m.dispatchImmediately();
+	msg.setSchedulerId(message->getSchedulerId());
+	msg.dispatchImmediately();
 }
 
 void ActivationController::handleMessage(MessageResetZoom* message)
@@ -140,19 +140,25 @@ void ActivationController::handleMessage(MessageSearch* message)
 			case SearchMatch::COMMAND_ALL:
 			case SearchMatch::COMMAND_NODE_FILTER:
 			{
-				MessageActivateAll(message->acceptedNodeTypes).dispatchImmediately();
+				MessageActivateAll msg(message->acceptedNodeTypes);
+				msg.setSchedulerId(message->getSchedulerId());
+				msg.dispatch();
 				return;
 			}
 
 			case SearchMatch::COMMAND_ERROR:
 			{
-				MessageErrorsAll().dispatch();
+				MessageErrorsAll msg;
+				msg.setSchedulerId(message->getSchedulerId());
+				msg.dispatch();
 				return;
 			}
 
 			case SearchMatch::COMMAND_LEGEND:
 			{
-				MessageActivateLegend().dispatch();
+				MessageActivateLegend msg;
+				msg.setSchedulerId(message->getSchedulerId());
+				msg.dispatch();
 				return;
 			}
 		}

src/lib/component/controller/ActivationController.h

@@ -30,19 +30,18 @@ class ActivationController
 {
 public:
 	ActivationController(StorageAccess* storageAccess);
-	~ActivationController();
 
-	virtual void clear();
+	void clear() override;
 
 private:
-	virtual void handleMessage(MessageActivateEdge* message);
+	void handleMessage(MessageActivateEdge* message) override;
-	virtual void handleMessage(MessageActivateFile* message);
+	void handleMessage(MessageActivateFile* message) override;
-	virtual void handleMessage(MessageActivateNodes* message);
+	void handleMessage(MessageActivateNodes* message) override;
-	virtual void handleMessage(MessageActivateTokenIds* message);
+	void handleMessage(MessageActivateTokenIds* message) override;
-	virtual void handleMessage(MessageActivateSourceLocations* message);
+	void handleMessage(MessageActivateSourceLocations* message) override;
-	virtual void handleMessage(MessageResetZoom* message);
+	void handleMessage(MessageResetZoom* message) override;
-	virtual void handleMessage(MessageSearch* message);
+	void handleMessage(MessageSearch* message) override;
-	virtual void handleMessage(MessageZoom* message);
+	void handleMessage(MessageZoom* message) override;
 
 	StorageAccess* m_storageAccess;
 };

src/lib/component/controller/BookmarkController.cpp

@@ -10,7 +10,9 @@
 
 #include "MessageActivateEdge.h"
 #include "MessageActivateNodes.h"
+#include "MessageBookmarkButtonState.h"
 #include "logging.h"
+#include "TabId.h"
 #include "utilityString.h"
 #include "utility.h"
 
@@ -33,8 +35,6 @@ void BookmarkController::clear()
 {
 	m_activeNodeIds.clear();
 	m_activeEdgeIds.clear();
-
-	getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CANNOT_CREATE);
 }
 
 void BookmarkController::displayBookmarks()
@@ -62,18 +62,20 @@ void BookmarkController::createBookmark(
 ){
 	LOG_INFO("Attempting to create new bookmark");
 
+	Id tabId = TabId::currentTab();
+
 	BookmarkCategory bookmarkCategory(0, category.empty() ? s_defaultCategoryName : category);
 
-	if (!m_activeEdgeIds.empty())
+	if (!m_activeEdgeIds[tabId].empty())
 	{
 		LOG_INFO("Creating Edge Bookmark");
 
 		EdgeBookmark bookmark(0, name, comment, TimeStamp::now(), bookmarkCategory);
-		bookmark.setEdgeIds(m_activeEdgeIds);
+		bookmark.setEdgeIds(m_activeEdgeIds[tabId]);
 
-		if (!m_activeNodeIds.empty())
+		if (!m_activeNodeIds[TabId::currentTab()].empty())
 		{
-			bookmark.setActiveNodeId(m_activeNodeIds.front());
+			bookmark.setActiveNodeId(m_activeNodeIds[tabId].front());
 		}
 		else
 		{
@@ -93,16 +95,17 @@ void BookmarkController::createBookmark(
 		}
 		else
 		{
-			bookmark.setNodeIds(m_activeNodeIds);
+			bookmark.setNodeIds(m_activeNodeIds[TabId::currentTab()]);
 		}
+
 		m_storageAccess->addNodeBookmark(bookmark);
 	}
 
 	m_bookmarkCache.clear();
 
-	if (!nodeId || (m_activeNodeIds.size() == 1 && m_activeNodeIds[0] == nodeId))
+	if (!nodeId || (m_activeNodeIds[TabId::currentTab()].size() == 1 && m_activeNodeIds[TabId::currentTab()][0] == nodeId))
 	{
-		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
+		MessageBookmarkButtonState(TabId::currentTab(), MessageBookmarkButtonState::ALREADY_CREATED).dispatch();
 	}
 
 	update();
@@ -128,9 +131,9 @@ void BookmarkController::deleteBookmark(Id bookmarkId)
 
 	cleanBookmarkCategories();
 
-	if (!getBookmarkForActiveToken())
+	if (!getBookmarkForActiveToken(TabId::currentTab()))
 	{
-		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+		MessageBookmarkButtonState(TabId::currentTab(), MessageBookmarkButtonState::CAN_CREATE).dispatch();
 	}
 
 	update();
@@ -142,9 +145,9 @@ void BookmarkController::deleteBookmarkCategory(Id categoryId)
 
 	m_bookmarkCache.clear();
 
-	if (!getBookmarkForActiveToken())
+	if (!getBookmarkForActiveToken(TabId::currentTab()))
 	{
-		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+		MessageBookmarkButtonState(TabId::currentTab(), MessageBookmarkButtonState::CAN_CREATE).dispatch();
 	}
 
 	update();
@@ -152,7 +155,7 @@ void BookmarkController::deleteBookmarkCategory(Id categoryId)
 
 void BookmarkController::deleteBookmarkForActiveTokens()
 {
-	if (std::shared_ptr<Bookmark> bookmark = getBookmarkForActiveToken())
+	if (std::shared_ptr<Bookmark> bookmark = getBookmarkForActiveToken(TabId::currentTab()))
 	{
 		LOG_INFO(L"Deleting bookmark " + bookmark->getName());
 
@@ -160,7 +163,7 @@ void BookmarkController::deleteBookmarkForActiveTokens()
 
 		cleanBookmarkCategories();
 
-		getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+		MessageBookmarkButtonState(TabId::currentTab(), MessageBookmarkButtonState::CAN_CREATE).dispatch();
 		update();
 	}
 	else
@@ -223,7 +226,8 @@ void BookmarkController::activateBookmark(const std::shared_ptr<Bookmark> bookma
 
 void BookmarkController::showBookmarkCreator(Id nodeId)
 {
-	if (!canCreateBookmark() && !nodeId)
+	Id tabId = TabId::currentTab();
+	if (!m_activeNodeIds[tabId].size() && !m_activeEdgeIds[tabId].size() && !nodeId)
 	{
 		return;
 	}
@@ -244,7 +248,7 @@ void BookmarkController::showBookmarkCreator(Id nodeId)
 	}
 	else
 	{
-		std::shared_ptr<Bookmark> bookmark = getBookmarkForActiveToken();
+		std::shared_ptr<Bookmark> bookmark = getBookmarkForActiveToken(tabId);
 		if (bookmark != nullptr)
 		{
 			view->displayBookmarkEditor(bookmark, getAllBookmarkCategories());
@@ -297,69 +301,89 @@ void BookmarkController::handleMessage(MessageActivateAll* message)
 	clear();
 }
 
-void BookmarkController::handleMessage(MessageActivateBookmark* message)
+void BookmarkController::handleMessage(MessageActivateErrors* message)
 {
-	activateBookmark(message->bookmark);
+	clear();
 }
 
-void BookmarkController::handleMessage(MessageActivateErrors* message)
+void BookmarkController::handleMessage(MessageActivateFullTextSearch* message)
+{
+	clear();
+}
+
+void BookmarkController::handleMessage(MessageActivateLegend* message)
 {
 	clear();
 }
 
 void BookmarkController::handleMessage(MessageActivateTokens* message)
 {
-	m_activeEdgeIds.clear();
+	Id tabId = message->getSchedulerId();
+	m_activeEdgeIds[tabId].clear();
 
 	if (message->isEdge || message->isAggregation)
 	{
-		m_activeEdgeIds = message->tokenIds;
+		m_activeEdgeIds[tabId] = message->tokenIds;
 
-		if (getBookmarkForActiveToken())
+		if (getBookmarkForActiveToken(tabId))
 		{
-			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
+			MessageBookmarkButtonState(tabId, MessageBookmarkButtonState::ALREADY_CREATED).dispatch();
 		}
 		else
 		{
-			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+			MessageBookmarkButtonState(tabId, MessageBookmarkButtonState::CAN_CREATE).dispatch();
 		}
 	}
 	else if (!message->isEdge)
 	{
-		m_activeNodeIds = message->tokenIds;
+		m_activeNodeIds[tabId] = message->tokenIds;
 
-		if (getBookmarkForActiveToken())
+		if (getBookmarkForActiveToken(tabId))
 		{
-			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::ALREADY_CREATED);
+			MessageBookmarkButtonState(tabId, MessageBookmarkButtonState::ALREADY_CREATED).dispatch();
 		}
 		else
 		{
-			getView<BookmarkView>()->setCreateButtonState(BookmarkView::CreateButtonState::CAN_CREATE);
+			MessageBookmarkButtonState(tabId, MessageBookmarkButtonState::CAN_CREATE).dispatch();
 		}
 	}
 }
 
-void BookmarkController::handleMessage(MessageDisplayBookmarks* message)
+void BookmarkController::handleMessage(MessageBookmarkActivate* message)
+{
+	activateBookmark(message->bookmark);
+}
+
+void BookmarkController::handleMessage(MessageBookmarkBrowse* message)
 {
 	displayBookmarksFor(message->filter, message->order);
 }
 
-void BookmarkController::handleMessage(MessageDisplayBookmarkCreator* message)
+void BookmarkController::handleMessage(MessageBookmarkCreate* message)
 {
 	showBookmarkCreator(message->nodeId);
 }
 
+void BookmarkController::handleMessage(MessageBookmarkDelete* message)
+{
+	deleteBookmarkForActiveTokens();
+}
+
+void BookmarkController::handleMessage(MessageBookmarkEdit* message)
+{
+	showBookmarkCreator(0);
+}
+
 void BookmarkController::handleMessage(MessageIndexingFinished* message)
 {
 	m_bookmarkCache.clear();
-	getView<BookmarkView>()->enableDisplayBookmarks(true);
 
 	update();
 }
 
 std::vector<std::wstring> BookmarkController::getActiveTokenDisplayNames() const
 {
-	if (m_activeEdgeIds.size() > 0)
+	if (m_activeEdgeIds[TabId::currentTab()].size() > 0)
 	{
 		return getActiveEdgeDisplayNames();
 	}
@@ -379,14 +403,14 @@ std::vector<BookmarkCategory> BookmarkController::getAllBookmarkCategories() con
 	return m_storageAccess->getAllBookmarkCategories();
 }
 
-std::shared_ptr<Bookmark> BookmarkController::getBookmarkForActiveToken() const
+std::shared_ptr<Bookmark> BookmarkController::getBookmarkForActiveToken(Id tabId) const
 {
-	if (!m_activeEdgeIds.empty())
+	if (!m_activeEdgeIds[tabId].empty())
 	{
 		for (const std::shared_ptr<EdgeBookmark>& edgeBookmark: getAllEdgeBookmarks())
 		{
-			if (!m_activeNodeIds.empty() && edgeBookmark->getActiveNodeId() == m_activeNodeIds.front() &&
+			if (!m_activeNodeIds[tabId].empty() && edgeBookmark->getActiveNodeId() == m_activeNodeIds[tabId].front() &&
-				utility::isPermutation(edgeBookmark->getEdgeIds(), m_activeEdgeIds))
+				utility::isPermutation(edgeBookmark->getEdgeIds(), m_activeEdgeIds[tabId]))
 			{
 				return std::make_shared<EdgeBookmark>(*(edgeBookmark.get()));
 			}
@@ -396,7 +420,7 @@ std::shared_ptr<Bookmark> BookmarkController::getBookmarkForActiveToken() const
 	{
 		for (const std::shared_ptr<NodeBookmark>& nodeBookmark: getAllNodeBookmarks())
 		{
-			if (utility::isPermutation(nodeBookmark->getNodeIds(), m_activeNodeIds))
+			if (utility::isPermutation(nodeBookmark->getNodeIds(), m_activeNodeIds[tabId]))
 			{
 				return std::make_shared<NodeBookmark>(*(nodeBookmark.get()));
 			}
@@ -419,11 +443,6 @@ std::shared_ptr<Bookmark> BookmarkController::getBookmarkForNodeId(Id nodeId) co
 	return std::shared_ptr<Bookmark>();
 }
 
-bool BookmarkController::canCreateBookmark() const
-{
-	return m_activeNodeIds.size() || m_activeEdgeIds.size();
-}
-
 std::vector<std::shared_ptr<Bookmark>> BookmarkController::getAllBookmarks() const
 {
 	LOG_INFO("Retrieving all bookmarks");
@@ -476,7 +495,7 @@ std::vector<std::shared_ptr<Bookmark>> BookmarkController::getBookmarks(
 std::vector<std::wstring> BookmarkController::getActiveNodeDisplayNames() const
 {
 	std::vector<std::wstring> names;
-	for (Id nodeId : m_activeNodeIds)
+	for (Id nodeId : m_activeNodeIds[TabId::currentTab()])
 	{
 		names.push_back(getNodeDisplayName(nodeId));
 	}
@@ -486,7 +505,7 @@ std::vector<std::wstring> BookmarkController::getActiveNodeDisplayNames() const
 std::vector<std::wstring> BookmarkController::getActiveEdgeDisplayNames() const
 {
 	std::vector<std::wstring> activeEdgeDisplayNames;
-	for (Id activeEdgeId: m_activeEdgeIds)
+	for (Id activeEdgeId: m_activeEdgeIds[TabId::currentTab()])
 	{
 		const StorageEdge activeEdge = m_storageAccess->getEdgeById(activeEdgeId);
 		const std::wstring sourceDisplayName = getNodeDisplayName(activeEdge.sourceNodeId);

src/lib/component/controller/BookmarkController.h

@@ -6,13 +6,17 @@
 #include "EdgeBookmark.h"
 
 #include "MessageListener.h"
-#include "MessageActivateErrors.h"
-#include "MessageIndexingFinished.h"
 #include "MessageActivateAll.h"
-#include "MessageActivateBookmark.h"
+#include "MessageActivateErrors.h"
+#include "MessageActivateFullTextSearch.h"
+#include "MessageActivateLegend.h"
 #include "MessageActivateTokens.h"
-#include "MessageDisplayBookmarkCreator.h"
+#include "MessageBookmarkActivate.h"
-#include "MessageDisplayBookmarks.h"
+#include "MessageBookmarkBrowse.h"
+#include "MessageBookmarkCreate.h"
+#include "MessageBookmarkDelete.h"
+#include "MessageBookmarkEdit.h"
+#include "MessageIndexingFinished.h"
 
 #include "Controller.h"
 
@@ -21,18 +25,22 @@ class StorageAccess;
 class BookmarkController
 	: public Controller
 	, public MessageListener<MessageActivateAll>
-	, public MessageListener<MessageActivateBookmark>
 	, public MessageListener<MessageActivateErrors>
+	, public MessageListener<MessageActivateFullTextSearch>
+	, public MessageListener<MessageActivateLegend>
 	, public MessageListener<MessageActivateTokens>
-	, public MessageListener<MessageDisplayBookmarkCreator>
+	, public MessageListener<MessageBookmarkActivate>
-	, public MessageListener<MessageDisplayBookmarks>
+	, public MessageListener<MessageBookmarkBrowse>
+	, public MessageListener<MessageBookmarkCreate>
+	, public MessageListener<MessageBookmarkDelete>
+	, public MessageListener<MessageBookmarkEdit>
 	, public MessageListener<MessageIndexingFinished>
 {
 public:
 	BookmarkController(StorageAccess* storageAccess);
 	virtual ~BookmarkController();
 
-	virtual void clear();
+	void clear() override;
 
 	void displayBookmarks();
 	void displayBookmarksFor(Bookmark::BookmarkFilter filter, Bookmark::BookmarkOrder order);
@@ -68,20 +76,24 @@ private:
 		bool m_edgeBookmarksValid;
 	};
 
-	virtual void handleMessage(MessageActivateAll* message);
+	void handleMessage(MessageActivateAll* message) override;
-	virtual void handleMessage(MessageActivateBookmark* message);
+	void handleMessage(MessageActivateErrors* message) override;
-	virtual void handleMessage(MessageActivateErrors* message);
+	void handleMessage(MessageActivateFullTextSearch* message) override;
-	virtual void handleMessage(MessageActivateTokens* message);
+	void handleMessage(MessageActivateLegend* message) override;
-	virtual void handleMessage(MessageDisplayBookmarkCreator* message);
+	void handleMessage(MessageActivateTokens* message) override;
-	virtual void handleMessage(MessageDisplayBookmarks* message);
+	void handleMessage(MessageBookmarkActivate* message) override;
-	virtual void handleMessage(MessageIndexingFinished* message);
+	void handleMessage(MessageBookmarkBrowse* message) override;
+	void handleMessage(MessageBookmarkCreate* message) override;
+	void handleMessage(MessageBookmarkDelete* message) override;
+	void handleMessage(MessageBookmarkEdit* message) override;
+	void handleMessage(MessageIndexingFinished* message) override;
 
 	std::vector<std::wstring> getActiveTokenDisplayNames() const;
 	std::vector<std::wstring> getDisplayNamesForNodeId(Id nodeId) const;
 
 	std::vector<BookmarkCategory> getAllBookmarkCategories() const;
 
-	std::shared_ptr<Bookmark> getBookmarkForActiveToken() const;
+	std::shared_ptr<Bookmark> getBookmarkForActiveToken(Id tabId) const;
 	std::shared_ptr<Bookmark> getBookmarkForNodeId(Id nodeId) const;
 
 	bool canCreateBookmark() const;
@@ -118,8 +130,8 @@ private:
 	StorageAccess* m_storageAccess;
 	mutable BookmarkCache m_bookmarkCache;
 
-	std::vector<Id> m_activeNodeIds;
+	mutable std::map<Id, std::vector<Id>> m_activeNodeIds;
-	std::vector<Id> m_activeEdgeIds;
+	mutable std::map<Id, std::vector<Id>> m_activeEdgeIds;
 
 	Bookmark::BookmarkFilter m_filter;
 	Bookmark::BookmarkOrder m_order;

src/lib/component/controller/CodeController.cpp

@@ -20,8 +20,9 @@ CodeController::CodeController(StorageAccess* storageAccess)
 {
 }
 
-CodeController::~CodeController()
+Id CodeController::getSchedulerId() const
 {
+	return Controller::getTabId();
 }
 
 const uint CodeController::s_lineRadius = 2;

src/lib/component/controller/CodeController.h

@@ -58,33 +58,35 @@ class CodeController
 {
 public:
 	CodeController(StorageAccess* storageAccess);
-	~CodeController();
+	virtual ~CodeController() = default;
+
+	Id getSchedulerId() const override;
 
 private:
 	static const uint s_lineRadius;
 
-	virtual void handleMessage(MessageActivateAll* message);
+	void handleMessage(MessageActivateAll* message) override;
-	virtual void handleMessage(MessageActivateErrors* message);
+	void handleMessage(MessageActivateErrors* message) override;
-	virtual void handleMessage(MessageActivateFullTextSearch* message);
+	void handleMessage(MessageActivateFullTextSearch* message) override;
-	virtual void handleMessage(MessageActivateLegend* message);
+	void handleMessage(MessageActivateLegend* message) override;
-	virtual void handleMessage(MessageActivateLocalSymbols* message);
+	void handleMessage(MessageActivateLocalSymbols* message) override;
-	virtual void handleMessage(MessageActivateTokens* message);
+	void handleMessage(MessageActivateTokens* message) override;
-	virtual void handleMessage(MessageActivateTrailEdge* message);
+	void handleMessage(MessageActivateTrailEdge* message) override;
-	virtual void handleMessage(MessageChangeFileView* message);
+	void handleMessage(MessageChangeFileView* message) override;
-	virtual void handleMessage(MessageCodeShowDefinition* message);
+	void handleMessage(MessageCodeShowDefinition* message) override;
-	virtual void handleMessage(MessageDeactivateEdge* message);
+	void handleMessage(MessageDeactivateEdge* message) override;
-	virtual void handleMessage(MessageErrorCountClear* message);
+	void handleMessage(MessageErrorCountClear* message) override;
-	virtual void handleMessage(MessageFlushUpdates* message);
+	void handleMessage(MessageFlushUpdates* message) override;
-	virtual void handleMessage(MessageFocusIn* message);
+	void handleMessage(MessageFocusIn* message) override;
-	virtual void handleMessage(MessageFocusOut* message);
+	void handleMessage(MessageFocusOut* message) override;
-	virtual void handleMessage(MessageScrollCode* message);
+	void handleMessage(MessageScrollCode* message) override;
-	virtual void handleMessage(MessageScrollToLine* message);
+	void handleMessage(MessageScrollToLine* message) override;
-	virtual void handleMessage(MessageShowError* message);
+	void handleMessage(MessageShowError* message) override;
-	virtual void handleMessage(MessageShowScope* message);
+	void handleMessage(MessageShowScope* message) override;
 
 	CodeView* getView() const;
 
-	virtual void clear();
+	void clear() override;
 
 	std::vector<CodeSnippetParams> getSnippetsForFileWithState(const FilePath& filePath, CodeView::FileState state) const;
 	std::vector<CodeSnippetParams> getSnippetsForActiveSourceLocations(

src/lib/component/controller/Controller.cpp

@@ -1,6 +1,7 @@
 #include  "component/controller/Controller.h"
 
 Controller::Controller()
+	: m_component(nullptr)
 {
 }
 
@@ -12,3 +13,13 @@ void Controller::setComponent(Component* component)
 {
 	m_component = component;
 }
+
+Id Controller::getTabId() const
+{
+	if (m_component)
+	{
+		return m_component->getTabId();
+	}
+
+	return 0;
+}

src/lib/component/controller/Controller.h

@@ -13,6 +13,8 @@ public:
 
 	virtual void clear() = 0;
 
+	Id getTabId() const;
+
 protected:
 	template <typename ViewType>
 		ViewType* getView() const;

src/lib/component/controller/ErrorController.cpp

@@ -1,10 +1,11 @@
 #include "ErrorController.h"
 
 #include "Application.h"
-#include "DialogView.h"
-#include "StorageAccess.h"
-#include "Project.h"
 #include "ApplicationSettings.h"
+#include "DialogView.h"
+#include "Project.h"
+#include "StorageAccess.h"
+#include "TabId.h"
 
 ErrorController::ErrorController(StorageAccess* storageAccess)
 	: m_storageAccess(storageAccess)
@@ -17,19 +18,19 @@ ErrorController::~ErrorController()
 
 void ErrorController::errorFilterChanged(const ErrorFilter& filter)
 {
-	if (m_activeFilePath.empty())
+	if (m_tabActiveFilePath[TabId::currentTab()].empty())
 	{
 		MessageActivateErrors(filter).dispatch();
 	}
 	else
 	{
-		MessageActivateErrors(filter, m_activeFilePath).dispatch();
+		MessageActivateErrors(filter, m_tabActiveFilePath[TabId::currentTab()]).dispatch();
 	}
 }
 
 void ErrorController::showError(Id errorId)
 {
-	if (!m_showsErrors)
+	if (!m_tabShowsErrors[TabId::currentTab()])
 	{
 		errorFilterChanged(getView()->getErrorFilter());
 	}
@@ -39,15 +40,15 @@ void ErrorController::showError(Id errorId)
 
 void ErrorController::handleMessage(MessageActivateAll* message)
 {
-	m_showsErrors = false;
+	m_tabShowsErrors[message->getSchedulerId()] = false;
 }
 
 void ErrorController::handleMessage(MessageActivateErrors* message)
 {
 	clear();
 
-	m_showsErrors = true;
+	m_tabShowsErrors[message->getSchedulerId()] = true;
-	m_activeFilePath = message->file;
+	m_tabActiveFilePath[message->getSchedulerId()] = message->file;
 
 	ErrorView* view = getView();
 	view->setErrorFilter(message->filter);
@@ -60,12 +61,12 @@ void ErrorController::handleMessage(MessageActivateErrors* message)
 
 void ErrorController::handleMessage(MessageActivateFullTextSearch* message)
 {
-	m_showsErrors = false;
+	m_tabShowsErrors[message->getSchedulerId()] = false;
 }
 
 void ErrorController::handleMessage(MessageActivateTokens* message)
 {
-	m_showsErrors = false;
+	m_tabShowsErrors[message->getSchedulerId()] = false;
 }
 
 void ErrorController::handleMessage(MessageErrorCountClear* message)
@@ -178,9 +179,9 @@ ErrorView* ErrorController::getView() const
 
 void ErrorController::clear()
 {
-	m_showsErrors = false;
 	m_errorCount = 0;
-	m_activeFilePath = FilePath();
+	m_tabShowsErrors.clear();
+	m_tabActiveFilePath.clear();
 
 	getView()->clear();
 }
@@ -193,13 +194,13 @@ bool ErrorController::showErrors(const ErrorFilter& filter, bool scrollTo)
 	filterUnlimited.limit = 0;
 
 	std::vector<ErrorInfo> errors;
-	if (m_activeFilePath.empty())
+	if (m_tabActiveFilePath[TabId::currentTab()].empty())
 	{
 		errors = m_storageAccess->getErrorsLimited(filterUnlimited);
 	}
 	else
 	{
-		errors = m_storageAccess->getErrorsForFileLimited(filter, m_activeFilePath);
+		errors = m_storageAccess->getErrorsForFileLimited(filter, m_tabActiveFilePath[TabId::currentTab()]);
 	}
 
 	ErrorCountInfo errorCount(errors);

src/lib/component/controller/ErrorController.h

@@ -65,9 +65,10 @@ private:
 
 	StorageAccess* m_storageAccess;
 
-	bool m_showsErrors = false;
 	size_t m_errorCount = 0;
-	FilePath m_activeFilePath;
+
+	std::map<Id, bool> m_tabShowsErrors;
+	std::map<Id, FilePath> m_tabActiveFilePath;
 };
 
 #endif // ERROR_CONTROLLER_H

src/lib/component/controller/GraphController.cpp

@@ -28,8 +28,9 @@ GraphController::GraphController(StorageAccess* storageAccess)
 {
 }
 
-GraphController::~GraphController()
+Id GraphController::getSchedulerId() const
 {
+	return Controller::getTabId();
 }
 
 void GraphController::handleMessage(MessageActivateAll* message)

src/lib/component/controller/GraphController.h

@@ -52,29 +52,31 @@ class GraphController
 {
 public:
 	GraphController(StorageAccess* storageAccess);
-	~GraphController();
+	~GraphController() = default;
+
+	Id getSchedulerId() const override;
 
 private:
-	virtual void handleMessage(MessageActivateAll* message);
+	void handleMessage(MessageActivateAll* message) override;
-	virtual void handleMessage(MessageActivateErrors* message);
+	void handleMessage(MessageActivateErrors* message) override;
-	virtual void handleMessage(MessageActivateFullTextSearch* message);
+	void handleMessage(MessageActivateFullTextSearch* message) override;
-	virtual void handleMessage(MessageActivateLegend* message);
+	void handleMessage(MessageActivateLegend* message) override;
-	virtual void handleMessage(MessageActivateTokens* message);
+	void handleMessage(MessageActivateTokens* message) override;
-	virtual void handleMessage(MessageActivateTrail* message);
+	void handleMessage(MessageActivateTrail* message) override;
-	virtual void handleMessage(MessageActivateTrailEdge* message);
+	void handleMessage(MessageActivateTrailEdge* message) override;
-	virtual void handleMessage(MessageFlushUpdates* message);
+	void handleMessage(MessageFlushUpdates* message) override;
-	virtual void handleMessage(MessageFocusIn* message);
+	void handleMessage(MessageFocusIn* message) override;
-	virtual void handleMessage(MessageFocusOut* message);
+	void handleMessage(MessageFocusOut* message) override;
-	virtual void handleMessage(MessageGraphNodeBundleSplit* message);
+	void handleMessage(MessageGraphNodeBundleSplit* message) override;
-	virtual void handleMessage(MessageGraphNodeExpand* message);
+	void handleMessage(MessageGraphNodeExpand* message) override;
-	virtual void handleMessage(MessageGraphNodeHide* message);
+	void handleMessage(MessageGraphNodeHide* message) override;
-	virtual void handleMessage(MessageGraphNodeMove* message);
+	void handleMessage(MessageGraphNodeMove* message) override;
-	virtual void handleMessage(MessageScrollGraph* message);
+	void handleMessage(MessageScrollGraph* message) override;
-	virtual void handleMessage(MessageShowReference* message);
+	void handleMessage(MessageShowReference* message) override;
 
 	GraphView* getView() const;
 
-	virtual void clear();
+	void clear() override;
 
 	void createDummyGraph(const std::shared_ptr<Graph> graph);
 	void createDummyGraphAndSetActiveAndVisibility(

src/lib/component/controller/IDECommunicationController.cpp

@@ -2,12 +2,11 @@
 
 #include "FileSystem.h"
 #include "logging.h"
-#include "MessageActivateSourceLocations.h"
 #include "MessageActivateWindow.h"
+#include "MessagePingReceived.h"
 #include "MessageProjectNew.h"
 #include "MessageStatus.h"
-#include "MessageActivateFile.h"
+#include "MessageTabOpenWith.h"
-#include "MessagePingReceived.h"
 
 #include "StorageAccess.h"
 #include "SourceLocationFile.h"
@@ -118,7 +117,7 @@ void IDECommunicationController::handleSetActiveTokenMessage(
 					std::to_wstring(message.row) + L", col: " + std::to_wstring(message.column)
 				).dispatch();
 
-				MessageActivateSourceLocations(selectedLocationIds).dispatch();
+				MessageTabOpenWith(0, selectedLocationIds[0]).showNewTab(true).dispatch();
 				MessageActivateWindow().dispatch();
 				return;
 			}
@@ -126,7 +125,7 @@ void IDECommunicationController::handleSetActiveTokenMessage(
 
 		if (fileId > 0)
 		{
-			MessageActivateFile(filePath, message.row).dispatchImmediately();
+			MessageTabOpenWith(filePath, message.row).showNewTab(true).dispatch();
 			MessageActivateWindow().dispatch();
 		}
 		else

src/lib/component/controller/ScreenSearchController.cpp

@@ -2,14 +2,6 @@
 
 #include "ScreenSearchView.h"
 
-ScreenSearchController::ScreenSearchController()
-{
-}
-
-ScreenSearchController::~ScreenSearchController()
-{
-}
-
 void ScreenSearchController::clear()
 {
 }
@@ -54,15 +46,21 @@ void ScreenSearchController::addResponder(ScreenSearchResponder* responder)
 	}
 }
 
+void ScreenSearchController::removeResponder(ScreenSearchResponder* responder)
+{
+	if (responder)
+	{
+		auto it = std::find(m_responders.begin(), m_responders.end(), responder);
+		if (it != m_responders.end())
+		{
+			m_responders.erase(it);
+		}
+	}
+}
+
 void ScreenSearchController::search(const std::wstring& query, const std::set<std::string>& responderNames)
 {
-	{
+	clearMatches();
-		std::lock_guard<std::mutex> lock(m_matchMutex);
-		m_matches.clear();
-		m_matchIndex = 0;
-	}
-
-	getView<ScreenSearchView>()->setMatchCount(0);
 
 	for (ScreenSearchResponder* responder : m_responders)
 	{
@@ -75,10 +73,6 @@ void ScreenSearchController::search(const std::wstring& query, const std::set<st
 		{
 			responder->findMatches(this, query);
 		}
-		else
-		{
-			responder->clearMatches();
-		}
 	}
 }
 
@@ -133,6 +127,8 @@ void ScreenSearchController::clearMatches()
 		m_matchIndex = 0;
 	}
 
+	getView<ScreenSearchView>()->setMatchCount(0);
+
 	for (ScreenSearchResponder* responder : m_responders)
 	{
 		responder->clearMatches();

src/lib/component/controller/ScreenSearchController.h

@@ -13,19 +13,19 @@ class ScreenSearchController
 	, public ScreenSearchSender
 {
 public:
-	ScreenSearchController();
+	virtual ~ScreenSearchController() = default;
-	virtual ~ScreenSearchController();
 
 	// Controller implementation
-	virtual void clear();
+	void clear() override;
 
 	// ScreenSearchSender implementation
-	virtual void foundMatches(ScreenSearchResponder* responder, size_t matchCount);
+	void foundMatches(ScreenSearchResponder* responder, size_t matchCount) override;
+	void addResponder(ScreenSearchResponder* responder) override;
+	void removeResponder(ScreenSearchResponder* responder) override;
+	void clearMatches() override;
 
-	void addResponder(ScreenSearchResponder* responder);
 	void search(const std::wstring& query, const std::set<std::string>& responderNames);
 	void activateMatch(bool next);
-	void clearMatches();
 
 private:
 	size_t getResponderId(ScreenSearchResponder* responder) const;

src/lib/component/controller/SearchController.cpp

@@ -1,8 +1,9 @@
 #include "SearchController.h"
 
+#include "logging.h"
+#include "MessageTabState.h"
 #include "SearchView.h"
 #include "StorageAccess.h"
-#include "logging.h"
 #include "tracing.h"
 
 SearchController::SearchController(StorageAccess* storageAccess)
@@ -10,38 +11,37 @@ SearchController::SearchController(StorageAccess* storageAccess)
 {
 }
 
-SearchController::~SearchController()
+Id SearchController::getSchedulerId() const
 {
+	return Controller::getTabId();
 }
 
 void SearchController::handleMessage(MessageActivateAll* message)
 {
-	getView()->setMatches(message->getSearchMatches());
+	updateMatches(message);
 }
 
 void SearchController::handleMessage(MessageActivateErrors* message)
 {
-	getView()->setMatches(message->getSearchMatches());
+	updateMatches(message);
 }
 
 void SearchController::handleMessage(MessageActivateFullTextSearch* message)
 {
-	getView()->setMatches(message->getSearchMatches());
+	updateMatches(message);
 }
 
 void SearchController::handleMessage(MessageActivateLegend* message)
 {
-	getView()->setMatches(message->getSearchMatches());
+	updateMatches(message);
 }
 
 void SearchController::handleMessage(MessageActivateTokens* message)
 {
-	if (message->keepContent())
+	if (!message->isEdge)
 	{
-		return;
+		updateMatches(message, !message->keepContent());
 	}
-
-	getView()->setMatches(message->getSearchMatches());
 }
 
 void SearchController::handleMessage(MessageFind* message)
@@ -79,5 +79,22 @@ SearchView* SearchController::getView()
 
 void SearchController::clear()
 {
-	getView()->setMatches(std::vector<SearchMatch>());
+	updateMatches(nullptr);
+}
+
+void SearchController::updateMatches(MessageActivateBase* message, bool updateView)
+{
+	std::vector<SearchMatch> matches;
+
+	if (message)
+	{
+		matches = message->getSearchMatches();
+	}
+
+	if (updateView)
+	{
+		getView()->setMatches(matches);
+	}
+
+	MessageTabState(Controller::getTabId(), matches).dispatch();
 }

src/lib/component/controller/SearchController.h

@@ -26,20 +26,24 @@ class SearchController
 {
 public:
 	SearchController(StorageAccess* storageAccess);
-	~SearchController();
+	~SearchController() = default;
+
+	Id getSchedulerId() const override;
 
 private:
-	virtual void handleMessage(MessageActivateAll* message);
+	void handleMessage(MessageActivateAll* message) override;
-	virtual void handleMessage(MessageActivateErrors* message);
+	void handleMessage(MessageActivateErrors* message) override;
-	virtual void handleMessage(MessageActivateFullTextSearch* message);
+	void handleMessage(MessageActivateFullTextSearch* message) override;
-	virtual void handleMessage(MessageActivateLegend* message);
+	void handleMessage(MessageActivateLegend* message) override;
-	virtual void handleMessage(MessageActivateTokens* message);
+	void handleMessage(MessageActivateTokens* message) override;
-	virtual void handleMessage(MessageFind* message);
+	void handleMessage(MessageFind* message) override;
-	virtual void handleMessage(MessageSearchAutocomplete* message);
+	void handleMessage(MessageSearchAutocomplete* message) override;
 
 	SearchView* getView();
 
-	virtual void clear();
+	void clear() override;
+
+	void updateMatches(MessageActivateBase* message, bool updateView = true);
 
 	StorageAccess* m_storageAccess;
 };

src/lib/component/controller/TabsController.cpp

@@ -0,0 +1,224 @@
+#include "TabsController.h"
+
+#include "Application.h"
+#include "MessageFind.h"
+#include "MessageIndexingFinished.h"
+#include "MessageSearch.h"
+#include "MessageScrollToLine.h"
+#include "ScreenSearchInterfaces.h"
+#include "TabId.h"
+#include "TaskLambda.h"
+#include "TaskManager.h"
+#include "TaskScheduler.h"
+
+TabsController::TabsController(
+	ViewLayout* mainLayout,
+	const ViewFactory* viewFactory,
+	StorageAccess* storageAccess,
+	ScreenSearchSender* screenSearchSender
+)
+	: m_mainLayout(mainLayout)
+	, m_viewFactory(viewFactory)
+	, m_storageAccess(storageAccess)
+	, m_screenSearchSender(screenSearchSender)
+{
+}
+
+void TabsController::clear()
+{
+	getView()->clear();
+
+	while (true)
+	{
+		{
+			std::lock_guard<std::mutex> lock(m_tabsMutex);
+			if (m_tabs.empty())
+			{
+				break;
+			}
+		}
+
+		std::this_thread::sleep_for(std::chrono::milliseconds(100));
+	}
+}
+
+void TabsController::addTab(Id tabId, SearchMatch match)
+{
+	std::lock_guard<std::mutex> lock(m_tabsMutex);
+
+	TaskManager::createScheduler(tabId)->startSchedulerLoopThreaded();
+
+	m_tabs.emplace(tabId, std::make_shared<Tab>(tabId, m_viewFactory, m_storageAccess, m_screenSearchSender));
+
+	if (match.isValid())
+	{
+		MessageSearch msg({ match }, NodeTypeSet::all());
+		msg.setSchedulerId(tabId);
+		msg.dispatch();
+
+		if (match.tokenIds.size() && std::get<0>(m_scrollToLine) == match.tokenIds[0])
+		{
+			MessageScrollToLine scrollMsg(std::get<1>(m_scrollToLine), std::get<2>(m_scrollToLine));
+			scrollMsg.setSchedulerId(tabId);
+			scrollMsg.dispatch();
+		}
+	}
+	else
+	{
+		MessageFind msg;
+		msg.setSchedulerId(tabId);
+		msg.dispatch();
+	}
+
+	m_scrollToLine = std::make_tuple(0, FilePath(), 0);
+}
+
+void TabsController::showTab(Id tabId)
+{
+	std::lock_guard<std::mutex> lock(m_tabsMutex);
+
+	auto it = m_tabs.find(tabId);
+	if (it != m_tabs.end())
+	{
+		TabId::setCurrentTabId(tabId);
+		it->second->setParentLayout(m_mainLayout);
+	}
+	else
+	{
+		TabId::setCurrentTabId(0);
+		m_mainLayout->showOriginalViews();
+	}
+
+	Task::dispatch(
+		TabId::app(),
+		std::make_shared<TaskLambda>(
+			[this]()
+			{
+				m_screenSearchSender->clearMatches();
+			}
+		)
+	);
+}
+
+void TabsController::removeTab(Id tabId)
+{
+	// use app task scheduler thread to stop running tasks of tab
+	Task::dispatch(
+		TabId::background(),
+		std::make_shared<TaskLambda>(
+			[tabId, this]()
+			{
+				m_screenSearchSender->clearMatches();
+
+				TaskScheduler* scheduler = TaskManager::getScheduler(tabId).get();
+				scheduler->terminateRunningTasks();
+				scheduler->stopSchedulerLoop();
+
+				TaskManager::destroyScheduler(tabId);
+
+				getView()->destroyTab(tabId);
+			}
+		)
+	);
+}
+
+void TabsController::destroyTab(Id tabId)
+{
+	std::lock_guard<std::mutex> lock(m_tabsMutex);
+
+	// destroy the tab on the qt thread to allow view destruction
+	m_tabs.erase(tabId);
+
+	if (m_tabs.empty() && Application::getInstance()->isProjectLoaded())
+	{
+		MessageTabOpen().dispatch();
+	}
+}
+
+void TabsController::onClearTabs()
+{
+	TabId::setCurrentTabId(0);
+	m_mainLayout->showOriginalViews();
+}
+
+TabsView* TabsController::getView() const
+{
+	return Controller::getView<TabsView>();
+}
+
+void TabsController::handleMessage(MessageIndexingFinished* message)
+{
+	if (m_tabs.empty() && Application::getInstance()->isProjectLoaded())
+	{
+		MessageTabOpenWith(SearchMatch::createCommand(SearchMatch::COMMAND_ALL)).dispatch();
+	}
+}
+
+void TabsController::handleMessage(MessageTabClose* message)
+{
+	getView()->closeTab();
+}
+
+void TabsController::handleMessage(MessageTabOpen* message)
+{
+	if (Application::getInstance()->isProjectLoaded())
+	{
+		getView()->openTab(true, SearchMatch());
+	}
+}
+
+void TabsController::handleMessage(MessageTabOpenWith* message)
+{
+	if (!Application::getInstance()->isProjectLoaded())
+	{
+		return;
+	}
+
+	SearchMatch match = message->match;
+	if (!match.isValid())
+	{
+		Id tokenId = message->tokenId;
+		if (!tokenId && message->locationId)
+		{
+			std::vector<Id> tokenIds = m_storageAccess->getNodeIdsForLocationIds({ message->locationId });
+			if (tokenIds.size())
+			{
+				tokenId = tokenIds[0];
+			}
+		}
+
+		if (!tokenId && !message->filePath.empty())
+		{
+			tokenId = m_storageAccess->getNodeIdForFileNode(message->filePath);
+
+			if (message->line)
+			{
+				m_scrollToLine = std::make_tuple(tokenId, message->filePath, message->line);
+			}
+		}
+
+		if (tokenId)
+		{
+			std::vector<SearchMatch> matches = m_storageAccess->getSearchMatchesForTokenIds({ tokenId });
+			if (matches.size())
+			{
+				match = matches[0];
+			}
+		}
+	}
+
+	if (match.isValid())
+	{
+		getView()->openTab(message->showTab, match);
+	}
+}
+
+void TabsController::handleMessage(MessageTabSelect* message)
+{
+	getView()->selectTab(message->next);
+}
+
+void TabsController::handleMessage(MessageTabState* message)
+{
+	getView()->updateTab(message->tabId, message->searchMatches);
+}

src/lib/component/controller/TabsController.h

@@ -0,0 +1,69 @@
+#ifndef TABS_CONTROLLER_H
+#define TABS_CONTROLLER_H
+
+#include "MessageListener.h"
+#include "MessageIndexingFinished.h"
+#include "MessageTabClose.h"
+#include "MessageTabOpen.h"
+#include "MessageTabOpenWith.h"
+#include "MessageTabSelect.h"
+#include "MessageTabState.h"
+
+#include "Controller.h"
+#include "Tab.h"
+#include "TabsView.h"
+
+struct SearchMatch;
+
+class StorageAccess;
+class ViewFactory;
+class ViewLayout;
+
+class TabsController
+	: public Controller
+	, public MessageListener<MessageIndexingFinished>
+	, public MessageListener<MessageTabClose>
+	, public MessageListener<MessageTabOpen>
+	, public MessageListener<MessageTabOpenWith>
+	, public MessageListener<MessageTabSelect>
+	, public MessageListener<MessageTabState>
+{
+public:
+	TabsController(
+		ViewLayout* mainLayout,
+		const ViewFactory* viewFactory,
+		StorageAccess* storageAccess,
+		ScreenSearchSender* screenSearchSender
+	);
+
+	// Controller implementation
+	virtual void clear();
+
+	void addTab(Id tabId, SearchMatch match);
+	void showTab(Id tabId);
+	void removeTab(Id tabId);
+	void destroyTab(Id tabId);
+	void onClearTabs();
+
+private:
+	virtual void handleMessage(MessageIndexingFinished* message);
+	virtual void handleMessage(MessageTabClose* message);
+	virtual void handleMessage(MessageTabOpen* message);
+	virtual void handleMessage(MessageTabOpenWith* message);
+	virtual void handleMessage(MessageTabSelect* message);
+	virtual void handleMessage(MessageTabState* message);
+
+	TabsView* getView() const;
+
+	ViewLayout* m_mainLayout;
+	const ViewFactory* m_viewFactory;
+	StorageAccess* m_storageAccess;
+	ScreenSearchSender* m_screenSearchSender;
+
+	std::map<Id, std::shared_ptr<Tab>> m_tabs;
+	std::mutex m_tabsMutex;
+
+	std::tuple<Id, FilePath, size_t> m_scrollToLine;
+};
+
+#endif // TABS_CONTROLLER_H

src/lib/component/controller/TooltipController.cpp

@@ -6,6 +6,7 @@
 #include "StorageAccess.h"
 
 #include "MessageActivateSourceLocations.h"
+#include "TabId.h"
 #include "TaskDecoratorDelay.h"
 #include "TaskLambda.h"
 
@@ -143,7 +144,7 @@ void TooltipController::requestTooltipShow(const std::vector<Id> tokenIds, Toolt
 		delayMS = 300;
 	}
 
-	Task::dispatch(std::make_shared<TaskDecoratorDelay>(delayMS)->addChildTask(
+	Task::dispatch(TabId::app(), std::make_shared<TaskDecoratorDelay>(delayMS)->addChildTask(
 		std::make_shared<TaskLambda>(
 			[requestId, this]()
 			{
@@ -180,7 +181,7 @@ void TooltipController::requestTooltipHide()
 	}
 	m_hideRequest = true;
 
-	Task::dispatch(std::make_shared<TaskDecoratorDelay>(500)->addChildTask(
+	Task::dispatch(TabId::app(), std::make_shared<TaskDecoratorDelay>(500)->addChildTask(
 		std::make_shared<TaskLambda>(
 			[this]()
 			{

src/lib/component/controller/UndoRedoController.cpp

@@ -15,8 +15,9 @@ UndoRedoController::UndoRedoController(StorageAccess* storageAccess)
 	m_iterator = m_list.end();
 }
 
-UndoRedoController::~UndoRedoController()
+Id UndoRedoController::getSchedulerId() const
 {
+	return Controller::getTabId();
 }
 
 UndoRedoView* UndoRedoController::getView()
@@ -269,7 +270,10 @@ void UndoRedoController::handleMessage(MessageHistoryToPosition* message)
 				else
 				{
 					replayCommand(m_iterator);
-					MessageFlushUpdates(false).dispatch();
+
+					MessageFlushUpdates msg(false);
+					msg.setSchedulerId(getSchedulerId());
+					msg.dispatch();
 				}
 			}
 
@@ -359,7 +363,9 @@ void UndoRedoController::handleMessage(MessageRefreshUI* message)
 {
 	if (m_iterator == m_list.begin())
 	{
-		MessageActivateAll().dispatch();
+		MessageActivateAll msg;
+		msg.setSchedulerId(getSchedulerId());
+		msg.dispatch();
 	}
 	else
 	{
@@ -466,7 +472,9 @@ void UndoRedoController::replayCommands(std::list<Command>::iterator it)
 		std::advance(it, 1);
 	}
 
-	MessageFlushUpdates(keepsContent).dispatch();
+	MessageFlushUpdates msg(keepsContent);
+	msg.setSchedulerId(getSchedulerId());
+	msg.dispatch();
 }
 
 void UndoRedoController::replayCommand(std::list<Command>::iterator it)
@@ -512,6 +520,7 @@ void UndoRedoController::replayCommand(std::list<Command>::iterator it)
 			filter.unindexedFatal = false;
 
 			MessageActivateErrors msg(filter);
+			msg.setSchedulerId(getSchedulerId());
 			msg.setIsReplayed(true);
 			msg.setIsLast(it == std::prev(m_iterator));
 			msg.dispatch();
@@ -608,34 +617,7 @@ MessageBase* UndoRedoController::lastMessage() const
 
 void UndoRedoController::updateHistoryMenu(std::shared_ptr<MessageBase> message)
 {
-	const size_t historyMenuSize = 20;
+	Application::getInstance()->updateHistoryMenu(message);
-
-	if (message && dynamic_cast<MessageActivateBase*>(message.get()))
-	{
-		std::vector<SearchMatch> matches = dynamic_cast<MessageActivateBase*>(message.get())->getSearchMatches();
-		if (matches.size() && !matches[0].text.empty())
-		{
-			std::vector<std::shared_ptr<MessageBase>> history = { message };
-			std::set<SearchMatch> uniqueMatches = { matches[0] };
-
-			for (std::shared_ptr<MessageBase> m : m_history)
-			{
-				if (uniqueMatches.insert(dynamic_cast<MessageActivateBase*>(m.get())->getSearchMatches()[0]).second)
-				{
-					history.push_back(m);
-
-					if (history.size() >= historyMenuSize)
-					{
-						break;
-					}
-				}
-			}
-
-			m_history = history;
-		}
-	}
-
-	Application::getInstance()->updateHistoryMenu(m_history);
 }
 
 void UndoRedoController::updateHistory()

src/lib/component/controller/UndoRedoController.h

@@ -66,7 +66,9 @@ class UndoRedoController
 {
 public:
 	UndoRedoController(StorageAccess* storageAccess);
-	virtual ~UndoRedoController();
+	virtual ~UndoRedoController() = default;
+
+	Id getSchedulerId() const override;
 
 	UndoRedoView* getView();
 

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

@@ -11,8 +11,9 @@ template <typename ControllerType>
 class ControllerProxy
 {
 public:
-	ControllerProxy(View* view)
+	ControllerProxy(View* view, Id schedulerId)
 		: m_view(view)
+		, m_schedulerId(schedulerId)
 	{
 	}
 
@@ -30,7 +31,7 @@ public:
 		ControllerType* controller = m_view->getController<ControllerType>();
 		if (controller)
 		{
-			Task::dispatch(std::make_shared<TaskLambda>(
+			Task::dispatch(m_schedulerId, std::make_shared<TaskLambda>(
 				std::bind(callback, controller)
 			));
 		}
@@ -42,7 +43,7 @@ public:
 		ControllerType* controller = m_view->getController<ControllerType>();
 		if (controller)
 		{
-			Task::dispatch(std::make_shared<TaskLambda>(
+			Task::dispatch(m_schedulerId, std::make_shared<TaskLambda>(
 				[func = std::bind(callback, controller, args...)]()
 				{
 					func();
@@ -53,6 +54,7 @@ public:
 
 private:
 	View* m_view;
+	Id m_schedulerId;
 };
 
 #endif // CONTROLLER_PROXY_H

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

@@ -6,15 +6,20 @@ class ScreenSearchResponder;
 class ScreenSearchSender
 {
 public:
-	virtual ~ScreenSearchSender() {}
+	virtual ~ScreenSearchSender() = default;
 
 	virtual void foundMatches(ScreenSearchResponder* responder, size_t matchCount) = 0;
+
+	virtual void addResponder(ScreenSearchResponder* responder) = 0;
+	virtual void removeResponder(ScreenSearchResponder* responder) = 0;
+
+	virtual void clearMatches() = 0;
 };
 
 class ScreenSearchResponder
 {
 public:
-	virtual ~ScreenSearchResponder() {}
+	virtual ~ScreenSearchResponder() = default;
 
 	virtual std::string getName() const = 0;
 	virtual bool isVisible() const = 0;

src/lib/component/view/BookmarkButtonsView.cpp

@@ -0,0 +1,27 @@
+#include "BookmarkButtonsView.h"
+
+BookmarkButtonsView::BookmarkButtonsView(ViewLayout* viewLayout)
+	: View(viewLayout)
+	, m_schedulerId(0)
+{
+}
+
+std::string BookmarkButtonsView::getName() const
+{
+	return "BookmarkButtons";
+}
+
+Id BookmarkButtonsView::getSchedulerId() const
+{
+	return m_schedulerId;
+}
+
+void BookmarkButtonsView::setTabId(Id schedulerId)
+{
+	m_schedulerId = schedulerId;
+}
+
+void BookmarkButtonsView::handleMessage(MessageBookmarkButtonState* message)
+{
+	setCreateButtonState(message->state);
+}

src/lib/component/view/BookmarkButtonsView.h

@@ -0,0 +1,29 @@
+#ifndef BOOKMARK_BUTTONS_VIEW_H
+#define BOOKMARK_BUTTONS_VIEW_H
+
+#include "MessageBookmarkButtonState.h"
+#include "MessageListener.h"
+#include "View.h"
+
+class BookmarkButtonsView
+	: public View
+	, public MessageListener<MessageBookmarkButtonState>
+{
+public:
+	BookmarkButtonsView(ViewLayout* viewLayout);
+	virtual ~BookmarkButtonsView() = default;
+
+	std::string getName() const override;
+
+	Id getSchedulerId() const override;
+	void setTabId(Id schedulerId);
+
+	virtual void setCreateButtonState(const MessageBookmarkButtonState::ButtonState& state) = 0;
+
+private:
+	void handleMessage(MessageBookmarkButtonState* message) override;
+
+	Id m_schedulerId;
+};
+
+#endif // BOOKMARK_BUTTONS_VIEW_H

src/lib/component/view/BookmarkView.cpp

@@ -7,10 +7,6 @@ BookmarkView::BookmarkView(ViewLayout* viewLayout)
 {
 }
 
-BookmarkView::~BookmarkView()
-{
-}
-
 std::string BookmarkView::getName() const
 {
 	return "BookmarkView";

src/lib/component/view/BookmarkView.h

@@ -1,8 +1,8 @@
 #ifndef BOOKMARK_VIEW_H
 #define BOOKMARK_VIEW_H
 
-#include "View.h"
 #include "Bookmark.h"
+#include "View.h"
 
 class BookmarkController;
 
@@ -11,25 +11,15 @@ class BookmarkView
 {
 public:
 	BookmarkView(ViewLayout* viewLayout);
-	virtual ~BookmarkView();
+	virtual ~BookmarkView() = default;
 
 	virtual std::string getName() const;
 
-	enum CreateButtonState
-	{
-		CAN_CREATE = 0,
-		CANNOT_CREATE,
-		ALREADY_CREATED
-	};
-
-	virtual void setCreateButtonState(const CreateButtonState& state) = 0;
-
 	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::wstring>& names, const std::vector<BookmarkCategory>& categories, Id nodeId) = 0;
-	virtual void enableDisplayBookmarks(bool enable) = 0;
 
 	virtual bool bookmarkBrowserIsVisible() const = 0;
 

src/lib/component/view/CodeView.h

@@ -96,7 +96,7 @@ public:
 
 	virtual bool hasSingleFileCached(const FilePath& filePath) const = 0;
 
-private:
+protected:
 	CodeController* getController();
 };
 

src/lib/component/view/MainView.cpp

@@ -1,9 +1,35 @@
 #include "MainView.h"
 
-MainView::MainView()
+#include "TabId.h"
+
+MainView::MainView(const ViewFactory* viewFactory, StorageAccess* storageAccess)
+	: m_componentManager(viewFactory, storageAccess)
 {
 }
 
-MainView::~MainView()
+void MainView::setup()
 {
+	m_componentManager.setupMain(this, TabId::app());
+
+	loadLayout();
+
+	m_componentManager.refreshViews();
+}
+
+void MainView::clear()
+{
+	m_componentManager.clearComponents();
+	clearHistoryMenu();
+	clearBookmarksMenu();
+}
+
+void MainView::refreshViews()
+{
+	refreshView();
+	m_componentManager.refreshViews();
+}
+
+std::shared_ptr<DialogView> MainView::getDialogView(DialogView::UseCase useCase)
+{
+	return m_componentManager.getDialogView(useCase);
 }

src/lib/component/view/MainView.h

@@ -5,18 +5,27 @@
 #include <string>
 #include <vector>
 
+#include "ComponentManager.h"
+#include "DialogView.h"
 #include "ViewLayout.h"
 
-struct SearchMatch;
 class Bookmark;
 class MessageBase;
+class StorageAccess;
+class ViewFactory;
 
 class MainView
 	: public ViewLayout
 {
 public:
-	MainView();
+	MainView(const ViewFactory* viewFactory, StorageAccess* storageAccess);
-	virtual ~MainView();
+	virtual ~MainView() = default;
+
+	void setup();
+	void clear();
+	void refreshViews();
+
+	std::shared_ptr<DialogView> getDialogView(DialogView::UseCase useCase);
 
 	virtual void loadLayout() = 0;
 	virtual void saveLayout() = 0;
@@ -30,8 +39,15 @@ public:
 	virtual void activateWindow() = 0;
 
 	virtual void updateRecentProjectMenu() = 0;
-	virtual void updateHistoryMenu(const std::vector<std::shared_ptr<MessageBase>>& historyMenuItems) = 0;
+
+	virtual void updateHistoryMenu(std::shared_ptr<MessageBase> message) = 0;
+	virtual void clearHistoryMenu() = 0;
+
 	virtual void updateBookmarksMenu(const std::vector<std::shared_ptr<Bookmark>>& bookmarks) = 0;
+	virtual void clearBookmarksMenu() = 0;
+
+protected:
+	ComponentManager m_componentManager;
 };
 
 #endif // MAIN_VIEW_H

src/lib/component/view/TabsView.cpp

@@ -0,0 +1,11 @@
+#include "TabsView.h"
+
+TabsView::TabsView(ViewLayout* viewLayout)
+	: View(viewLayout)
+{
+}
+
+std::string TabsView::getName() const
+{
+	return "Tabs";
+}

src/lib/component/view/TabsView.h

@@ -0,0 +1,28 @@
+#ifndef TABS_VIEW_H
+#define TABS_VIEW_H
+
+#include <vector>
+
+#include "View.h"
+
+struct SearchMatch;
+
+class TabsView
+	: public View
+{
+public:
+	TabsView(ViewLayout* viewLayout);
+	virtual ~TabsView() = default;
+
+	virtual std::string getName() const;
+
+	virtual void clear() = 0;
+
+	virtual void openTab(bool showTab, SearchMatch match) = 0;
+	virtual void closeTab() = 0;
+	virtual void destroyTab(Id tabId) = 0;
+	virtual void selectTab(bool next) = 0;
+	virtual void updateTab(Id tabId, std::vector<SearchMatch> matches) = 0;
+};
+
+#endif // TABS_VIEW_H

src/lib/component/view/View.cpp

@@ -3,16 +3,12 @@
 #include "ViewWidgetWrapper.h"
 
 View::View(ViewLayout* viewLayout)
-	: m_viewLayout(viewLayout)
+	: m_component(nullptr)
+	, m_viewLayout(viewLayout)
 	, m_widgetWrapper(nullptr)
 {
 }
 
-View::~View()
-{
-	m_viewLayout->removeView(this);
-}
-
 void View::init()
 {
 	createWidgetWrapper();

src/lib/component/view/View.h

@@ -22,7 +22,7 @@ public:
 	static std::shared_ptr<T> createAndInit(ViewLayout* viewLayout);
 
 	View(ViewLayout* viewLayout);
-	virtual ~View();
+	virtual ~View() = default;
 
 	virtual std::string getName() const = 0;
 

src/lib/component/view/ViewFactory.cpp

@@ -1,5 +0,0 @@
-#include "ViewFactory.h"
-
-ViewFactory::ViewFactory()
-{
-}

src/lib/component/view/ViewFactory.h

@@ -6,10 +6,12 @@
 #include "CompositeView.h"
 #include "DialogView.h"
 
+class BookmarkButtonsView;
 class BookmarkView;
 class CodeView;
 class ErrorView;
 class GraphView;
+class GraphViewStyleImpl;
 class MainView;
 class RefreshView;
 class ScreenSearchView;
@@ -18,6 +20,7 @@ class StatusBarView;
 class StatusView;
 class StorageAccess;
 class TabbedView;
+class TabsView;
 class TooltipView;
 class UndoRedoView;
 class ViewLayout;
@@ -25,14 +28,14 @@ class ViewLayout;
 class ViewFactory
 {
 public:
-	ViewFactory();
 	virtual ~ViewFactory() = default;
 
-	virtual std::shared_ptr<MainView> createMainView() const = 0;
+	virtual std::shared_ptr<MainView> createMainView(StorageAccess* storageAccess) const = 0;
 	virtual std::shared_ptr<CompositeView> createCompositeView(
 			ViewLayout* viewLayout, CompositeView::CompositeDirection direction, const std::string& name) const = 0;
 	virtual std::shared_ptr<TabbedView> createTabbedView(ViewLayout* viewLayout, const std::string& name) const = 0;
 
+	virtual std::shared_ptr<BookmarkButtonsView> createBookmarkButtonsView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<BookmarkView> createBookmarkView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<CodeView> createCodeView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<ErrorView> createErrorView(ViewLayout* viewLayout) const = 0;
@@ -42,11 +45,14 @@ public:
 	virtual std::shared_ptr<SearchView> createSearchView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<StatusBarView> createStatusBarView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<StatusView> createStatusView(ViewLayout* viewLayout) const = 0;
+	virtual std::shared_ptr<TabsView> createTabsView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<TooltipView> createTooltipView(ViewLayout* viewLayout) const = 0;
 	virtual std::shared_ptr<UndoRedoView> createUndoRedoView(ViewLayout* viewLayout) const = 0;
 
 	virtual std::shared_ptr<DialogView> createDialogView(
 		ViewLayout* viewLayout, DialogView::UseCase useCase, StorageAccess* storageAccess) const = 0;
+
+	virtual std::shared_ptr<GraphViewStyleImpl> createGraphStyleImpl() const = 0;
 };
 
 #endif // VIEW_FACTORY_H

src/lib/component/view/ViewLayout.cpp

@@ -1,10 +1,6 @@
 #include "ViewLayout.h"
 
-ViewLayout::ViewLayout()
+void ViewLayout::overrideView(View* view)
-{
-}
-
-ViewLayout::~ViewLayout()
 {
 }
 
@@ -12,3 +8,7 @@ View* ViewLayout::findFloatingView(const std::string& name) const
 {
 	return nullptr;
 }
+
+void ViewLayout::showOriginalViews()
+{
+}

src/lib/component/view/ViewLayout.h

@@ -8,10 +8,10 @@ class View;
 class ViewLayout
 {
 public:
-	ViewLayout();
+	virtual ~ViewLayout() = default;
-	virtual ~ViewLayout();
 
 	virtual void addView(View* view) = 0;
+	virtual void overrideView(View* view);
 	virtual void removeView(View* view) = 0;
 
 	virtual void showView(View* view) = 0;
@@ -20,6 +20,8 @@ public:
 	virtual void setViewEnabled(View* view, bool enabled) = 0;
 
 	virtual View* findFloatingView(const std::string& name) const;
+
+	virtual void showOriginalViews();
 };
 
 #endif // VIEW_LAYOUT_H

src/lib/data/storage/PersistentStorage.cpp

@@ -513,18 +513,21 @@ std::shared_ptr<SourceLocationCollection> PersistentStorage::getFullTextSearchLo
 {
 	TRACE();
 
-	const TextCodec codec(ApplicationSettings::getInstance()->getTextEncoding());
-
 	std::shared_ptr<SourceLocationCollection> collection = std::make_shared<SourceLocationCollection>();
 	if (searchTerm.empty())
 	{
 		return collection;
 	}
 
-	if (m_fullTextSearchCodec != codec.getName())
+	const TextCodec codec(ApplicationSettings::getInstance()->getTextEncoding());
 	{
-		MessageStatus(L"Building fulltext search index", false, true).dispatch();
+		std::lock_guard<std::mutex> lock(m_fullTextSearchMutex);
-		buildFullTextSearchIndex();
+
+		if (m_fullTextSearchCodec != codec.getName())
+		{
+			MessageStatus(L"Building fulltext search index", false, true).dispatch();
+			buildFullTextSearchIndex();
+		}
 	}
 
 	MessageStatus(

src/lib/data/storage/PersistentStorage.h

@@ -212,6 +212,7 @@ private:
 
 	mutable FullTextSearchIndex m_fullTextSearchIndex;
 	mutable std::string m_fullTextSearchCodec;
+	mutable std::mutex m_fullTextSearchMutex;
 
 	SqliteIndexStorage m_sqliteIndexStorage;
 	SqliteBookmarkStorage m_sqliteBookmarkStorage;

src/lib/project/Project.cpp

@@ -28,6 +28,7 @@
 #include "MessageIndexingStatus.h"
 #include "MessageRefresh.h"
 #include "MessageStatus.h"
+#include "TabId.h"
 #include "TaskDecoratorRepeat.h"
 #include "TaskFindKeyOnBlackboard.h"
 #include "TaskGroupSelector.h"
@@ -71,6 +72,23 @@ std::string Project::getDescription() const
 	return m_settings->getDescription();
 }
 
+bool Project::isLoaded() const
+{
+	switch (m_state)
+	{
+		case PROJECT_STATE_EMPTY:
+		case PROJECT_STATE_LOADED:
+		case PROJECT_STATE_OUTDATED:
+		case PROJECT_STATE_NEEDS_MIGRATION:
+			return true;
+
+		default:
+			break;
+	}
+
+	return false;
+}
+
 bool Project::isIndexing() const
 {
 	return m_refreshStage == RefreshStageType::INDEXING;
@@ -238,8 +256,6 @@ void Project::refresh(RefreshMode refreshMode, std::shared_ptr<DialogView> dialo
 		return;
 	}
 
-	m_refreshStage = RefreshStageType::REFRESHING;
-
 	if (m_state == PROJECT_STATE_NOT_LOADED)
 	{
 		return;
@@ -312,6 +328,8 @@ void Project::refresh(RefreshMode refreshMode, std::shared_ptr<DialogView> dialo
 		}
 	}
 
+	m_refreshStage = RefreshStageType::REFRESHING;
+
 	if (m_state == PROJECT_STATE_NEEDS_MIGRATION)
 	{
 		m_settings->migrate();
@@ -324,6 +342,7 @@ void Project::refresh(RefreshMode refreshMode, std::shared_ptr<DialogView> dialo
 	{
 		if (!sourceGroup->prepareIndexing())
 		{
+			m_refreshStage = RefreshStageType::NONE;
 			return;
 		}
 	}
@@ -554,7 +573,7 @@ void Project::buildIndex(const RefreshInfo& info, std::shared_ptr<DialogView> di
 		std::make_shared<TaskGroupSequence>()->addChildTasks(
 			std::make_shared<TaskFindKeyOnBlackboard>("keep_database"),
 			std::make_shared<TaskLambda>([dialogView, this]() {
-				Task::dispatch(std::make_shared<TaskLambda>([dialogView, this]() {
+				Task::dispatch(TabId::app(), std::make_shared<TaskLambda>([dialogView, this]() {
 					swapToTempStorage(dialogView);
 				}));
 			})
@@ -562,7 +581,7 @@ void Project::buildIndex(const RefreshInfo& info, std::shared_ptr<DialogView> di
 		std::make_shared<TaskGroupSequence>()->addChildTasks(
 			std::make_shared<TaskFindKeyOnBlackboard>("discard_database"),
 			std::make_shared<TaskLambda>([this]() {
-				Task::dispatch(std::make_shared<TaskLambda>([this]() {
+				Task::dispatch(TabId::app(), std::make_shared<TaskLambda>([this]() {
 					discardTempStorage();
 				}));
 			})
@@ -575,7 +594,7 @@ void Project::buildIndex(const RefreshInfo& info, std::shared_ptr<DialogView> di
 	}));
 
 	taskSequential->setIsBackgroundTask(true);
-	Task::dispatch(taskSequential);
+	Task::dispatch(TabId::app(), taskSequential);
 
 	m_refreshStage = RefreshStageType::INDEXING;
 	MessageIndexingStarted().dispatch();

src/lib/project/Project.h

@@ -30,6 +30,7 @@ public:
 	FilePath getProjectSettingsFilePath() const;
 	std::string getDescription() const;
 
+	bool isLoaded() const;
 	bool isIndexing() const;
 
 	bool settingsEqualExceptNameAndLocation(const ProjectSettings& otherSettings) const;

src/lib/utility/messaging/MessageBase.h

@@ -12,6 +12,7 @@ class MessageBase
 public:
 	MessageBase()
 		: m_id(s_nextId++)
+		, m_schedulerId(0)
 		, m_isParallel(false)
 		, m_isReplayed(false)
 		, m_sendAsTask(true)
@@ -21,9 +22,7 @@ public:
 	{
 	}
 
-	virtual ~MessageBase()
+	virtual ~MessageBase() = default;
-	{
-	}
 
 	virtual std::string getType() const = 0;
 	virtual void dispatch() = 0;
@@ -33,6 +32,16 @@ public:
 		return m_id;
 	}
 
+	Id getSchedulerId() const
+	{
+		return m_schedulerId;
+	}
+
+	void setSchedulerId(Id schedulerId)
+	{
+		m_schedulerId = schedulerId;
+	}
+
 	bool sendAsTask() const
 	{
 		return m_sendAsTask;
@@ -107,6 +116,7 @@ private:
 	static Id s_nextId;
 
 	Id m_id;
+	Id m_schedulerId;
 
 	bool m_isParallel;
 	bool m_isReplayed;

src/lib/utility/messaging/MessageListenerBase.h

@@ -53,6 +53,11 @@ public:
 		m_alive = false;
 	}
 
+	virtual Id getSchedulerId() const
+	{
+		return 0;
+	}
+
 private:
 	virtual std::string doGetType() const = 0;
 	virtual void doHandleMessageBase(MessageBase*) = 0;

src/lib/utility/messaging/MessageQueue.cpp

@@ -10,6 +10,7 @@
 #include "TaskGroupParallel.h"
 #include "TaskGroupSequence.h"
 #include "TaskLambda.h"
+#include "TabId.h"
 
 std::shared_ptr<MessageQueue> MessageQueue::getInstance()
 {
@@ -252,7 +253,9 @@ void MessageQueue::sendMessage(std::shared_ptr<MessageBase> message)
 	{
 		MessageListenerBase* listener = m_listeners[m_currentListenerIndex];
 
-		if (listener->getType() == message->getType())
+		if (listener->getType() == message->getType() &&
+			(message->getSchedulerId() == 0 || listener->getSchedulerId() == 0 ||
+			listener->getSchedulerId() == message->getSchedulerId()))
 		{
 			// The listenersMutex gets unlocked so changes to listeners are possible while message handling.
 			m_listenersMutex.unlock();
@@ -280,7 +283,9 @@ void MessageQueue::sendMessageAsTask(std::shared_ptr<MessageBase> message, bool
 		{
 			MessageListenerBase* listener = m_listeners[i];
 
-			if (listener->getType() == message->getType())
+			if (listener->getType() == message->getType() &&
+				(message->getSchedulerId() == 0 || listener->getSchedulerId() == 0 ||
+				listener->getSchedulerId() == message->getSchedulerId()))
 			{
 				Id listenerId = listener->getId();
 				taskGroup->addTask(std::make_shared<TaskLambda>(
@@ -297,12 +302,18 @@ void MessageQueue::sendMessageAsTask(std::shared_ptr<MessageBase> message, bool
 		}
 	}
 
+	Id schedulerId = message->getSchedulerId();
+	if (!schedulerId)
+	{
+		schedulerId = TabId::app();
+	}
+
 	if (asNextTask)
 	{
-		Task::dispatchNext(taskGroup);
+		Task::dispatchNext(schedulerId, taskGroup);
 	}
 	else
 	{
-		Task::dispatch(taskGroup);
+		Task::dispatch(schedulerId, taskGroup);
 	}
 }

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

@@ -5,6 +5,7 @@
 #include "MessageActivateBase.h"
 
 #include "NodeTypeSet.h"
+#include "TabId.h"
 
 class MessageActivateAll
 	: public Message<MessageActivateAll>
@@ -20,6 +21,7 @@ public:
 		: acceptedNodeTypes(acceptedNodeTypes)
 	{
 		setIsParallel(true);
+		setSchedulerId(TabId::currentTab());
 	}
 
 	std::vector<SearchMatch> getSearchMatches() const override

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

@@ -1,29 +0,0 @@
-#ifndef MESSAGE_ACTIVATE_BOOKMARK_H
-#define MESSAGE_ACTIVATE_BOOKMARK_H
-
-#include "Message.h"
-
-#include "Bookmark.h"
-
-class MessageActivateBookmark
-	: public Message<MessageActivateBookmark>
-{
-public:
-	MessageActivateBookmark(const std::shared_ptr<Bookmark>& bookmark)
-		: bookmark(bookmark)
-	{
-	}
-
-	virtual ~MessageActivateBookmark()
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageActivateBookmark";
-	}
-
-	const std::shared_ptr<Bookmark> bookmark;
-};
-
-#endif // MESSAGE_ACTIVATE_BOOKMARK_H

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

@@ -7,6 +7,7 @@
 #include "Message.h"
 #include "types.h"
 #include "utilityString.h"
+#include "TabId.h"
 
 class MessageActivateEdge
 	: public Message<MessageActivateEdge>
@@ -22,6 +23,8 @@ public:
 		{
 			setKeepContent(true);
 		}
+
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -3,14 +3,17 @@
 
 #include "Message.h"
 #include "FilePath.h"
+#include "TabId.h"
 
-class MessageActivateFile: public Message<MessageActivateFile>
+class MessageActivateFile
+	: public Message<MessageActivateFile>
 {
 public:
 	MessageActivateFile(const FilePath& filePath, unsigned int line = 0)
 		: filePath(filePath)
 		, line(line)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -3,6 +3,7 @@
 
 #include "Message.h"
 #include "MessageActivateBase.h"
+#include "TabId.h"
 
 class MessageActivateFullTextSearch
 	: public Message<MessageActivateFullTextSearch>
@@ -18,6 +19,7 @@ public:
 		: searchTerm(searchTerm)
 		, caseSensitive(caseSensitive)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	void print(std::wostream& os) const override

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

@@ -3,6 +3,7 @@
 
 #include "Message.h"
 #include "types.h"
+#include "TabId.h"
 
 class MessageActivateLocalSymbols
 	: public Message<MessageActivateLocalSymbols>
@@ -10,11 +11,13 @@ class MessageActivateLocalSymbols
 public:
 	MessageActivateLocalSymbols()
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	MessageActivateLocalSymbols(const std::vector<Id>& symbolIds)
 		: symbolIds(symbolIds)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	void addSymbol(Id symbolId)

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

@@ -2,6 +2,7 @@
 #define MESSAGE_ACTIVATE_NODES_H
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 
 class MessageActivateNodes
@@ -24,6 +25,8 @@ public:
 		{
 			addNode(tokenId);
 		}
+
+		setSchedulerId(TabId::currentTab());
 	}
 
 	void addNode(Id tokenId)

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

@@ -2,6 +2,7 @@
 #define MESSAGE_ACTIVATE_SOURCE_LOCATIONS_H
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 
 class MessageActivateSourceLocations
@@ -11,6 +12,7 @@ public:
 	MessageActivateSourceLocations(const std::vector<Id>& locationIds)
 		: locationIds(locationIds)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_ACTIVATE_TOKEN_IDS_H
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 
 class MessageActivateTokenIds
@@ -11,6 +12,7 @@ public:
 	MessageActivateTokenIds(const std::vector<Id>& tokenIds)
 		: tokenIds(tokenIds)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -24,6 +24,7 @@ public:
 	{
 		setIsParallel(true);
 		setKeepContent(other->keepContent());
+		setSchedulerId(other->getSchedulerId());
 	}
 
 	void print(std::wostream& os) const override

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

@@ -3,6 +3,7 @@
 
 #include "Message.h"
 #include "types.h"
+#include "TabId.h"
 
 class MessageActivateTrail
 	: public Message<MessageActivateTrail>
@@ -15,6 +16,7 @@ public:
 		, depth(depth)
 		, horizontalLayout(horizontalLayout)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -5,6 +5,7 @@
 #include "NameHierarchy.h"
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 #include "utilityString.h"
 
@@ -21,6 +22,7 @@ public:
 		, sourceNameHierarchy(sourceNameHierarchy)
 		, targetNameHierarchy(targetNameHierarchy)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -3,6 +3,7 @@
 
 #include "FilePath.h"
 #include "Message.h"
+#include "TabId.h"
 
 class MessageChangeFileView
 	: public Message<MessageChangeFileView>
@@ -37,6 +38,7 @@ public:
 		, showErrors(showErrors)
 		, switchesViewMode(switchesViewMode)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_CODE_REFERENCE_H
 
 #include "Message.h"
+#include "TabId.h"
 
 class MessageCodeReference
 	: public Message<MessageCodeReference>
@@ -17,6 +18,7 @@ public:
 		: type(type)
 		, localReference(localReference)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_DEACTIVATE_EDGE_H
 
 #include "Message.h"
+#include "TabId.h"
 
 class MessageDeactivateEdge
 	: public Message<MessageDeactivateEdge>
@@ -10,6 +11,7 @@ public:
 	MessageDeactivateEdge(bool scrollToDefinition)
 		: scrollToDefinition(scrollToDefinition)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -1,23 +0,0 @@
-#ifndef MESSAGE_DISPLAY_BOOKMARK_CREATOR_H
-#define MESSAGE_DISPLAY_BOOKMARK_CREATOR_H
-
-#include "Message.h"
-
-class MessageDisplayBookmarkCreator
-	: public Message<MessageDisplayBookmarkCreator>
-{
-public:
-	MessageDisplayBookmarkCreator(Id nodeId = 0)
-		: nodeId(nodeId)
-	{
-	}
-
-	static const std::string getStaticType()
-	{
-		return "MessageDisplayBookmarkCreator";
-	}
-
-	const Id nodeId;
-};
-
-#endif // MESSAGE_DISPLAY_BOOKMARK_CREATOR_H

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

@@ -2,6 +2,7 @@
 #define MESSAGE_FIND_H
 
 #include "Message.h"
+#include "TabId.h"
 
 class MessageFind
 	: public Message<MessageFind>
@@ -10,6 +11,7 @@ public:
 	MessageFind(bool fulltext = false)
 		: findFulltext(fulltext)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_FLUSH_UPDATES_H
 
 #include "Message.h"
+#include "TabId.h"
 
 class MessageFlushUpdates:
 	public Message<MessageFlushUpdates>
@@ -10,6 +11,7 @@ public:
 	MessageFlushUpdates(bool keepsContent = false)
 	{
 		setKeepContent(keepsContent);
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -4,6 +4,7 @@
 #include <vector>
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 
 #include "TooltipOrigin.h"
@@ -17,6 +18,7 @@ public:
 		, origin(origin)
 	{
 		setIsLogged(false);
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -4,6 +4,7 @@
 #include <vector>
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 
 class MessageFocusOut
@@ -14,6 +15,7 @@ public:
 		: tokenIds(tokenIds)
 	{
 		setIsLogged(false);
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_GRAPH_NODE_BUNDLE_SPLIT_H
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 
 class MessageGraphNodeBundleSplit
@@ -13,6 +14,7 @@ public:
 		, removeOtherNodes(removeOtherNodes)
 		, layoutToList(layoutToList)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -3,6 +3,7 @@
 
 #include "Message.h"
 #include "types.h"
+#include "TabId.h"
 
 class MessageGraphNodeExpand
 	: public Message<MessageGraphNodeExpand>
@@ -13,6 +14,7 @@ public:
 		, expand(expand)
 		, ignoreIfNotReplayed(ignoreIfNotReplayed)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_GRAPH_NODE_HIDE_H
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 
 class MessageGraphNodeHide
@@ -11,6 +12,7 @@ public:
 	MessageGraphNodeHide(Id tokenId)
 		: tokenId(tokenId)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -1,9 +1,10 @@
 #ifndef MESSAGE_GRAPH_NODE_MOVE_H
 #define MESSAGE_GRAPH_NODE_MOVE_H
 
-#include "Vector2.h"
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
+#include "Vector2.h"
 
 class MessageGraphNodeMove
 	: public Message<MessageGraphNodeMove>
@@ -13,6 +14,7 @@ public:
 		: tokenId(tokenId)
 		, delta(delta)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_SCROLL_CODE_H
 
 #include "Message.h"
+#include "TabId.h"
 
 class MessageScrollCode
 	: public Message<MessageScrollCode>
@@ -12,6 +13,7 @@ public:
 		, inListMode(inListMode)
 	{
 		setIsLogged(false);
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_SCROLL_GRAPH_H
 
 #include "Message.h"
+#include "TabId.h"
 
 class MessageScrollGraph
 	: public Message<MessageScrollGraph>
@@ -12,6 +13,7 @@ public:
 		, yValue(yValue)
 	{
 		setIsLogged(false);
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -3,6 +3,7 @@
 
 #include "FilePath.h"
 #include "Message.h"
+#include "TabId.h"
 
 class MessageScrollToLine
 	: public Message<MessageScrollToLine>
@@ -12,6 +13,7 @@ public:
 		: filePath(filePath)
 		, line(line)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -5,6 +5,7 @@
 
 #include "NodeTypeSet.h"
 #include "SearchMatch.h"
+#include "TabId.h"
 
 class MessageSearch
 	: public Message<MessageSearch>
@@ -19,6 +20,7 @@ public:
 		: acceptedNodeTypes(acceptedNodeTypes)
 		, m_matches(matches)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	const std::vector<SearchMatch>& getMatches() const

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

@@ -4,6 +4,7 @@
 #include "Node.h"
 #include "NodeTypeSet.h"
 #include "Message.h"
+#include "TabId.h"
 
 class MessageSearchAutocomplete
 	: public Message<MessageSearchAutocomplete>
@@ -13,6 +14,7 @@ public:
 		: query(query)
 		, acceptedNodeTypes(acceptedNodeTypes)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -2,6 +2,7 @@
 #define MESSAGE_SHOW_REFERENCE_H
 
 #include "Message.h"
+#include "TabId.h"
 #include "types.h"
 
 class MessageShowReference
@@ -14,6 +15,7 @@ public:
 		, locationId(locationId)
 		, fromUser(fromUser)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

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

@@ -3,6 +3,7 @@
 
 #include "Message.h"
 #include "types.h"
+#include "TabId.h"
 
 class MessageShowScope
 	: public Message<MessageShowScope>
@@ -12,6 +13,7 @@ public:
 		: scopeLocationId(scopeLocationId)
 		, showErrors(showErrors)
 	{
+		setSchedulerId(TabId::currentTab());
 	}
 
 	static const std::string getStaticType()

src/lib/utility/messaging/type/activation/MessageActivateLegend.h

@@ -3,12 +3,18 @@
 
 #include "Message.h"
 #include "MessageActivateBase.h"
+#include "TabId.h"
 
 class MessageActivateLegend
 	: public Message<MessageActivateLegend>
 	, public MessageActivateBase
 {
 public:
+	MessageActivateLegend()
+	{
+		setSchedulerId(TabId::currentTab());
+	}
+
 	static const std::string getStaticType()
 	{
 		return "MessageActivateLegend";

src/lib/utility/messaging/type/bookmark/MessageBookmarkActivate.h

@@ -0,0 +1,24 @@
+#ifndef MESSAGE_BOOKMARK_ACTIVATE_H
+#define MESSAGE_BOOKMARK_ACTIVATE_H
+
+#include "Bookmark.h"
+#include "Message.h"
+
+class MessageBookmarkActivate
+	: public Message<MessageBookmarkActivate>
+{
+public:
+	MessageBookmarkActivate(const std::shared_ptr<Bookmark>& bookmark)
+		: bookmark(bookmark)
+	{
+	}
+
+	static const std::string getStaticType()
+	{
+		return "MessageBookmarkActivate";
+	}
+
+	const std::shared_ptr<Bookmark> bookmark;
+};
+
+#endif // MESSAGE_BOOKMARK_ACTIVATE_H