logic: Moved all error handling logic into ErrorController (issue #577)

* Handle all error related messages in ErrorController
* Moved error filter state from Storage to ErrorController
* Moved all error related messages to type/error subdirectory
* Enable all errors shown by default
* Always show unfiltered error count in status bar and overview
* Fixed all errors shown again when changing error filter on errors for file

src/lib/component/controller/ErrorController.cpp

@@ -12,51 +12,109 @@ ErrorController::~ErrorController()
 {
 }
 
-void ErrorController::handleMessage(MessageClearErrorCount* message)
+void ErrorController::errorFilterChanged(const ErrorFilter& filter)
+{
+	if (m_activeFilePath.empty())
+	{
+		MessageActivateErrors(filter).dispatch();
+	}
+	else
+	{
+		MessageActivateErrors(filter, m_activeFilePath).dispatch();
+	}
+}
+
+void ErrorController::showError(Id errorId)
+{
+	if (!m_showsErrors)
+	{
+		errorFilterChanged(getView()->getErrorFilter());
+	}
+
+	MessageShowError(errorId).dispatch();
+}
+
+void ErrorController::handleMessage(MessageActivateAll* message)
+{
+	m_showsErrors = false;
+}
+
+void ErrorController::handleMessage(MessageActivateErrors* message)
 {
 	clear();
 
-	getView()->resetErrorLimit();
+	m_showsErrors = true;
+	m_activeFilePath = message->file;
+
+	ErrorView* view = getView();
+	view->setErrorFilter(message->filter);
+
+	if (showErrors(message->filter, true))
+	{
+		view->showDockWidget();
+	}
 }
 
-void ErrorController::handleMessage(MessageFinishedParsing* message)
+void ErrorController::handleMessage(MessageActivateTokens* message)
+{
+	m_showsErrors = false;
+}
+
+void ErrorController::handleMessage(MessageErrorCountClear* message)
 {
 	clear();
 
-	getView()->setErrorCount(m_storageAccess->getErrorCount());
-	getView()->addErrors(m_storageAccess->getErrorsLimited({ }), false);
+	ErrorView* view = getView();
+
+	ErrorFilter filter = view->getErrorFilter();
+	filter.limit = ErrorFilter().limit;
+	view->setErrorFilter(filter);
 }
 
-void ErrorController::handleMessage(MessageNewErrors* message)
+void ErrorController::handleMessage(MessageErrorCountUpdate* message)
 {
-	ErrorFilter filter;
-	int room = message->errors.size() + filter.limit - message->errorCount.total;
+	ErrorFilter filter = getView()->getErrorFilter();
+
+	int room = filter.limit - m_errorCount;
 	if (room > 0)
 	{
-		std::vector<ErrorInfo> errors = message->errors;
-		if (room < int(errors.size()))
-		{
-			errors.resize(room);
-		}
+		filter.limit = 0;
+		std::vector<ErrorInfo> errors = m_storageAccess->getErrorsLimited(filter);
+		ErrorCountInfo errorCount(errors);
 
-		getView()->addErrors(message->errors, true);
+		auto startIt = errors.begin() + m_errorCount;
+		errors = std::vector<ErrorInfo>(
+			startIt,
+			(errors.size() < m_errorCount + room) ? errors.end() : startIt + room
+		);
+
+		getView()->addErrors(errors, errorCount, true);
 		getView()->showDockWidget();
+
+		m_errorCount += errors.size();
 	}
-
-	getView()->setErrorCount(message->errorCount);
-
 }
 
-void ErrorController::handleMessage(MessageShowErrorHelpMessage* message)
+void ErrorController::handleMessage(MessageErrorsAll* message)
+{
+	MessageActivateErrors(getView()->getErrorFilter()).dispatch();
+}
+
+void ErrorController::handleMessage(MessageErrorsForFile* message)
+{
+	MessageActivateErrors(ErrorFilter(), message->file).dispatch();
+}
+
+void ErrorController::handleMessage(MessageErrorsHelpMessage* message)
 {
 	ApplicationSettings* appSettings = ApplicationSettings::getInstance().get();
-	if (!message->force && appSettings->getSeenErrorHelpMessage())
-	{
-		return;
-	}
-
 	if (!message->force)
 	{
+		if (appSettings->getSeenErrorHelpMessage())
+		{
+			return;
+		}
+
 		ErrorCountInfo info = m_storageAccess->getErrorCount();
 		if (!info.total)
 		{
@@ -70,29 +128,21 @@ void ErrorController::handleMessage(MessageShowErrorHelpMessage* message)
 	getView()->showErrorHelpMessage();
 }
 
-void ErrorController::handleMessage(MessageShowErrors* message)
+void ErrorController::handleMessage(MessageFinishedParsing* message)
 {
-	if (message->errorId)
-	{
-		getView()->setErrorId(message->errorId);
-		return;
-	}
-
 	clear();
 
-	std::vector<ErrorInfo> errors;
-	if (!message->showsOnlyErrorIds || message->errorIds.size())
-	{
-		errors = m_storageAccess->getErrorsLimited(message->errorIds);
-	}
+	showErrors(getView()->getErrorFilter(), false);
+}
 
-	if (errors.size())
-	{
-		getView()->showDockWidget();
-	}
+void ErrorController::handleMessage(MessageShowError* message)
+{
+	getView()->setErrorId(message->errorId);
+}
 
-	getView()->setErrorCount(message->errorCount);
-	getView()->addErrors(errors, false);
+void ErrorController::handleMessage(MessageSearchFullText* message)
+{
+	m_showsErrors = false;
 }
 
 ErrorView* ErrorController::getView() const
@@ -102,5 +152,37 @@ ErrorView* ErrorController::getView() const
 
 void ErrorController::clear()
 {
+	m_showsErrors = false;
+	m_errorCount = 0;
+	m_activeFilePath = FilePath();
+
 	getView()->clear();
 }
+
+bool ErrorController::showErrors(const ErrorFilter& filter, bool scrollTo)
+{
+	ErrorView* view = getView();
+
+	ErrorFilter filterUnlimited = filter;
+	filterUnlimited.limit = 0;
+
+	std::vector<ErrorInfo> errors;
+	if (m_activeFilePath.empty())
+	{
+		errors = m_storageAccess->getErrorsLimited(filterUnlimited);
+	}
+	else
+	{
+		errors = m_storageAccess->getErrorsForFileLimited(filter, m_activeFilePath);
+	}
+
+	ErrorCountInfo errorCount(errors);
+	if (filter.limit > 0 && errors.size() > filter.limit)
+	{
+		errors.resize(filter.limit);
+	}
+
+	view->addErrors(errors, errorCount, scrollTo);
+
+	return errors.size();
+}