ui: statusview

* statusview as tab

src/lib/CMakeLists.txt

@@ -35,6 +35,8 @@ add_files(
 	component/controller/SearchController.h
 	component/controller/StatusBarController.cpp
 	component/controller/StatusBarController.h
+	component/controller/StatusController.cpp
+	component/controller/StatusController.h
 	component/controller/UndoRedoController.cpp
 	component/controller/UndoRedoController.h
 
@@ -63,6 +65,8 @@ add_files(
 	component/view/SearchView.h
 	component/view/StatusBarView.cpp
 	component/view/StatusBarView.h
+	component/view/StatusView.cpp
+	component/view/StatusView.h
 	component/view/TabbedView.cpp
 	component/view/TabbedView.h
 	component/view/UndoRedoView.cpp
@@ -256,6 +260,7 @@ add_files(
 	utility/messaging/type/MessageChangeFileView.h
 	utility/messaging/type/MessageClearErrorCount.h
 	utility/messaging/type/MessageClearLogView.h
+	utility/messaging/type/MessageClearStatusView.h
 	utility/messaging/type/MessageCodeReference.h
 	utility/messaging/type/MessageColorSchemeTest.h
 	utility/messaging/type/MessageDeactivateEdge.h
@@ -274,6 +279,7 @@ add_files(
 	utility/messaging/type/MessageIDECreateCDB.h
 	utility/messaging/type/MessageInterruptTasks.h
 	utility/messaging/type/MessageLoadProject.h
+	utility/messaging/type/MessageLogFilterChanged.h
 	utility/messaging/type/MessageMoveIDECursor.h
 	utility/messaging/type/MessageNewErrors.h
 	utility/messaging/type/MessagePingReceived.h
@@ -293,6 +299,7 @@ add_files(
 	utility/messaging/type/MessageShowScope.h
 	utility/messaging/type/MessageShowStartScreen.h
 	utility/messaging/type/MessageStatus.h
+	utility/messaging/type/MessageStatusFilterChanged.h
 	utility/messaging/type/MessageSwitchColorScheme.h
 	utility/messaging/type/MessageUndo.h
 	utility/messaging/type/MessageWindowClosed.h

src/lib/component/ComponentFactory.cpp

@@ -9,6 +9,7 @@
 #include "component/controller/RefreshController.h"
 #include "component/controller/SearchController.h"
 #include "component/controller/StatusBarController.h"
+#include "component/controller/StatusController.h"
 #include "component/controller/UndoRedoController.h"
 #include "component/view/CodeView.h"
 #include "component/view/ErrorView.h"
@@ -17,6 +18,7 @@
 #include "component/view/RefreshView.h"
 #include "component/view/SearchView.h"
 #include "component/view/StatusBarView.h"
+#include "component/view/StatusView.h"
 #include "component/view/UndoRedoView.h"
 #include "component/view/ViewFactory.h"
 
@@ -119,6 +121,14 @@ std::shared_ptr<Component> ComponentFactory::createStatusBarComponent(ViewLayout
 	return std::make_shared<Component>(view, controller);
 }
 
+std::shared_ptr<Component> ComponentFactory::createStatusComponent(ViewLayout* viewLayout)
+{
+	std::shared_ptr<StatusView> view = m_viewFactory->createStatusView(viewLayout);
+	std::shared_ptr<StatusController> controller = std::make_shared<StatusController>();
+
+	return std::make_shared<Component>(view, controller);
+}
+
 ComponentFactory::ComponentFactory()
 {
 }

src/lib/component/ComponentFactory.h

@@ -27,6 +27,7 @@ public:
 	std::shared_ptr<Component> createRefreshComponent(ViewLayout* viewLayout);
 	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> createUndoRedoComponent(ViewLayout* viewLayout);
 
 private:

src/lib/component/ComponentManager.cpp

@@ -63,8 +63,12 @@ void ComponentManager::setup(ViewLayout* viewLayout)
 	// std::shared_ptr<Component> logComponent = m_componentFactory->createLogComponent(tabbedView.get());
 	// m_components.push_back(logComponent);
 
+	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());
 	m_components.push_back(errorComponent);
+
 }
 
 void ComponentManager::clearComponents()

src/lib/component/controller/StatusController.cpp

@@ -0,0 +1,110 @@
+#include "component/controller/StatusController.h"
+
+#include "data/access/StorageAccess.h"
+#include "utility/logging/LogManager.h"
+#include "settings/ApplicationSettings.h"
+#include "component/view/StatusView.h"
+
+StatusController::StatusController()
+	: m_enabled(false)
+	, m_lastSyncedStatus(0)
+	, m_waiting(false)
+{
+}
+
+StatusController::~StatusController()
+{
+}
+
+void StatusController::setEnabled(bool enabled)
+{
+	m_enabled = enabled;
+}
+
+bool StatusController::getEnabled() const
+{
+	return m_enabled;
+}
+
+StatusView* StatusController::getView() const
+{
+	return Controller::getView<StatusView>();
+}
+
+void StatusController::clear()
+{
+	std::lock_guard<std::mutex> lock(m_statusMutex);
+	m_status.clear();
+	clearTable();
+	m_lastSyncedStatus = 0;
+}
+
+
+void StatusController::handleMessage(MessageStatus* message)
+{
+	std::lock_guard<std::mutex> lock(m_statusMutex);
+	m_status.push_back(Status(message->status, message->isError));
+
+	if (!m_waiting)
+	{
+		m_waiting = true;
+		std::thread([&]()
+			{
+				std::this_thread::sleep_for(std::chrono::milliseconds(200));
+				syncStatus();
+				m_waiting = false;
+			}
+		).detach();
+	}
+}
+
+void StatusController::handleMessage(MessageStatusFilterChanged* message)
+{
+	m_statusFilter = message->statusFilter;
+	ApplicationSettings* settings = ApplicationSettings::getInstance().get();
+	settings->setStatusFilter(m_statusFilter);
+	settings->save();
+	clearTable();
+	std::cout << "handlefilterchange" << std::endl;
+	syncStatus();
+}
+
+void StatusController::clearTable()
+{
+	getView()->clear();
+}
+
+void StatusController::handleMessage(MessageClearStatusView* message)
+{
+	clear();
+}
+
+void StatusController::syncStatus()
+{
+	std::lock_guard<std::mutex> lock(m_statusMutex);
+
+	std::vector<Status> status;
+
+	for (size_t i = m_lastSyncedStatus; i < m_status.size(); i++)
+	{
+		if ((m_status[i].isError && (STATUSTYPE::STATUS_ERROR & m_statusFilter))
+			|| (!m_status[i].isError && (STATUSTYPE::STATUS_INFO & m_statusFilter)))
+		{
+			status.push_back(m_status[i]);
+		}
+		m_lastSyncedStatus = i;
+	}
+	m_lastSyncedStatus++;
+
+	//for (Status  s : m_status)
+	//{
+		//if ((s.isError && (STATUSTYPE::STATUS_ERROR & m_statusFilter))
+			//|| (!s.isError && (STATUSTYPE::STATUS_INFO & m_statusFilter)))
+		//{
+			//status.push_back(s);
+		//}
+	//}
+
+	getView()->addStatus(status);
+}
+

src/lib/component/controller/StatusController.h

@@ -0,0 +1,57 @@
+#ifndef STATUS_CONTROLLER_H
+#define STATUS_CONTROLLER_H
+
+#include <mutex>
+
+#include "component/controller/Controller.h"
+
+#include "utility/logging/Logger.h"
+#include "utility/logging/LogMessage.h"
+#include "utility/messaging/MessageListener.h"
+#include "utility/messaging/type/MessageClearStatusView.h"
+#include "utility/messaging/type/MessageStatusFilterChanged.h"
+#include "utility/messaging/type/MessageStatus.h"
+#include "utility/Status.h"
+
+class StatusView;
+class StorageAccess;
+
+class StatusController
+	: public Controller
+	, public MessageListener<MessageClearStatusView>
+	, public MessageListener<MessageStatusFilterChanged>
+	, public MessageListener<MessageStatus>
+{
+public:
+	StatusController();
+	~StatusController();
+
+	void setEnabled(bool enabled);
+	bool getEnabled() const;
+
+private:
+	bool m_enabled;
+	StatusView* getView() const;
+
+	virtual void clear();
+
+	virtual void handleMessage(MessageClearStatusView* message);
+	virtual void handleMessage(MessageStatusFilterChanged* message);
+	virtual void handleMessage(MessageStatus* message);
+
+
+	void addStatus(Logger::LogLevel type, const LogMessage& message);
+	void syncStatus();
+	void clearTable();
+
+
+	std::vector<Status> m_status;
+	size_t m_lastSyncedStatus;
+	StatusFilter m_statusFilter;
+
+	std::mutex m_statusMutex;
+	bool m_waiting;
+
+};
+
+#endif // STATUS_CONTROLLER_H

src/lib/component/view/StatusView.cpp

@@ -0,0 +1,16 @@
+#include "component/view/StatusView.h"
+
+StatusView::StatusView(ViewLayout* viewLayout)
+	: View(viewLayout)
+{
+}
+
+StatusView::~StatusView()
+{
+}
+
+std::string StatusView::getName() const
+{
+	return "Status";
+}
+

src/lib/component/view/StatusView.h

@@ -0,0 +1,28 @@
+#ifndef STATUS_VIEW_H
+#define STATUS_VIEW_H
+
+#include "component/view/View.h"
+
+#include "utility/Status.h"
+#include "utility/logging/LogMessage.h"
+#include "utility/logging/Logger.h"
+
+
+class StatusView
+	: public View
+{
+public:
+	StatusView(ViewLayout* viewLayout);
+	virtual ~StatusView();
+
+
+	virtual std::string getName() const;
+	virtual void addStatus(const std::vector<Status>& status) = 0;
+	virtual void clear() = 0;
+	//virtual bool hasLogLevel(const Logger::LogLevel type, const Logger::LogLevelMask mask) const;
+	//virtual void addLog(Logger::LogLevel type, const LogMessage& message) = 0;
+	//virtual void addLogs(const std::vector<Log>& logs) = 0;
+	//static const int LogLimit;
+};
+
+#endif // STATUS_VIEW_H

src/lib/component/view/ViewFactory.h

@@ -14,6 +14,7 @@ class LogView;
 class RefreshView;
 class SearchView;
 class StatusBarView;
+class StatusView;
 class StorageAccess;
 class TabbedView;
 class UndoRedoView;
@@ -37,6 +38,7 @@ public:
 	virtual std::shared_ptr<RefreshView> createRefreshView(ViewLayout* viewLayout) const = 0;
 	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<UndoRedoView> createUndoRedoView(ViewLayout* viewLayout) const = 0;
 
 	virtual std::shared_ptr<DialogView> createDialogView(ViewLayout* viewLayout, StorageAccess* storageAccess) const = 0;

src/lib/settings/ApplicationSettings.cpp

@@ -1,6 +1,7 @@
 #include "settings/ApplicationSettings.h"
 
 #include "utility/ResourcePaths.h"
+#include "utility/Status.h"
 #include "utility/utility.h"
 
 const size_t ApplicationSettings::VERSION = 1;
@@ -180,6 +181,16 @@ void ApplicationSettings::setLogFilter(int mask)
 	setValue<int>("application/log_filter", mask);
 }
 
+void ApplicationSettings::setStatusFilter(int mask)
+{
+	setValue<int>("application/status_filter", mask);
+}
+
+int ApplicationSettings::getStatusFilter() const
+{
+	return getValue<int>("application/status_filter", STATUSTYPE::STATUS_INFO | STATUSTYPE::STATUS_ERROR);
+}
+
 int ApplicationSettings::getLogFilter() const
 {
 	return getValue<int>("application/log_filter", Logger::LOG_WARNINGS | Logger::LOG_ERRORS);

src/lib/settings/ApplicationSettings.h

@@ -57,6 +57,9 @@ public:
 	int getLogFilter() const;
 	void setLogFilter(int mask);
 
+	int getStatusFilter() const;
+	void setStatusFilter(int mask);
+
 	std::vector<FilePath> getIndexingFilePaths() const;
 	bool setIndexingFilePaths(const std::vector<FilePath>& indexingFiles);
 

src/lib/utility/Status.h

@@ -0,0 +1,24 @@
+#ifndef STATUS_H
+#define STATUS_H
+
+#include <string>
+
+struct Status
+{
+	Status(std::string message, bool isError = false)
+		: message(message)
+		, isError(isError){};
+
+	std::string message;
+	bool isError;
+};
+
+enum STATUSTYPE
+{
+	STATUS_INFO = 1,
+	STATUS_ERROR = 2,
+};
+
+typedef int StatusFilter;
+
+#endif //STATUS_H

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

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

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

@@ -0,0 +1,25 @@
+#ifndef MESSAGE_STATUS_FILTER_CHANGED_H
+#define MESSAGE_STATUS_FILTER_CHANGED_H
+
+#include "utility/messaging/Message.h"
+#include "utility/logging/Logger.h"
+#include "utility/Status.h"
+
+class MessageStatusFilterChanged
+	: public Message<MessageStatusFilterChanged>
+{
+public:
+	MessageStatusFilterChanged(const StatusFilter filter)
+		: statusFilter(filter)
+	{
+	}
+
+	static const std::string getStaticType()
+	{
+		return "MessageStatusFilterChanged";
+	}
+
+	const StatusFilter statusFilter;
+};
+
+#endif // MESSAGE_STATUS_FILTER_CHANGED_H

src/lib_gui/CMakeLists.txt

@@ -115,6 +115,8 @@ add_files(
 	qt/view/QtSearchView.h
 	qt/view/QtStatusBarView.cpp
 	qt/view/QtStatusBarView.h
+	qt/view/QtStatusView.cpp
+	qt/view/QtStatusView.h
 	qt/view/QtTabbedView.cpp
 	qt/view/QtTabbedView.h
 	qt/view/QtUndoRedoView.cpp

src/lib_gui/qt/view/QtStatusView.cpp

@@ -0,0 +1,214 @@
+#include "qt/view/QtStatusView.h"
+
+#include <QBoxLayout>
+#include <QFrame>
+#include <QLabel>
+#include <QCheckBox>
+#include <QPushButton>
+#include <QStandardItemModel>
+
+#include "settings/ApplicationSettings.h"
+#include "settings/ColorScheme.h"
+#include "qt/view/QtViewWidgetWrapper.h"
+#include "utility/messaging/type/MessageClearStatusView.h"
+#include "utility/messaging/type/MessageRefresh.h"
+#include "utility/messaging/type/MessageStatusFilterChanged.h"
+#include "utility/ResourcePaths.h"
+#include "qt/utility/utilityQt.h"
+#include "qt/element/QtTable.h"
+
+QtStatusView::QtStatusView(ViewLayout* viewLayout)
+	: StatusView(viewLayout)
+	, m_addStatusFunctor(std::bind(&QtStatusView::doAddStatus, this, std::placeholders::_1))
+	, m_clearFunctor(std::bind(&QtStatusView::doClear, this))
+	, m_refreshFunctor(std::bind(&QtStatusView::doRefreshView, this))
+{
+}
+
+QtStatusView::~QtStatusView()
+{
+}
+
+void QtStatusView::createWidgetWrapper()
+{
+	setWidgetWrapper(std::make_shared<QtViewWidgetWrapper>(new QFrame()));
+}
+
+void QtStatusView::initView()
+{
+	QWidget* widget = QtViewWidgetWrapper::getWidgetOfView(this);
+
+	QBoxLayout* layout = new QBoxLayout(QBoxLayout::TopToBottom);
+	layout->setContentsMargins(0, 10, 0, 5);
+	layout->setSpacing(0);
+	widget->setLayout(layout);
+
+	QHBoxLayout* headerLayout = new QHBoxLayout();
+	headerLayout->addSpacing(10);
+
+	ApplicationSettings* settings = ApplicationSettings::getInstance().get();
+
+	m_table = new QtTable(this);
+	m_model = new QStandardItemModel(this);
+	m_table->setModel(m_model);
+
+	m_model->setColumnCount(2);
+	m_table->setColumnWidth(STATUSVIEW_COLUMN::TYPE, 100);
+	//m_table->setColumnWidth(STATUSVIEW_COLUMN::STATUS, 150);
+
+	QStringList headers;
+	headers << "Type" << "Status";
+	m_model->setHorizontalHeaderLabels(headers);
+
+	layout->addWidget(m_table);
+
+	QHBoxLayout* filters = new QHBoxLayout();
+	filters->addSpacing(15);
+
+	const StatusFilter filter = settings->getStatusFilter();
+
+	m_showErrors = createFilterCheckbox("error", filters, filter & STATUSTYPE::STATUS_ERROR);
+	m_showInfo = createFilterCheckbox("info", filters, filter & STATUSTYPE::STATUS_ERROR);
+
+	filters->addStretch();
+
+	QPushButton* clearButton = new QPushButton("clear");
+	connect(clearButton, &QPushButton::clicked,
+		[=]()
+		{
+			//doClear();
+			MessageClearStatusView().dispatch();
+		});
+	filters->addWidget(clearButton);
+	filters->addSpacing(30);
+
+	updateMask();
+
+	layout->addLayout(filters);
+
+	doRefreshView();
+}
+
+QCheckBox* QtStatusView::createFilterCheckbox(const QString& name, QBoxLayout* layout, bool checked)
+{
+	QCheckBox* checkbox = new QCheckBox(name);
+	checkbox->setChecked(checked);
+
+	connect(checkbox, &QCheckBox::stateChanged,
+		[=](int)
+		{
+			m_table->selectionModel()->clearSelection();
+			updateMask();
+			updateTable();
+		}
+	);
+
+	layout->addWidget(checkbox);
+	layout->addSpacing(25);
+
+	return checkbox;
+}
+
+void QtStatusView::refreshView()
+{
+	m_refreshFunctor();
+}
+
+void QtStatusView::clear()
+{
+	m_clearFunctor();
+}
+
+void QtStatusView::addStatus(const std::vector<Status>& status)
+{
+	m_addStatusFunctor(status);
+}
+
+void QtStatusView::doClear()
+{
+	if (!m_model->index(0, 0).data(Qt::DisplayRole).toString().isEmpty())
+	{
+		m_model->removeRows(0, m_model->rowCount());
+	}
+
+	m_status.clear();
+}
+
+void QtStatusView::doRefreshView()
+{
+	setStyleSheet();
+}
+
+void QtStatusView::setStyleSheet() const
+{
+	QWidget* widget = QtViewWidgetWrapper::getWidgetOfView(this);
+	utility::setWidgetBackgroundColor(widget, ColorScheme::getInstance()->getColor("error/background"));
+
+	QPalette palette(m_showErrors->palette());
+	palette.setColor(QPalette::WindowText, QColor(ColorScheme::getInstance()->getColor("error/text/normal").c_str()));
+	//palette.setColor(QPalette::Text, QColor(ColorScheme::getInstance()->getColor("error/text/normal").c_str()));
+	//palette.setColor(QPalette::ButtonText, QColor(ColorScheme::getInstance()->getColor("error/text/normal").c_str()));
+
+	//m_showErrors->setAutoFillBackground(true);
+	//m_showErrors->setPalette(palette);
+	//m_showFatals->setPalette(palette);
+	//m_showNonIndexedErrors->setPalette(palette);
+	//m_showNonIndexedFatals->setPalette(palette);
+
+	widget->setStyleSheet(
+		utility::getStyleSheet(ResourcePaths::getGuiPath() + "error_view/error_view.css").c_str()
+	);
+
+	m_table->updateRows();
+}
+
+const char* QtStatusView::getStatusTypeAsString(STATUSTYPE type) const
+{
+	switch (type)
+	{
+		case STATUSTYPE::STATUS_INFO:
+			return "INFO";
+		case STATUSTYPE::STATUS_ERROR:
+			return "ERROR";
+	}
+}
+
+void QtStatusView::updateTable()
+{
+	if (!m_model->index(0, 0).data(Qt::DisplayRole).toString().isEmpty())
+	{
+		m_model->removeRows(0, m_model->rowCount());
+	}
+}
+
+void QtStatusView::updateMask()
+{
+	const StatusFilter statusMask =
+		(m_showInfo->isChecked() ? STATUSTYPE::STATUS_INFO : 0) +
+		(m_showErrors->isChecked() ? STATUSTYPE::STATUS_ERROR : 0);
+
+	MessageStatusFilterChanged(statusMask).dispatch();
+}
+
+void QtStatusView::addStatusToTable(Status status)
+{
+	const int rowNumber = m_table->getFilledRowCount();
+	if (rowNumber < m_model->rowCount())
+	{
+		m_model->insertRow(rowNumber);
+	}
+
+	m_model->setItem(rowNumber, STATUSVIEW_COLUMN::TYPE, new QStandardItem(status.isError ? "ERROR" : "INFO"));
+	m_model->setItem(rowNumber, STATUSVIEW_COLUMN::STATUS, new QStandardItem(status.message.c_str()));
+	m_table->updateRows();
+}
+
+void QtStatusView::doAddStatus(const std::vector<Status>& status)
+{
+	//doClear();
+	for(Status s : status)
+	{
+		addStatusToTable(s);
+	}
+
+}

src/lib_gui/qt/view/QtStatusView.h

@@ -0,0 +1,66 @@
+#ifndef QT_STATUS_VIEW_H
+#define QT_STATUS_VIEW_H
+
+#include <QWidget>
+
+#include "component/view/StatusView.h"
+#include "qt/utility/QtThreadedFunctor.h"
+#include "utility/logging/Logger.h"
+
+class QBoxLayout;
+class QCheckBox;
+class QPalette;
+class QStandardItemModel;
+class QtTable;
+
+class QtStatusView
+	: public StatusView
+	, public QWidget
+{
+public:
+	QtStatusView(ViewLayout* viewLayout);
+	virtual ~QtStatusView();
+
+	// View implementation
+	virtual void createWidgetWrapper();
+	virtual void initView();
+	virtual void refreshView();
+
+	// Status View Implementation
+	virtual void clear();
+	virtual void addStatus(const std::vector<Status>& status);
+
+private:
+	enum STATUSVIEW_COLUMN
+	{
+		TYPE = 0,
+		STATUS = 1,
+	};
+
+	void doClear();
+	void doRefreshView();
+	void doAddStatus(const std::vector<Status>& status);
+
+	std::vector<Status> m_status;
+	const char* getStatusTypeAsString(STATUSTYPE type) const;
+	void addStatusToTable(Status status);
+
+	QCheckBox* createFilterCheckbox(const QString& name, QBoxLayout* layout, bool checked = false);
+
+	void setStyleSheet() const;
+
+	void updateMask();
+	void updateTable();
+
+	QtTable* m_table;
+	QStandardItemModel* m_model;
+
+	QCheckBox* m_showErrors;
+	QCheckBox* m_showInfo;
+
+	QtThreadedFunctor<const std::vector<Status>&> m_addStatusFunctor;
+	QtThreadedFunctor<void> m_clearFunctor;
+	QtThreadedFunctor<void> m_refreshFunctor;
+};
+
+#endif // QT_STATUS_VIEW_H

src/lib_gui/qt/view/QtViewFactory.cpp

@@ -12,6 +12,7 @@
 #include "qt/view/QtRefreshView.h"
 #include "qt/view/QtSearchView.h"
 #include "qt/view/QtStatusBarView.h"
+#include "qt/view/QtStatusView.h"
 #include "qt/view/QtTabbedView.h"
 #include "qt/view/QtUndoRedoView.h"
 
@@ -60,6 +61,11 @@ std::shared_ptr<LogView> QtViewFactory::createLogView(ViewLayout* viewLayout) co
 	return View::createInitAndAddToLayout<QtLogView>(viewLayout);
 }
 
+std::shared_ptr<StatusView> QtViewFactory::createStatusView(ViewLayout* viewLayout) const
+{
+	return View::createInitAndAddToLayout<QtStatusView>(viewLayout);
+}
+
 std::shared_ptr<GraphView> QtViewFactory::createGraphView(ViewLayout* viewLayout) const
 {
 	GraphViewStyle::setImpl(std::make_shared<QtGraphViewStyleImpl>());

src/lib_gui/qt/view/QtViewFactory.h

@@ -21,6 +21,7 @@ public:
 	virtual std::shared_ptr<RefreshView> createRefreshView(ViewLayout* viewLayout) const;
 	virtual std::shared_ptr<SearchView> createSearchView(ViewLayout* viewLayout) const;
 	virtual std::shared_ptr<StatusBarView> createStatusBarView(ViewLayout* viewLayout) const;
+	virtual std::shared_ptr<StatusView> createStatusView(ViewLayout* viewLayout) const;
 	virtual std::shared_ptr<UndoRedoView> createUndoRedoView(ViewLayout* viewLayout) const;
 
 	virtual std::shared_ptr<DialogView> createDialogView(ViewLayout* viewLayout, StorageAccess* storageAccess) const;