@@ -436,7 +436,7 @@ EndConfig()
 #ifndef GPUCA_GPUCODE_DEVICE
 // Light settings concerning the event display (can be changed without rebuilding vertices)
 BeginSubConfig(GPUSettingsDisplayLight, light, configStandalone.display, "GLL", 'g', "Light OpenGL display settings", display_light)
-AddOption(animationMode, int32_t, 0, "", 0, "")
+AddOption(animationMode, int32_t, 0, "", 0, "", min(0), max(6))
 AddOption(smoothPoints, bool, true, "", 0, "Apply smoothing to points")
 AddOption(smoothLines, bool, false, "", 0, "Apply smoothing to lines")
 AddOption(depthBuffer, bool, false, "", 0, "Enable Z-buffer")
@@ -449,19 +449,19 @@ AddOption(drawTracks, bool, false, "", 0, "Highlight sector tracks")
 AddOption(drawExtrapolatedTracks, bool, false, "", 0, "Highlight global sector tracks prolonged into adjacent sector")
 AddOption(drawFinal, bool, false, "", 0, "Highlight final tracks")
 AddOption(excludeClusters, int32_t, 0, "", 0, "Exclude clusters from selected draw objects from display, (2 = exclude clusters but still show tracks)")
-AddOption(drawSector, int32_t,  -1, "", 0, "Show individual sector")
+AddOption(drawSector, int32_t,  -1, "", 0, "Show individual sector", min(-1), max(35))
 AddOption(drawRelatedSectors, int32_t, 0, "", 0, "Show related sectors (if drawSector != -1)")
 AddOption(drawGrid, int32_t, 0, "", 0, "Highlight grid")
 AddOption(propagateTracks, int32_t, 0, "", 0, "Propagate final tracks further (inward / outward / show MC tracks)")
 AddOption(showCollision, int32_t, -1, "", 0, "Show only individual collision")
 AddOption(colorCollisions, int32_t, 0, "", 0, "Distinguish collisions in timeframe by color")
 AddOption(colorClusters, int32_t, 1, "", 0, "Color clusters belonging to track objects")
-AddOption(pointSize, float, 2.0f, "", 0, "Set point size")
-AddOption(lineWidth, float, 1.4f, "", 0, "Set line width")
+AddOption(pointSize, float, 2.0f, "", 0, "Set point size", min(0.8f), max(20.f))
+AddOption(lineWidth, float, 1.4f, "", 0, "Set line width", min(0.4f), max(20.f))
 AddOption(drawTPC, bool, true, "", 0, "Enable drawing TPC data")
-AddOption(drawTRD, bool, true, "", 0, "Enabale drawing TRD data")
-AddOption(drawTOF, bool, true, "", 0, "Enabale drawing TOF data")
-AddOption(drawITS, bool, true, "", 0, "Enabale drawing ITS data")
+AddOption(drawTRD, bool, true, "", 0, "Enable drawing TRD data")
+AddOption(drawTOF, bool, true, "", 0, "Enable drawing TOF data")
+AddOption(drawITS, bool, true, "", 0, "Enable drawing ITS data")
 AddOption(drawField, bool, false, "", 0, "Enable drawing magnetic field")
 AddOption(bFieldStepSize, float, 5.0f, "", 0, "Set field line step size")
 AddOption(bFieldStepCount, int32_t, 100, "", 0, "Set field line step count")
@@ -477,7 +477,7 @@ AddOption(drawITSTracks, bool, true, "", 0, "Show tracks with ITS contribution")
 AddOption(drawTRDTracks, bool, true, "", 0, "Show tracks with TRD contribution")
 AddOption(drawTOFTracks, bool, true, "", 0, "Show tracks with TOF contribution")
 AddOption(drawTracksAndFilter, bool, false, "", 0, "Use AND filter instead of OR filter for selecting tracks")
-AddOption(propagateLoopers, bool, false, "", 0, "Enabale propagation of loopers")
+AddOption(propagateLoopers, bool, false, "", 0, "Enable propagation of loopers")
 AddOption(clustersOnly, bool, false, "", 0, "Visualize clusters only")
 AddOption(clustersOnNominalRow, bool, false, "", 0, "Show clusters at nominal x of pad row for early-transformed data")
 AddOption(separateExtrapolatedTracks, bool, false, "", 0, "Draw track segments propagated to adjacent sectors separately")
@@ -490,8 +490,7 @@ AddOption(hideRejectedTracks, int32_t, 1, "", 0, "Hide rejected tracks")
 AddOption(hideUnmatchedClusters, int32_t, 0, "", 0, "Hide unmatched clusters")
 AddOption(trackFilter, int32_t, 0, "", 0, "Apply filter on tracks to be displayed")
 AddOption(projectXY, int32_t, 0, "", 0, "Project everything on the XY-plane")
