Fix log levels for STM32 conflict

peteGSX · peteGSX · commit 6b7aa39c6ed7 · 2025-01-03T07:25:20.000+10:00
diff --git a/AtFinder.cpp b/AtFinder.cpp
@@ -50,7 +50,7 @@ void AtFinder::setup(uint8_t maxTextLength, CallbackInterface *callback) {
   _maxTextLength = maxTextLength;
   _text = (char *)malloc(_maxTextLength + 1);
   _callback = callback;
-  LOG(LogLevel::DEBUG, "AtFinder::setup with _maxTextLength %d", _maxTextLength);
+  LOG(LogLevel::LOG_DEBUG, "AtFinder::setup with _maxTextLength %d", _maxTextLength);
 }
 
 void AtFinder::processInputChar(char hot) {
diff --git a/Configurator.cpp b/Configurator.cpp
@@ -50,7 +50,7 @@ void Configurator::initialise() {
     if (display != nullptr) {
       _inputManager->setDisplay(display);
     } else {
-      LOG(LogLevel::ERROR, "Could not get display ID %d required by the input, user input not available", displayId);
+      LOG(LogLevel::LOG_ERROR, "Could not get display ID %d required by the input, user input not available", displayId);
     }
   }
 }
diff --git a/Configurator.h b/Configurator.h
@@ -31,7 +31,7 @@ class Configurator {
   /// @param consoleStream Pointer to the Stream for console interaction
   /// @param commandStationStream Pointer to the Stream for the CommandStation connection
   /// @param logLevel LogLevel to set (default WARN)
-  Configurator(Stream *consoleStream, Stream *commandStationStream, LogLevel logLevel = LogLevel::WARN);
+  Configurator(Stream *consoleStream, Stream *commandStationStream, LogLevel logLevel = LogLevel::LOG_WARN);
 
   /// @brief Call all one-shot initialisation or begin methods on startup
   void initialise();
diff --git a/Controller.cpp b/Controller.cpp
@@ -35,7 +35,7 @@ Controller::Controller(Stream *consoleStream, Stream *commandStationStream, Disp
 void Controller::begin() {
   _displayManager->startDisplays(); // Start displays
   _inputManager->startInput();      // Start input
-  LOG(LogLevel::MESSAGE, "EX-Display version %s", VERSION);
+  LOG(LogLevel::LOG_MESSAGE, "EX-Display version %s", VERSION);
   _displayManager->displayStartupInfo(VERSION); // Display version info
 }
 
@@ -54,7 +54,7 @@ void Controller::update() {
   // Configurator
   // When the time has passed, turn the pause of and clear each display to enable normal display operation
   if (_pauseDisplayUpdates && millis() > _pauseDisplayUpdatesUntil) {
-    LOG(LogLevel::DEBUG, "_pauseDisplayUpdatesUntil time exceeded, resume display updates");
+    LOG(LogLevel::LOG_DEBUG, "_pauseDisplayUpdatesUntil time exceeded, resume display updates");
     _pauseDisplayUpdatesUntil = 0;
     _pauseDisplayUpdates = false;
     _displayManager->clearAllDisplays();
@@ -79,9 +79,9 @@ void Controller::update() {
 }
 
 void Controller::updateScreen(uint8_t screenId, uint8_t row, const char *text) {
-  LOG(LogLevel::DEBUG, "Controller::updateScreen(%d, %d, %s)", screenId, row, text);
+  LOG(LogLevel::LOG_DEBUG, "Controller::updateScreen(%d, %d, %s)", screenId, row, text);
   if (_screenManager == nullptr) {
-    LOG(LogLevel::DEBUG, "Controller::_screenManager == nullptr");
+    LOG(LogLevel::LOG_DEBUG, "Controller::_screenManager == nullptr");
     return;
   }
   Screen *screen = _screenManager->updateScreen(screenId);
@@ -91,7 +91,7 @@ void Controller::updateScreen(uint8_t screenId, uint8_t row, const char *text) {
 }
 
 void Controller::onInputAction(InputAction action) {
-  LOG(LogLevel::DEBUG, "Controller::onInputAction(%d)", action);
+  LOG(LogLevel::LOG_DEBUG, "Controller::onInputAction(%d)", action);
   // No inputs are valid if there are no displays or screens, so just bail out
   if (_displayManager == nullptr || _screenManager == nullptr || _displayManager->getFirstDisplay() == nullptr ||
       _screenManager->getFirstScreen() == nullptr) {
@@ -101,33 +101,33 @@ void Controller::onInputAction(InputAction action) {
   switch (action) {
   // Left press selects the previous screen for display
   case InputAction::PRESS_LEFT: {
-    LOG(LogLevel::DEBUG, "Controller::onInputAction(InputAction::PRESS_LEFT)");
+    LOG(LogLevel::LOG_DEBUG, "Controller::onInputAction(InputAction::PRESS_LEFT)");
     _selectPreviousScreen(display);
     break;
   }
   // Right press selects the next screen for display
   case InputAction::PRESS_RIGHT: {
-    LOG(LogLevel::DEBUG, "Controller::onInputAction(InputAction::PRESS_RIGHT)");
+    LOG(LogLevel::LOG_DEBUG, "Controller::onInputAction(InputAction::PRESS_RIGHT)");
     _selectNextScreen(display);
     break;
   }
   // Up scrolls the screen up one row
   case InputAction::PRESS_UP: {
-    LOG(LogLevel::DEBUG, "Controller::onInputAction(InputAction::PRESS_UP)");
+    LOG(LogLevel::LOG_DEBUG, "Controller::onInputAction(InputAction::PRESS_UP)");
     break;
   }
   // Down scrolls the screen down one row
   case InputAction::PRESS_DOWN: {
-    LOG(LogLevel::DEBUG, "Controller::onInputAction(InputAction::PRESS_DOWN)");
+    LOG(LogLevel::LOG_DEBUG, "Controller::onInputAction(InputAction::PRESS_DOWN)");
     break;
   }
   // Centre moves input control to the next display - does nothing until multiple displays are supported
   case InputAction::PRESS_CENTRE: {
-    LOG(LogLevel::DEBUG, "Controller::onInputAction(InputAction::PRESS_CENTRE)");
+    LOG(LogLevel::LOG_DEBUG, "Controller::onInputAction(InputAction::PRESS_CENTRE)");
     break;
   }
   default: {
-    LOG(LogLevel::DEBUG, "Controller::onInputAction(Unknown)");
+    LOG(LogLevel::LOG_DEBUG, "Controller::onInputAction(Unknown)");
     break;
   }
   }
@@ -153,7 +153,7 @@ void Controller::_selectPreviousScreen(DisplayInterface *display) {
     previousId = _screenManager->getPreviousScreen(screen)->getId();
   }
   display->setScreenId(previousId);
-  LOG(LogLevel::DEBUG, "Controller::_selectPreviousScreen: _displayId=%d|screenId=%d|previousId=%d", display->getId(),
+  LOG(LogLevel::LOG_DEBUG, "Controller::_selectPreviousScreen: _displayId=%d|screenId=%d|previousId=%d", display->getId(),
       screenId, previousId);
 }
 
@@ -169,6 +169,6 @@ void Controller::_selectNextScreen(DisplayInterface *display) {
     nextId = _screenManager->getNextScreen(screen)->getId();
   }
   display->setScreenId(nextId);
-  LOG(LogLevel::DEBUG, "Controller::_selectNextScreen: _displayId=%d|screenId=%d|nextId=%d", display->getId(),
+  LOG(LogLevel::LOG_DEBUG, "Controller::_selectNextScreen: _displayId=%d|screenId=%d|nextId=%d", display->getId(),
       screenId, nextId);
 }
diff --git a/Defines.h b/Defines.h
@@ -20,11 +20,11 @@
 
 // Give log defines their values before user config
 #include "Logger.h"
-#define LOG_NONE LogLevel::NONE
-#define LOG_ERROR LogLevel::ERROR
-#define LOG_WARN LogLevel::WARN
-#define LOG_INFO LogLevel::INFO
-#define LOG_DEBUG LogLevel::DEBUG
+#define LOG_NONE LOG_NONE
+#define LOG_ERROR LOG_ERROR
+#define LOG_WARN LOG_WARN
+#define LOG_INFO LOG_INFO
+#define LOG_DEBUG LOG_DEBUG
 
 #ifndef PIO_UNIT_TESTING // Don't warn or use user config when testing
 // Incude user's myConfig.h if it exists.
diff --git a/DisplayManager.cpp b/DisplayManager.cpp
@@ -23,7 +23,7 @@
 DisplayManager::DisplayManager() : _firstDisplay(nullptr), _logger(nullptr), _nextDisplayId(0) {}
 
 void DisplayManager::addDisplay(DisplayInterface *display) {
-  LOG(LogLevel::DEBUG, "DisplayManager::addDisplay()");
+  LOG(LogLevel::LOG_DEBUG, "DisplayManager::addDisplay()");
   if (display == nullptr) {
     return;
   }
@@ -43,7 +43,7 @@ void DisplayManager::addDisplay(DisplayInterface *display) {
 }
 
 void DisplayManager::startDisplays() {
-  LOG(LogLevel::DEBUG, "DisplayManager::startDisplays()");
+  LOG(LogLevel::LOG_DEBUG, "DisplayManager::startDisplays()");
   if (_firstDisplay == nullptr) {
     return;
   }
@@ -54,7 +54,7 @@ void DisplayManager::startDisplays() {
 }
 
 void DisplayManager::clearAllDisplays() {
-  LOG(LogLevel::DEBUG, "DisplayManager::clearAllDisplays()");
+  LOG(LogLevel::LOG_DEBUG, "DisplayManager::clearAllDisplays()");
   if (_firstDisplay == nullptr) {
     return;
   }
@@ -66,7 +66,7 @@ void DisplayManager::clearAllDisplays() {
 }
 
 void DisplayManager::displayStartupInfo(const char *version) {
-  LOG(LogLevel::DEBUG, "DisplayManager::displayStartupInfo(%s)", version);
+  LOG(LogLevel::LOG_DEBUG, "DisplayManager::displayStartupInfo(%s)", version);
   // Do nothing if we don't have a DisplayManager or any displays
   if (_firstDisplay == nullptr) {
     return;
diff --git a/InputInterface.cpp b/InputInterface.cpp
@@ -30,7 +30,7 @@ void InputInterface::setDisplay(DisplayInterface *display) {
     return;
   }
   _display = display;
-  LOG(LogLevel::DEBUG, "DisplayInterface::setDisplay() - display ID %d", _display->getId());
+  LOG(LogLevel::LOG_DEBUG, "DisplayInterface::setDisplay() - display ID %d", _display->getId());
 }
 
 void InputInterface::setDebounceDelay(unsigned long delay) { _debounceDelay = delay; }
@@ -48,12 +48,12 @@ InputAction InputInterface::_debounceOrHeld(InputAction currentAction) {
     // If we're going from some action to none and not holding, then it must've been a press
     if ((currentTime - _lastDebounceTime) > _debounceDelay && currentAction == InputAction::PRESS_NONE && !_isHolding) {
       returnAction = _lastAction;
-      LOG(LogLevel::DEBUG, "InputInterface::_debounceOrHeld() - press detected: %d", returnAction);
+      LOG(LogLevel::LOG_DEBUG, "InputInterface::_debounceOrHeld() - press detected: %d", returnAction);
     }
     _lastDebounceTime = currentTime;
     _lastAction = currentAction;
     _isHolding = false;
-    LOG(LogLevel::DEBUG, "InputInterface::_debounceOrHeld() - action changed, resetting");
+    LOG(LogLevel::LOG_DEBUG, "InputInterface::_debounceOrHeld() - action changed, resetting");
     return returnAction;
   }
   // Check if the debounce time has been exceeded
@@ -63,7 +63,7 @@ InputAction InputInterface::_debounceOrHeld(InputAction currentAction) {
       if (!_isHolding) {
         // Flag that we're holding, and change from PRESS to HOLD
         _isHolding = true;
-        LOG(LogLevel::DEBUG, "InputInterface::_debounceOrHeld() - hold detected: %d", currentAction);
+        LOG(LogLevel::LOG_DEBUG, "InputInterface::_debounceOrHeld() - hold detected: %d", currentAction);
         switch (currentAction) {
         case InputAction::PRESS_UP:
           returnAction = InputAction::HOLD_UP;
@@ -91,7 +91,7 @@ InputAction InputInterface::_debounceOrHeld(InputAction currentAction) {
 }
 
 InputAction InputInterface::_calculateInputAction(int touchX, int touchY, int displayWidth, int displayHeight) {
-  LOG(LogLevel::DEBUG, "InputInterface::_calculateInputAction(%d, %d, %d, %d)", touchX, touchY, displayWidth,
+  LOG(LogLevel::LOG_DEBUG, "InputInterface::_calculateInputAction(%d, %d, %d, %d)", touchX, touchY, displayWidth,
       displayHeight);
   InputAction action = InputAction::PRESS_NONE;
   int thirdWidth = displayWidth / 3;
diff --git a/InputManager.cpp b/InputManager.cpp
@@ -25,17 +25,17 @@
 InputManager::InputManager() : _display(nullptr), _input(nullptr), _logger(nullptr), _callback(nullptr) {}
 
 void InputManager::addInput(InputInterface *input) {
-  LOG(LogLevel::DEBUG, "InputManager::addInput()");
+  LOG(LogLevel::LOG_DEBUG, "InputManager::addInput()");
   if (input == nullptr) {
-    LOG(LogLevel::ERROR, "InputInterface doesn't exist, user input will not be available");
+    LOG(LogLevel::LOG_ERROR, "InputInterface doesn't exist, user input will not be available");
     return;
   }
   _input = input;
   if (_logger) {
     _input->setLogger(_logger);
   }
   if (_callback == nullptr) {
-    LOG(LogLevel::ERROR, "InputInterface callback not set, user input will not be available");
+    LOG(LogLevel::LOG_ERROR, "InputInterface callback not set, user input will not be available");
     return;
   }
   _input->setCallback(_callback);
@@ -56,12 +56,12 @@ void InputManager::setDisplay(DisplayInterface *display) {
   if (display == nullptr || _input == nullptr) {
     return;
   }
-  LOG(LogLevel::DEBUG, "InputManager::setDisplay() - display ID %d", display->getId());
+  LOG(LogLevel::LOG_DEBUG, "InputManager::setDisplay() - display ID %d", display->getId());
   _input->setDisplay(display);
 }
 
 void InputManager::startInput() {
-  LOG(LogLevel::DEBUG, "InputManager::startInput()");
+  LOG(LogLevel::LOG_DEBUG, "InputManager::startInput()");
   if (_input != nullptr) {
     _input->begin();
   }
diff --git a/Logger.cpp b/Logger.cpp
@@ -17,7 +17,7 @@
 
 #include "Logger.h"
 
-Logger::Logger(Stream *outputStream) : _outputStream(outputStream), _currentLevel(LogLevel::WARN) {}
+Logger::Logger(Stream *outputStream) : _outputStream(outputStream), _currentLevel(LogLevel::LOG_WARN) {}
 
 void Logger::setLogLevel(LogLevel logLevel) { _currentLevel = logLevel; }
 
@@ -28,19 +28,19 @@ void Logger::log(LogLevel logLevel, const char *format, ...) {
     // Setup the prefix
     const char *prefix;
     switch (logLevel) {
-    case LogLevel::MESSAGE:
+    case LogLevel::LOG_MESSAGE:
       prefix = "[MESSAGE] ";
       break;
-    case LogLevel::ERROR:
+    case LogLevel::LOG_ERROR:
       prefix = "[ERROR] ";
       break;
-    case LogLevel::WARN:
+    case LogLevel::LOG_WARN:
       prefix = "[WARN] ";
       break;
-    case LogLevel::INFO:
+    case LogLevel::LOG_INFO:
       prefix = "[INFO] ";
       break;
-    case LogLevel::DEBUG:
+    case LogLevel::LOG_DEBUG:
       prefix = "[DEBUG] ";
       break;
     default:
diff --git a/Logger.h b/Logger.h
@@ -27,7 +27,7 @@
   _logger->log(level, __VA_ARGS__)
 
 /// @brief Define valid log levels in ascending order
-enum LogLevel { MESSAGE, NONE, ERROR, WARN, INFO, DEBUG };
+enum LogLevel { LOG_MESSAGE, LOG_NONE, LOG_ERROR, LOG_WARN, LOG_INFO, LOG_DEBUG };
 
 /// @brief Class to enable simple logging to a Stream object with different log levels
 /// This enables embedding permanent error, warn, info, and debug messages in the software, with the user defining the
diff --git a/Screen.cpp b/Screen.cpp
@@ -29,7 +29,7 @@ void Screen::updateScreenRow(uint8_t screenRowId, const char *text) {
   if (text == nullptr) {
     return;
   }
-  LOG(LogLevel::DEBUG, "Screen::updateScreenRow[%d](%d, %s)", _screenId, screenRowId, text);
+  LOG(LogLevel::LOG_DEBUG, "Screen::updateScreenRow[%d](%d, %s)", _screenId, screenRowId, text);
   // Check if it exists already
   ScreenRow *updateRow = getScreenRowById(screenRowId);
   // If not, create and add to the list unless this is supposed to delete it with ""
@@ -78,7 +78,7 @@ Screen::~Screen() {
 }
 
 void Screen::_addScreenRow(uint8_t screenRowId, const char *text) {
-  LOG(LogLevel::DEBUG, "Screen::_addScreenRow(%d, %s)", screenRowId, text);
+  LOG(LogLevel::LOG_DEBUG, "Screen::_addScreenRow(%d, %s)", screenRowId, text);
   ScreenRow *newRow = new ScreenRow(screenRowId);
   newRow->setText(text);
   if (_logger != nullptr) {
@@ -102,7 +102,7 @@ void Screen::_deleteScreenRow(ScreenRow *screenRow) {
   if (screenRow == nullptr) {
     return;
   }
-  LOG(LogLevel::DEBUG, "Screen::_deleteScreenRow() - ID: %d", screenRow->getId());
+  LOG(LogLevel::LOG_DEBUG, "Screen::_deleteScreenRow() - ID: %d", screenRow->getId());
   // If it's the first in the list, shuffle to next, delete, and done
   if (_firstScreenRow == screenRow) {
     ScreenRow *deleteRow = _firstScreenRow;
diff --git a/ScreenManager.cpp b/ScreenManager.cpp
@@ -21,7 +21,7 @@ ScreenManager::ScreenManager() : _firstScreen(nullptr), _logger(nullptr) {}
 
 Screen *ScreenManager::updateScreen(uint8_t screenId) {
   // If the screen doesn't exist, create and add to list
-  LOG(LogLevel::DEBUG, "ScreenManager::addScreen(%d)", screenId);
+  LOG(LogLevel::LOG_DEBUG, "ScreenManager::addScreen(%d)", screenId);
   if (getScreenById(screenId) == nullptr) {
     Screen *newScreen = new Screen(screenId);
     if (_logger != nullptr) {
diff --git a/ScreenRow.cpp b/ScreenRow.cpp
@@ -37,7 +37,7 @@ void ScreenRow::setText(const char *text) {
   _text = new char[strlen(text) + 1];
   strcpy(_text, text);
   _needsRedraw = true;
-  LOG(LogLevel::DEBUG, "ScreenRow::setText(%s)", _text);
+  LOG(LogLevel::LOG_DEBUG, "ScreenRow::setText(%s)", _text);
 }
 
 const char *ScreenRow::getText() {
diff --git a/TFT_eSPIDisplay.cpp b/TFT_eSPIDisplay.cpp
diff --git a/TFT_eSPITouch.cpp b/TFT_eSPITouch.cpp
diff --git a/Version.h b/Version.h
diff --git a/test/integration/test_InteractiveLogger/test_AtFinder_Logger.cpp b/test/integration/test_InteractiveLogger/test_AtFinder_Logger.cpp
diff --git a/test/unit/test_Configurator/test_Configurator.cpp b/test/unit/test_Configurator/test_Configurator.cpp
diff --git a/test/unit/test_Infrastructure/test_Logger.cpp b/test/unit/test_Infrastructure/test_Logger.cpp

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ void AtFinder::setup(uint8_t maxTextLength, CallbackInterface *callback) {`
`50`	`50`	`_maxTextLength = maxTextLength;`
`51`	`51`	`_text = (char *)malloc(_maxTextLength + 1);`
`52`	`52`	`_callback = callback;`
`53`		`- LOG(LogLevel::DEBUG, "AtFinder::setup with _maxTextLength %d", _maxTextLength);`
	`53`	`+ LOG(LogLevel::LOG_DEBUG, "AtFinder::setup with _maxTextLength %d", _maxTextLength);`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`void AtFinder::processInputChar(char hot) {`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ void Configurator::initialise() {`
`50`	`50`	`if (display != nullptr) {`
`51`	`51`	`_inputManager->setDisplay(display);`
`52`	`52`	`} else {`
`53`		`- LOG(LogLevel::ERROR, "Could not get display ID %d required by the input, user input not available", displayId);`
	`53`	`+ LOG(LogLevel::LOG_ERROR, "Could not get display ID %d required by the input, user input not available", displayId);`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`	`DisplayManager::DisplayManager() : _firstDisplay(nullptr), _logger(nullptr), _nextDisplayId(0) {}`
`24`	`24`
`25`	`25`	`void DisplayManager::addDisplay(DisplayInterface *display) {`
`26`		`- LOG(LogLevel::DEBUG, "DisplayManager::addDisplay()");`
	`26`	`+ LOG(LogLevel::LOG_DEBUG, "DisplayManager::addDisplay()");`
`27`	`27`	`if (display == nullptr) {`
`28`	`28`	`return;`
`29`	`29`	`}`
`@@ -43,7 +43,7 @@ void DisplayManager::addDisplay(DisplayInterface *display) {`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`void DisplayManager::startDisplays() {`
`46`		`- LOG(LogLevel::DEBUG, "DisplayManager::startDisplays()");`
	`46`	`+ LOG(LogLevel::LOG_DEBUG, "DisplayManager::startDisplays()");`
`47`	`47`	`if (_firstDisplay == nullptr) {`
`48`	`48`	`return;`
`49`	`49`	`}`
`@@ -54,7 +54,7 @@ void DisplayManager::startDisplays() {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`void DisplayManager::clearAllDisplays() {`
`57`		`- LOG(LogLevel::DEBUG, "DisplayManager::clearAllDisplays()");`
	`57`	`+ LOG(LogLevel::LOG_DEBUG, "DisplayManager::clearAllDisplays()");`
`58`	`58`	`if (_firstDisplay == nullptr) {`
`59`	`59`	`return;`
`60`	`60`	`}`
`@@ -66,7 +66,7 @@ void DisplayManager::clearAllDisplays() {`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`void DisplayManager::displayStartupInfo(const char *version) {`
`69`		`- LOG(LogLevel::DEBUG, "DisplayManager::displayStartupInfo(%s)", version);`
	`69`	`+ LOG(LogLevel::LOG_DEBUG, "DisplayManager::displayStartupInfo(%s)", version);`
`70`	`70`	`// Do nothing if we don't have a DisplayManager or any displays`
`71`	`71`	`if (_firstDisplay == nullptr) {`
`72`	`72`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -25,17 +25,17 @@`
`25`	`25`	`InputManager::InputManager() : _display(nullptr), _input(nullptr), _logger(nullptr), _callback(nullptr) {}`
`26`	`26`
`27`	`27`	`void InputManager::addInput(InputInterface *input) {`
`28`		`- LOG(LogLevel::DEBUG, "InputManager::addInput()");`
	`28`	`+ LOG(LogLevel::LOG_DEBUG, "InputManager::addInput()");`
`29`	`29`	`if (input == nullptr) {`
`30`		`- LOG(LogLevel::ERROR, "InputInterface doesn't exist, user input will not be available");`
	`30`	`+ LOG(LogLevel::LOG_ERROR, "InputInterface doesn't exist, user input will not be available");`
`31`	`31`	`return;`
`32`	`32`	`}`
`33`	`33`	`_input = input;`
`34`	`34`	`if (_logger) {`
`35`	`35`	`_input->setLogger(_logger);`
`36`	`36`	`}`
`37`	`37`	`if (_callback == nullptr) {`
`38`		`- LOG(LogLevel::ERROR, "InputInterface callback not set, user input will not be available");`
	`38`	`+ LOG(LogLevel::LOG_ERROR, "InputInterface callback not set, user input will not be available");`
`39`	`39`	`return;`
`40`	`40`	`}`
`41`	`41`	`_input->setCallback(_callback);`
`@@ -56,12 +56,12 @@ void InputManager::setDisplay(DisplayInterface *display) {`
`56`	`56`	`if (display == nullptr \|\| _input == nullptr) {`
`57`	`57`	`return;`
`58`	`58`	`}`
`59`		`- LOG(LogLevel::DEBUG, "InputManager::setDisplay() - display ID %d", display->getId());`
	`59`	`+ LOG(LogLevel::LOG_DEBUG, "InputManager::setDisplay() - display ID %d", display->getId());`
`60`	`60`	`_input->setDisplay(display);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`void InputManager::startInput() {`
`64`		`- LOG(LogLevel::DEBUG, "InputManager::startInput()");`
	`64`	`+ LOG(LogLevel::LOG_DEBUG, "InputManager::startInput()");`
`65`	`65`	`if (_input != nullptr) {`
`66`	`66`	`_input->begin();`
`67`	`67`	`}`