GPU Display Improvemnts: bind middle mouse button, better error messages, improve console usage

Author: davidrohr

GPU/GPUTracking/display/GPUDisplay.cxx

@@ -256,6 +256,10 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
 {
   HighResTimer timer(mUpdateVertexLists && mChain->GetProcessingSettings().debugLevel >= 2);
   int32_t mMouseWheelTmp = mFrontend->mMouseWheel;
+  if (mCfgC.showConsole && mMouseWheelTmp) { // Scrolls the console instead of zooming, one line per step (100)
+    mFrontend->mConsole->scroll(mMouseWheelTmp / 100 ? mMouseWheelTmp / 100 : (mMouseWheelTmp > 0) - (mMouseWheelTmp < 0));
+    mMouseWheelTmp = 0;
+  }
   mFrontend->mMouseWheel = 0;
   bool lookOrigin = mCfgR.camLookOrigin ^ mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_FOCUS_ORIGIN]];
   bool yUp = mCfgR.camYUp ^ mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_FOCUS_ORIENT_UP]] ^ lookOrigin;
@@ -308,7 +312,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
     float rotPitch = rotatescalefactor * mFPSScale * 2 * (mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_PITCH_DOWN]] - mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_PITCH_UP]]) * (!mFrontend->mKeys[mFrontend->KEY_SHIFT]);
 
     float mouseScale = 1920.f / std::max<float>(1920.f, mBackend->mScreenWidth);