-AddOption(xAdd, float, 0, "", 0, "Separate sectors, increase X coordinate")
-AddOption(zAdd, float, 0, "", 0, "Separate sides, increase Z coordinate")
+AddOption(xzAdd, float, 0, "", 0, "Separate sectors, increase X coordinate", min(0.f), max(300.f))
 AddHelp("help", 'h')
 EndConfig()
 
@@ -502,14 +501,14 @@ AddOption(camYUp, bool, false, "", 0, "Orient the camera such that the y-axis is
 AddOption(cameraMode, int32_t, 0, "", 0, "Camera mode")
 AddOption(fullScreen, bool, false, "", 0, "Full Screen")
 AddOption(maximized, bool, true, "", 0, "Maximized window")
-AddOption(drawQualityMSAA, int32_t, 0, "", 0, "MultiSample Anti Aliasing")
-AddOption(drawQualityDownsampleFSAA, int32_t, 0, "", 0, "Downsampling Anti Aliasing")
+AddOption(drawQualityMSAA, int32_t, 0, "", 0, "MultiSample Anti Aliasing", min(0), max(8))
+AddOption(drawQualityDownsampleFSAA, int32_t, 0, "", 0, "Downsampling Anti Aliasing", min(0), max(4))
 AddOption(drawQualityVSync, bool, true, "", 0, "Enable Vertical Sync")
 AddOption(fpsLimit, int32_t, 1, "", 0, "FPS limit: 0 = none (maximum rate), 1 = display refresh rate (no limit without VSync), 2 = fpsRate")
-AddOption(fpsRate, int32_t, 100, "", 0, "Target frame rate (frames per second) for fpsLimit 2, or if the backend cannot limit to the refresh rate (0 = no limit)")
+AddOption(fpsRate, int32_t, 100, "", 0, "Target frame rate (frames per second) for fpsLimit 2, or if the backend cannot limit to the refresh rate", min(1), max(9999))
 AddOption(useGLIndirectDraw, bool, true, "", 0, "Use OpenGL indirect draws to reduce number of draw calls")
-AddOption(screenshotScaleFactor, int32_t, 1, "", 0, "Resolution scale factor when taking screenshots")
-AddOption(fov, int32_t, 45, "", 0, "Display FOV")
+AddOption(screenshotScaleFactor, int32_t, 1, "", 0, "Resolution scale factor when taking screenshots", min(1), max(5))
+AddOption(fov, float, 45.f, "", 0, "Display FOV", min(5.f), max(175.f))
 AddHelp("help", 'h')
 EndConfig()
 
 
@@ -24,6 +24,7 @@
 #include <stdexcept>
 #include <mutex>
 #include <condition_variable>
+#include <filesystem>
 
 #ifndef _WIN32
 #include "../utils/linux_helpers.h"
@@ -201,6 +202,9 @@ int32_t GPUDisplay::InitDisplay_internal()
 void GPUDisplay::ExitDisplay()
 {
   mBackend->ExitBackend();
+  if (mTrackFilterMacroTemporary) { // Custom track filter macro code
+    std::filesystem::remove(mTrackFilterMacroLoaded);
+  }
 }
 
 int32_t GPUDisplay::DrawGLScene(bool suspended)
@@ -218,6 +222,10 @@ int32_t GPUDisplay::DrawGLScene(bool suspended)
   } else if (!mOverlayTFClusters.size()) {
     mNCollissions = std::max(1u, mIOPtrs->nMCInfosTPCCol);
   }
+  if (mCfgL.showCollision >= mNCollissions) { // Fewer collisions in the new event
+    mCfgL.showCollision = -1;
+    mUpdateDrawCommands = true;
+  }
   try {
     DrawGLScene_internal(suspended);
   } catch (const std::runtime_error& e) {
@@ -244,8 +252,8 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
   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;
-  bool rotateModel = mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_MODEL]] || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_AROUND_Z]];
-  bool rotateModelTPC = mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_AROUND_Z]];
+  bool rotateModelTPC = mCfgC.mRotateAroundZ || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_AROUND_Z]];
+  bool rotateModel = rotateModelTPC || mCfgC.mRotateModel || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_MODEL]];
 
   // Calculate rotation / translation scaling factors
   float scalefactor = mFrontend->mKeys[mFrontend->KEY_SHIFT] ? 0.2f : 1.0f;
@@ -277,7 +285,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
     mCfgL.lineWidth = 1.4f;
     mCfgL.drawSector = -1;
     mCfgL.showCollision = -1;
-    mCfgH.xAdd = mCfgH.zAdd = 0;
+    mCfgH.xzAdd = 0;
     mCfgR.camLookOrigin = mCfgR.camYUp = false;
     mAngleRollOrigin = -1e9f;
     mCfgR.fov = 45.f;
@@ -305,13 +313,15 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
     }
 
     if (mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_CHANGE_ANIMATION_INTERVAL]]) {
-      mAnimationDelay += moveX;
-      if (mAnimationDelay < 0.05f) {
-        mAnimationDelay = 0.05f;
+      mCfgC.mAnimationDelay += moveX;
+      if (mCfgC.mAnimationDelay < 0.05f) {
+        mCfgC.mAnimationDelay = 0.05f;
+      } else if (mCfgC.mAnimationDelay > 20.f) {
+        mCfgC.mAnimationDelay = 20.f;
       }
       moveX = 0.f;
       moveY = 0.f;
-      SetInfo("Animation delay set to %1.2f", mAnimationDelay);
+      SetInfo("Animation delay set to %1.2f", mCfgC.mAnimationDelay);
     }
 
     if (yUp) {
@@ -706,10 +716,10 @@ void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool re
     char info[1024];
     float fps = (double)mFramesDoneFPS / fpstime;
     snprintf(info, 1024,
-             "FPS: %6.2f (Sector: %d, 1:Clusters %d, 2:Prelinks %d, 3:Links %d, 4:Seeds %d, 5:Tracklets %d, 6:Tracks %d, 7:GTracks %d, 8:Merger %d) (%d frames, %d draw calls) "
-             "(X %1.2f Y %1.2f Z %1.2f / R %1.2f Phi %1.1f Theta %1.1f) / Yaw %1.1f Pitch %1.1f Roll %1.1f)",
+             "FPS:%8.2f (Sector: %d, 1:Clusters %d, 2:Prelinks %d, 3:Links %d, 4:Seeds %d, 5:Tracklets %d, 6:Tracks %d, 7:GTracks %d, 8:Merger %d) (%d frames, %d draw calls) "
+             "(X %1.2f Y %1.2f Z %1.2f / R %1.2f Phi %1.1f Theta %1.1f) / Yaw %1.1f Pitch %1.1f Roll %1.1f - Size: %ux%u",
              fps, mCfgL.drawSector, mCfgL.drawClusters, mCfgL.drawInitLinks, mCfgL.drawLinks, mCfgL.drawSeeds, mCfgL.drawTracklets, mCfgL.drawTracks, mCfgL.drawExtrapolatedTracks, mCfgL.drawFinal, mFramesDone, mNDrawCalls, mXYZ[0], mXYZ[1], mXYZ[2], mRPhiTheta[0], mRPhiTheta[1] * 180 / CAMath::Pi(),
-             mRPhiTheta[2] * 180 / CAMath::Pi(), mAngle[1] * 180 / CAMath::Pi(), mAngle[0] * 180 / CAMath::Pi(), mAngle[2] * 180 / CAMath::Pi());
+             mRPhiTheta[2] * 180 / CAMath::Pi(), mAngle[1] * 180 / CAMath::Pi(), mAngle[0] * 180 / CAMath::Pi(), mAngle[2] * 180 / CAMath::Pi(), mBackend->mScreenWidth, mBackend->mScreenHeight);
     if (fpstime > 1.) {
       if (mCfgC.mPrintInfoText & 2) {
         GPUInfo("%s", info);
@@ -721,7 +731,7 @@ void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool re
       mFramesDoneFPS = 0;
     }
 
-    if (mCfgC.mPrintInfoText & 1) {
+    if (mCfgC.mPrintInfoText & 1 || mCfgC.mPrintInfoTextGUI) {
       showInfo(info);
     }
   }
@@ -732,9 +742,9 @@ void GPUDisplay::DrawGLScene_internal(bool suspended, float animateTime, bool re
     std::vector<char> pixels = mBackend->getPixels();
     char tmpFileName[48];
     if (animateScreenshot) {
-      snprintf(tmpFileName, 48, "mAnimation%d_%05d.bmp", mAnimationExport, mAnimationFrame);
+      snprintf(tmpFileName, 48, "%d_%05d.bmp", mAnimationExport, mAnimationFrame);
     }
-    DoScreenshot(animateScreenshot ? tmpFileName : mScreenshotFile.c_str(), pixels);
+    DoScreenshot(animateScreenshot ? (mCfgC.mScreenShotname + tmpFileName).c_str() : mScreenshotFile.c_str(), pixels);
   }
 }
 
 
@@ -95,13 +95,25 @@ class GPUDisplay : public GPUDisplayInterface
     bool mRequestScreenshot = false;
     int32_t mAnimateScreenshot = 0;
     bool mAnimationChangeConfig = true;
-    bool dummy = false; // dummy value to reference for keys that do not change variables
+    float mAnimationDelay = 2.f;
+    bool mPrintInfoTextGUI = true;                    // Send the status and info text to the Qt GUI, shown at its bottom
+    bool mGuiPrintInfo = false;                       // Show the info of options changed with Qt GUI elements (not for key presses in the GUI)
+    bool mRotateModel = false;                        // Rotate the model instead of the camera, like holding RCTRL (set in the Qt GUI)
+    bool mRotateAroundZ = false;                      // Rotate the TPC around the beamline, like holding RALT (set in the Qt GUI)
+    std::string mFilterMacroCustom;                   // Code of the custom track filter ROOT macro (trackFilter = filterMacros.size() + 1), set in the Qt GUI
+    std::string mScreenShotname = "screenshot";       // Name of screenshot and animation frame files, followed by numbers
+    std::string mGLPosFile = "glpos.tmp";             // File for saving / loading the camera position
+    std::string mGLAnimationFile = "glanimation.tmp"; // File for saving / loading the animation path
+    int8_t mGuiDarkMode = -1;                         // Dark mode of the Qt GUI, -1 = not yet set: the GUI reports the system scheme when it starts
+    float mGuiScale = 1.f;                            // Scale factor of text and elements of the Qt GUI (on top of the system scaling), Ctrl + mouse wheel / Ctrl + 0 in the GUI
+    bool dummy = false;                               // dummy value to reference for keys that do not change variables
   } mCfgC;
 
  private:
   void buildConfig();
   void buildConfigKeys();
   void buildConfigInfo();