-    if (mFrontend->mMouseDnR && mFrontend->mMouseDn) {
+    if ((mFrontend->mMouseDnR && mFrontend->mMouseDn) || mFrontend->mMouseDnM) {
       moveZ += -scalefactor * mouseScale * ((float)mFrontend->mMouseMvY - (float)mFrontend->mMouseDnY) / 4;
       rotRoll += -rotatescalefactor * mouseScale * ((float)mFrontend->mMouseMvX - (float)mFrontend->mMouseDnX);
     } else if (mFrontend->mMouseDnR) {
@@ -430,7 +434,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
     calcXYZ(&mViewMatrix->Elements[0][0]);
   }
 
-  if (mFrontend->mMouseDn || mFrontend->mMouseDnR) {
+  if (mFrontend->mMouseDn || mFrontend->mMouseDnR || mFrontend->mMouseDnM) {
     mFrontend->mMouseDnX = mFrontend->mMouseMvX;
     mFrontend->mMouseDnY = mFrontend->mMouseMvY;
   }
@@ -740,9 +744,16 @@ void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool re
       showInfo(info);
     }
     if (consoleFraction > 0.f) {
-      const double consoleTime = mConsoleTimer.GetCurrentElapsedTime();
-      const bool cursor = mCfgC.showConsole && consoleTime >= mConfig.internal.consoleDelay && std::fmod(consoleTime - mConfig.internal.consoleDelay, 1.0) < 0.5; // Only when fully open, blinking, the timer runs while the console is open
-      mBackend->GLDrawConsole(consoleFraction, mFrontend->mConsole->mConsoleHistory, mFrontend->mConsole->shownText(), cursor ? (int32_t)mFrontend->mConsole->mConsoleTextPos : -1);
+      const bool open = mCfgC.showConsole && mConsoleTimer.GetCurrentElapsedTime() >= mConfig.internal.consoleDelay; // Cursor only when fully open
+      if (!open) {
+        mConsoleCursorTimer.Reset();
+      } else if (!mConsoleCursorTimer.IsRunning() || mConsoleCursorPos != mFrontend->mConsole->mConsoleTextPos) { // Blinking restarts visible when the cursor moves
+        mConsoleCursorTimer.ResetStart();
+        mConsoleCursorPos = mFrontend->mConsole->mConsoleTextPos;
+      }
+      const bool cursor = open && std::fmod(mConsoleCursorTimer.GetCurrentElapsedTime(), 1.0) < 0.5;
+      auto& console = *mFrontend->mConsole;
+      console.mVisibleLines = mBackend->GLDrawConsole(consoleFraction, console.mConsoleHistory, console.shownText(), cursor ? (int32_t)console.mConsoleTextPos : -1, console.mScroll);
     }
     if (drawText) {
       mBackend->finishText();

GPU/GPUTracking/display/GPUDisplay.h

@@ -333,6 +333,8 @@ class GPUDisplay : public GPUDisplayInterface
   std::string mGUIInfoText;                                    // Latest info message (SetInfo) for the Qt GUI
   uint64_t mGUIInfoTextCounter = 0;                            // Number of info messages, the GUI shows a new one for some seconds
   HighResTimer mInfoText2Timer, mInfoHelpTimer, mConsoleTimer; // mConsoleTimer: opening / closing animation of the console
+  HighResTimer mConsoleCursorTimer;                            // Blinking of the console cursor, started when the console is fully open, restarted when the cursor moves
+  uint32_t mConsoleCursorPos = 0;                              // Cursor position at the last restart of mConsoleCursorTimer
   bool mConsoleShown = false;                                  // showConsole of the last checkAndApplyConfigChanges
 
   std::vector<threadVertexBuffer> mThreadBuffers;

GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx

@@ -220,10 +220,10 @@ void GPUDisplayBackend::GLDrawLine(float x0, float y0, float x1, float y1, float
   GLDrawQuad({{x0 + nx, y0 + ny}, {x0 - nx, y0 - ny}, {x1 - nx, y1 - ny}, {x1 + nx, y1 + ny}}, color);
 }
 
-void GPUDisplayBackend::GLDrawConsole(float verticalFraction, std::span<const std::string> previous, const std::string& current, int32_t cursorPos)
+uint32_t GPUDisplayBackend::GLDrawConsole(float verticalFraction, std::span<const std::string> previous, const std::string& current, int32_t cursorPos, uint32_t scroll)
 {
   if (!mFreetypeInitialized) {
-    return;
+    return 1;
   }
   const float scale = mDisplay->frontend()->getDisplayScale();
   const float colorValue = mDisplay->cfgL().invertColors ? 0.f : 1.f;
@@ -239,12 +239,17 @@ void GPUDisplayBackend::GLDrawConsole(float verticalFraction, std::span<const st
   const size_t maxChars = mFontCharWidth > 0.f ? std::max(0.f, (width / scale - 2 * MARGIN) / mFontCharWidth) : SIZE_MAX; // Longer lines are cut
   float y = bottom + (0.5f + MARGIN) * scale + descent;                                                                   // Baseline of the lowest line, MARGIN above the line (half its width)
   if (cursorPos >= 0 && (size_t)cursorPos < maxChars && mFontCharWidth > 0.f) {                                           // Monospace font: position from the character width
-    GLPrintText("_", (MARGIN + cursorPos * mFontCharWidth) * scale, y, textColor, scale / mFontRasterScale, 0);
-  }
-  for (size_t i = 0; i <= previous.size() && y + lineHeight - descent <= top; i++, y += lineHeight) {
-    const std::string& text = i == 0 ? current : previous[previous.size() - i];
+    const float x0 = (MARGIN + cursorPos * mFontCharWidth) * scale, x1 = x0 + mFontCharWidth * scale;
+    const float y1 = y - 0.5f * descent, y0 = y1 - 3.f * scale;
+    GLDrawQuad({{x0, y0}, {x1, y0}, {x1, y1}, {x0, y1}}, textColor); // Solid underline, 3 logical pixels, below the baseline
+  }
+  const uint32_t nFit = std::max(1.f, std::floor((top - y + descent) / lineHeight) - 1.f); // Lines above the current one that fit, as in the loop
+  scroll = std::min<size_t>(scroll, previous.size());
+  for (size_t i = 0; i <= previous.size() - scroll && y + lineHeight - descent <= top; i++, y += lineHeight) {
+    const std::string& text = i == 0 ? current : previous[previous.size() - scroll - i];
     if (!text.empty() && maxChars) {
       GLPrintText(text.c_str(), MARGIN * scale, y, textColor, scale / mFontRasterScale, std::min(text.size(), maxChars));
     }
   }
+  return nFit;
 }

GPU/GPUTracking/display/backend/GPUDisplayBackend.h

@@ -101,10 +101,10 @@ class GPUDisplayBackend
   const char* backendName() const { return mBackendName; }
   virtual void resizeScene(uint32_t width, uint32_t height) {}
   virtual size_t needMultiVBO() { return 0; }
-  virtual void GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters) = 0;                   // nCharacters > 0: at most that many characters, otherwise until the terminating 0
-  virtual void GLDrawQuad(const float (&corners)[4][2], const float* color) = 0;                                                    // Filled quad with the corners counterclockwise, in pixels with y from the bottom, drawn with the text (SOLID_GLYPH)
-  void GLDrawLine(float x0, float y0, float x1, float y1, float width, const float* color);                                         // As GLDrawQuad
-  void GLDrawConsole(float verticalFraction, std::span<const std::string> previous, const std::string& current, int32_t cursorPos); // Console over the top verticalFraction of the window: current text in the lowest line, previous ones above (last one lowest), cursor _ at cursorPos (< 0: none)
+  virtual void GLPrintText(const char* s, float x, float y, float* color, float scale, uint32_t nCharacters) = 0;                                        // nCharacters > 0: at most that many characters, otherwise until the terminating 0
+  virtual void GLDrawQuad(const float (&corners)[4][2], const float* color) = 0;                                                                         // Filled quad with the corners counterclockwise, in pixels with y from the bottom, drawn with the text (SOLID_GLYPH)
+  void GLDrawLine(float x0, float y0, float x1, float y1, float width, const float* color);                                                              // As GLDrawQuad
+  uint32_t GLDrawConsole(float verticalFraction, std::span<const std::string> previous, const std::string& current, int32_t cursorPos, uint32_t scroll); // Console over the top verticalFraction of the window: current text in the lowest line, previous ones above (last one lowest, the last scroll ones skipped), cursor underline at cursorPos (< 0: none); returns the number of previous lines that fit
   static GPUDisplayBackend* getBackend(const char* type);
   std::vector<char> getPixels();
   virtual float getYFactor() const { return 1.0f; }

GPU/GPUTracking/display/frontend/GPUDisplayConsole.cxx

@@ -25,10 +25,38 @@
 
 using namespace o2::gpu;
 
+namespace
+{
+struct consoleArgumentError : public std::runtime_error { // Wrong arguments for an existing command, what(): the error, usage: the argument types
+  consoleArgumentError(const std::string& cmd, const std::string& error, const std::string& types) : std::runtime_error(error), command(cmd), usage("[")
+  {
+    static constexpr std::pair<char, const char*> names[] = {{'s', "string"}, {'i', "int"}, {'d', "double"}, {'a', "any"}, {'+', "[optional]"}};
+    for (char t : types) {
+      for (const auto& [c, name] : names) {
+        usage += c == t ? std::string(usage.size() > 1 ? " " : "") + name : "";
+      }
+    }
+    usage += "]";
+  }
+  std::string command, usage;
+};
+} // namespace
+
 GPUDisplayConsole::GPUDisplayConsole(const std::string& title) : mConsoleHistory{title} {}
 
-void GPUDisplayConsole::handleConsoleKey(uint8_t key)
+void GPUDisplayConsole::scroll(int32_t lines)
 {
+  const int64_t maxScroll = std::max<int64_t>(0, (int64_t)mConsoleHistory.size() - mVisibleLines);
+  mScroll = std::clamp<int64_t>((int64_t)mScroll + lines, 0, maxScroll);
+}
+
+void GPUDisplayConsole::handleConsoleKey(uint8_t key, bool shift)
+{
+  if (key == KEY_PAGEUP || key == KEY_PAGEDOWN || (shift && (key == KEY_UP || key == KEY_DOWN))) { // Half a page / one line
+    const int32_t lines = key == KEY_PAGEUP || key == KEY_PAGEDOWN ? std::max<int32_t>(1, mVisibleLines / 2) : 1;
+    scroll(key == KEY_PAGEUP || key == KEY_UP ? lines : -lines);
+    return;
+  }
   const uint32_t nHistory = mConsoleHistory.size();
   auto isOutput = [this](uint32_t i) { return mConsoleHistory[i].size() && mConsoleHistory[i][0] == ' '; }; // Indented output of commands, not selectable
   if (key == KEY_UP || key == KEY_DOWN) {                                                                   // Entry 0 is the title, not selectable
@@ -43,13 +71,13 @@ void GPUDisplayConsole::handleConsoleKey(uint8_t key)
       }
       mConsoleTextCurrent = i < nHistory ? i : 0;
     }
-    mConsoleTextPos = 0;
+    mConsoleTextPos = shownText().size(); // At the end, as when editing the entry starts
     return;
   } else if (key == KEY_ENTER) {
     std::string command = mConsoleTextCurrent ? mConsoleHistory[mConsoleTextCurrent] : mConsoleText;
     command.erase(0, std::min(command.size(), command.find_first_not_of(' '))); // Leading spaces would mark it as output in the history
     mConsoleText.clear();
-    mConsoleTextCurrent = mConsoleTextPos = 0;
+    mConsoleTextCurrent = mConsoleTextPos = mScroll = 0;
     if (!command.empty()) {
       consoleAppend(command); // Before its output
       handleConsoleCommand(command);
@@ -184,7 +212,7 @@ std::tuple<const GPUDisplayConsole::GPUDisplayConsoleCommand&, std::vector<GPUDi
   const bool more = types.size() && types.back() == '+';
   const size_t nFixed = types.size() - more, nArgs = tokens.size() - 1;
   if (nArgs < nFixed || (!more && nArgs > nFixed)) {
-    throw std::runtime_error(name + ": " + std::to_string(nFixed) + (more ? " or more" : "") + " arguments expected, got " + std::to_string(nArgs));
+    throw consoleArgumentError(name, std::to_string(nFixed) + (more ? " or more" : "") + " arguments expected, got " + std::to_string(nArgs), types);
   }
   auto autoType = [](const std::string& text, bool plain) -> consoleArg { // int64_t for [+-]digits, double for other decimal numbers (also with exponent, as saveSettings writes them), string otherwise or if plain text
     const char *begin = text.c_str() + (text[0] == '+' || text[0] == '-'), *end = text.c_str() + text.size();
@@ -204,12 +232,12 @@ std::tuple<const GPUDisplayConsole::GPUDisplayConsoleCommand&, std::vector<GPUDi
     const char type = i < nFixed ? types[i] : '+';
     consoleArg value = type == 's' ? consoleArg(text) : autoType(text, plain);
     if (type == 'i' && !std::holds_alternative<int64_t>(value)) {
-      throw std::runtime_error(name + ": argument " + std::to_string(i + 1) + " (" + text + ") must be an integer");
+      throw consoleArgumentError(name, "argument " + std::to_string(i + 1) + " (" + text + ") must be an integer", types);
     } else if (type == 'd') {
       if (std::holds_alternative<int64_t>(value)) {
         value = (double)std::get<int64_t>(value);
       } else if (!std::holds_alternative<double>(value)) {
-        throw std::runtime_error(name + ": argument " + std::to_string(i + 1) + " (" + text + ") must be a number");
+        throw consoleArgumentError(name, "argument " + std::to_string(i + 1) + " (" + text + ") must be a number", types);
       }
     } else if (type != 's' && type != 'i' && type != 'a' && type != '+') {
       throw std::runtime_error(name + ": invalid argument types " + types);
@@ -230,6 +258,9 @@ void GPUDisplayConsole::handleConsoleCommand(std::string_view cmd)
     auto parsed = parseConsoleCommand(cmd);
     command = &std::get<0>(parsed);
     args = std::move(std::get<1>(parsed));
+  } catch (const consoleArgumentError& e) {
+    consolePrint("Invalid arguments for %s: %s %s", e.command.c_str(), e.what(), e.usage.c_str());
+    return;
   } catch (const std::runtime_error& e) {
     consolePrint("Invalid command: %s", e.what());
     return;

GPU/GPUTracking/display/frontend/GPUDisplayConsole.h

@@ -41,7 +41,8 @@ class GPUDisplayConsole : public GPUDisplayFrontendKeyVars // Text console of th
   };
   GPUDisplayConsole(const std::string& title); // First history entry, not selectable
 
-  void handleConsoleKey(uint8_t key);              // Key typed while the console is shown
+  void handleConsoleKey(uint8_t key, bool shift);  // Key typed while the console is shown
+  void scroll(int32_t lines);                      // Scrolls the history up (> 0) or down, limited to its lines
   void handleConsoleCommand(std::string_view cmd); // Runs the command named by the first token, error if unknown
   void runScript(std::string_view script);         // Queues the lines (separated by \n / \r) as console commands before the remaining script lines, runs them up to a wait
   void runScriptFile(const std::string& filename); // runScript with the content of the file
@@ -76,6 +77,8 @@ class GPUDisplayConsole : public GPUDisplayFrontendKeyVars // Text console of th
   std::vector<std::string> mConsoleHistory;                   // Title, then commands entered in the console and their output (indented)
   std::string mConsoleText;                                   // Text being typed in the console
   uint32_t mConsoleTextCurrent = 0;                           // Entry of mConsoleHistory shown in the console (selected with up / down, the title entry 0 is not selectable), 0 for mConsoleText
+  uint32_t mScroll = 0;                                       // History lines scrolled up (the lowest ones not shown), reset by enter
+  uint32_t mVisibleLines = 1;                                 // History lines fitting into the console, set when it is drawn
   uint32_t mConsoleTextPos = 0;                               // Cursor position in the shown text (left / right), the character there is the current one
 };
 } // namespace o2::gpu

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h

@@ -116,7 +116,7 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface, public GPUDisplay
   // Keyboard / Mouse actions
   bool mMouseDn = false;      // Mouse button down
   bool mMouseDnR = false;     // Right mouse button down
-  bool mMouseDnM = false;     // Middle mouse button down (not used yet)
+  bool mMouseDnM = false;     // Middle mouse button down, as left + right
   float mMouseDnX, mMouseDnY; // X/Y position where mouse button was pressed
   float mMouseMvX, mMouseMvY; // Current mouse pointer position
   int32_t mMouseWheel = 0;    // Incremental value of mouse wheel, ca +/- 100 per wheel tick

GPU/GPUTracking/display/frontend/GPUDisplayFrontendConfig.cxx

@@ -720,7 +720,7 @@ void GPUDisplay::HandleKey(uint8_t key, bool external, bool bypassConsole)
 {
   if (mCfgC.showConsole && !bypassConsole && mFrontend->mConfiguration->keyRTTIIndex(key) != mFrontend->mConfiguration->getRTTIIndex(*this, &GPUDisplayControl::showConsole)) { // All keys except the one toggling the console go to the console
     if (!external) {
-      mFrontend->mConsole->handleConsoleKey(key);
+      mFrontend->mConsole->handleConsoleKey(key, mFrontend->mKeys[mFrontend->KEY_SHIFT]);
     }
     return;
   }

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx

@@ -170,8 +170,8 @@ void GPUDisplayFrontendGlfw::key_callback(GLFWwindow* window, int32_t key, int32
   int32_t handleKey = 0, keyPress = 0;
   GetKey(key, scancode, mods, handleKey, keyPress);
   if (handleKey < 32) {
-    if (action == GLFW_PRESS || action == GLFW_REPEAT) { // Repeat as the other frontends (e.g. backspace in the console), characters are repeated by char_callback
-      me->mKeys[keyPress] = !me->consoleShown();
+    if (action == GLFW_PRESS || action == GLFW_REPEAT) {                  // Repeat as the other frontends (e.g. backspace in the console), characters are repeated by char_callback
+      me->mKeys[keyPress] = keyPress == KEY_SHIFT || !me->consoleShown(); // Held keys only without console, SHIFT also with it (scrolling)
       me->HandleKey(handleKey);
     } else if (action == GLFW_RELEASE) {
       me->mKeys[keyPress] = false;
@@ -203,7 +203,7 @@ void GPUDisplayFrontendGlfw::char_callback(GLFWwindow* window, uint32_t codepoin
       keyPress += 'A' - 'a';
     }
     me->mGLFWKeyDownMap[me->mLastKeyDown] = keyPress;
-    me->mKeys[keyPress] = !me->consoleShown();
+    me->mKeys[keyPress] = keyPress == KEY_SHIFT || !me->consoleShown(); // Held keys only without console, SHIFT also with it (scrolling)
     me->HandleKey(codepoint);
   }
 }

GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.cxx

@@ -134,7 +134,7 @@ void GPUDisplayFrontendGlut::keyboardFunc(int32_t key, bool special, bool down)
 {
   int32_t handleKey = 0, keyPress = 0;
   GetKey(key, handleKey, keyPress, special);
-  mKeys[keyPress] = down && !consoleShown();
+  mKeys[keyPress] = down && (keyPress == KEY_SHIFT || !consoleShown()); // Held keys only without console, SHIFT also with it (scrolling)
   if (down) {
     HandleKey(handleKey);
   }