+  void buildConfigQtGUI();
 
   static constexpr int32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
   static constexpr float GL_SCALE_FACTOR = (1.f / 100.f);
@@ -114,6 +126,7 @@ class GPUDisplay : public GPUDisplayInterface
   static constexpr const int32_t N_LINES_TYPE = 7;
   static constexpr const int32_t N_FINAL_TYPE = 4;
   static constexpr int32_t TRACK_TYPE_ID_LIMIT = 100;
+  static const std::array<std::string, 7> ANIMATION_MODE_NAMES_SHORT, ANIMATION_MODE_NAMES_LONG; // By mCfgL.animationMode
   enum PointTypes { tCLUSTER = 0,
                     tINITLINK = 1,
                     tLINK = 2,
@@ -180,6 +193,7 @@ class GPUDisplay : public GPUDisplayInterface
   void updateOptions();
   void disableUnsupportedOptions();
   int32_t buildTrackFilter();
+  std::string trackFilterName() const; // Selected track filter: macro file from filterMacros, or "Custom Macro"
   const GPUTPCTracker& sectorTracker(int32_t iSector);
   const GPUTRDGeometry* trdGeometry();
   const GPUTrackingInOutPointers* mIOPtrs = nullptr;
@@ -191,6 +205,12 @@ class GPUDisplay : public GPUDisplayInterface
   void calcXYZ(const float*);
   void mAnimationCloseAngle(float& newangle, float lastAngle);
   void mAnimateCloseQuaternion(float* v, float lastx, float lasty, float lastz, float lastw);
+  void SaveGLPos(); // Camera position to mCfgC.mGLPosFile
+  void LoadGLPos();
+  void SaveGLAnimation(); // Animation path to mCfgC.mGLAnimationFile
+  void LoadGLAnimation();
+  void takeScreenshot();
+  void runAnimation(); // Starts the animation if it has enough points
   void setAnimationPoint();
   void resetAnimation();
   void removeAnimationPoint();
@@ -300,6 +320,9 @@ class GPUDisplay : public GPUDisplayInterface
   std::vector<bool> mTrackFilter;
 
   volatile bool mUpdateTrackFilter = false;
+  std::string mTrackFilterMacroLoaded;     // Track filter macro file loaded into ROOT, unloaded before loading another one (same function name)
+  bool mTrackFilterMacroTemporary = false; // mTrackFilterMacroLoaded is a temporary file with the custom macro code
+  bool mUpdateGUIOptions = false;          // The Qt GUI must call the dynamic option lambdas of its elements again (new event, GUI started)
   volatile bool mUpdateVertexLists = true;
   volatile bool mUpdateEventData = false;
   volatile bool mUpdateDrawCommands = true;
@@ -313,12 +336,14 @@ class GPUDisplay : public GPUDisplayInterface
   int32_t mAnimationLastBase = 0;
   int32_t mAnimationMixBase = -1; // Target keyframe of the current config blend (mixing), -1 = none
   int32_t mAnimationExport = 0;
-  float mAnimationDelay = 2.f;
   vecpod<float> mAnimateVectors[9];
   vecpod<GPUSettingsDisplayLight> mAnimateConfig;
   opengl_spline mAnimationSplines[8];
 
   char mInfoText2[1024];
+  std::string mGUIInfoStatus;       // Latest status line (FPS etc.) for the Qt GUI
+  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;
 
   std::vector<threadVertexBuffer> mThreadBuffers;
 
@@ -123,22 +123,43 @@ void GPUDisplayFrontend::HandleExternalGUISignals()
     for (int32_t key : update->keys) {
       mDisplay->HandleExternalGUIKey(key);
     }
-    if (update->lineWidth) {
-      mDisplay->mCfgL.lineWidth = *update->lineWidth;
+    applyGUIValues(update->values);
+    if (update->guiScale) {
+      mDisplay->mCfgC.mGuiScale = *update->guiScale;
+    }
+    if (update->guiDarkMode) {
+      mDisplay->mCfgC.mGuiDarkMode = *update->guiDarkMode;
     }
   }
 
   if (gui) {
+    auto values = getGUIValues();
     {
       std::lock_guard lock(mGUIChannel->mutex);
       mGUIChannel->state.cfg = {mDisplay->mCfgH, mDisplay->mCfgL, mDisplay->mCfgR};
+      mGUIChannel->state.values = std::move(values);
+      mGUIChannel->state.guiScale = mDisplay->mCfgC.mGuiScale;
+      mGUIChannel->state.guiDarkMode = mDisplay->mCfgC.mGuiDarkMode;
+      mGUIChannel->state.infoStatus = mDisplay->mCfgC.mPrintInfoTextGUI ? mDisplay->mGUIInfoStatus : "";
+      mGUIChannel->state.infoText = mDisplay->mCfgC.mPrintInfoTextGUI ? mDisplay->mGUIInfoText : "";
+      mGUIChannel->state.infoTextCounter = mDisplay->mGUIInfoTextCounter;
+      if (mDisplay->mUpdateGUIOptions) {
+        mGUIChannel->state.optionsRevision++;
+        mDisplay->mUpdateGUIOptions = false;
+      }
       if (update) {
         mGUIChannel->state.appliedUpdate = update->id;
       }
       mGUIChannel->state.counter++;
       mGUIChannel->displayProcessingCurrentUpdate = false;
     }
     mGUIChannel->stateUpdated.notify_all();
+    std::unique_lock lock(mGUIChannel->mutex);
+    if (mGUIChannel->optionsReadRevision != mGUIChannel->state.optionsRevision) { // The GUI calls the dynamic option lambdas (reading display data) only while we wait here, short timeout, retried in the next frame
+      mGUIChannel->displayWaitingForOptions = true;
+      mGUIChannel->optionsRead.wait_for(lock, std::chrono::milliseconds(20), [this] { return mGUIChannel->optionsReadRevision == mGUIChannel->state.optionsRevision || mGUIChannel->stop; });
+      mGUIChannel->displayWaitingForOptions = false;
+    }
   }
 }
 
@@ -201,10 +222,13 @@ int32_t GPUDisplayFrontend::startGUI()
       std::lock_guard lock(mGUIChannel->mutex);
       mGUIChannel->update.reset();
       mGUIChannel->state = {};
-      mGUIChannel->guiSleeping = mGUIChannel->displayProcessingCurrentUpdate = mGUIChannel->stop = false;
+      mGUIChannel->guiSleeping = mGUIChannel->displayProcessingCurrentUpdate = mGUIChannel->stop = mGUIChannel->displayWaitingForOptions = false;
+      mGUIChannel->optionsReadRevision = 0;
+      mDisplay->mUpdateGUIOptions = true;
       mGUIChannel->replyTimeout = std::chrono::milliseconds(mDisplay->cfg().guiReplyTimeout);
       mGUIChannel->maxUpdatesAhead = std::max<uint32_t>(mDisplay->cfg().guiMaxUpdatesAhead, 1); // 0 would block all updates
       mGUIChannel->windowName = DISPLAY_WINDOW_NAME;
+      setGUILayout(*mGUIChannel);
     }
     mGUI->start();
   } else {