add progress indication to the tick textfield, improve appearance

Author: bhaller

QtSLiM/QtSLiMExtras.cpp

@@ -42,6 +42,7 @@
 #include <cmath>
 
 #include "QtSLiMPreferences.h"
+#include "QtSLiMAppDelegate.h"
 
 #include "eidos_value.h"
 
@@ -208,8 +209,18 @@ void RGBForSelectionCoeff(double value, float *colorRed, float *colorGreen, floa
 
 // A subclass of QLineEdit that selects all its text when it receives keyboard focus
 // thanks to https://stackoverflow.com/a/51807268/2752221
-QtSLiMGenerationLineEdit::QtSLiMGenerationLineEdit(const QString &contents, QWidget *p_parent) : QLineEdit(contents, p_parent) { }
-QtSLiMGenerationLineEdit::QtSLiMGenerationLineEdit(QWidget *p_parent) : QLineEdit(p_parent) { }
+QtSLiMGenerationLineEdit::QtSLiMGenerationLineEdit(const QString &contents, QWidget *p_parent) : QLineEdit(contents, p_parent)
+{
+    connect(qtSLiMAppDelegate, &QtSLiMAppDelegate::applicationPaletteChanged, this, [this]() { _ReconfigureAppearance(); });
+    _ReconfigureAppearance();
+}
+
+QtSLiMGenerationLineEdit::QtSLiMGenerationLineEdit(QWidget *p_parent) : QLineEdit(p_parent)
+{
+    connect(qtSLiMAppDelegate, &QtSLiMAppDelegate::applicationPaletteChanged, this, [this]() { _ReconfigureAppearance(); });
+    _ReconfigureAppearance();
+}
+
 QtSLiMGenerationLineEdit::~QtSLiMGenerationLineEdit() {}
 
 void QtSLiMGenerationLineEdit::focusInEvent(QFocusEvent *p_event)
@@ -222,6 +233,103 @@ void QtSLiMGenerationLineEdit::focusInEvent(QFocusEvent *p_event)
     QTimer::singleShot(0, this, &QLineEdit::selectAll);
 }
 
+void QtSLiMGenerationLineEdit::setProgress(double p_progress)
+{
+    double newProgress = std::min(std::max(p_progress, 0.0), 1.0);
+    
+    if (newProgress != progress)
+    {
+        progress = newProgress;
+        update();
+    }
+}
+
+void QtSLiMGenerationLineEdit::_ReconfigureAppearance()
+{
+    // Eight states, based on three binary flags; but two states never happen in practice
+    bool darkMode = QtSLiMInDarkMode();
+    bool enabled = isEnabled();
+    
+    if (darkMode)
+    {
+        if (enabled)
+        {
+            if (dimmed)
+                setStyleSheet("color: red;  background-color: black");                  // doesn't happen
+            else
+                setStyleSheet("color: rgb(255, 255, 255);  background-color: black");   // not playing
+        }
+        else
+        {
+            if (dimmed)
+                setStyleSheet("color: rgb(40, 40, 40);  background-color: black");      // error state (not normally visible)
+            else
+                setStyleSheet("color: rgb(170, 170, 170);  background-color: black");   // playing
+        }
+    }
+    else
+    {
+        if (enabled)
+        {
+            if (dimmed)
+                setStyleSheet("color: red;  background-color: white");                  // doesn't happen
+            else
+                setStyleSheet("color: rgb(0, 0, 0);  background-color: white");         // not playing
+        }
+        else
+        {
+            if (dimmed)
+                setStyleSheet("color: rgb(192, 192, 192);  background-color: white");   // error state (not normally visible)
+            else
+                setStyleSheet("color: rgb(120, 120, 120);  background-color: white");   // playing
+        }
+    }
+    
+    update();
+}
+
+void QtSLiMGenerationLineEdit::setAppearance(bool p_enabled, bool p_dimmed)
+{
+    if ((isEnabled() != p_enabled) || (dimmed != p_dimmed))
+    {
+        setEnabled(p_enabled);
+        dimmed = p_dimmed;
+        
+        _ReconfigureAppearance();
+    }
+}
+
+void QtSLiMGenerationLineEdit::paintEvent(QPaintEvent *p_paintEvent)
+{
+    // first let super draw
+    QLineEdit::paintEvent(p_paintEvent);
+    
+    // then overlay a progress bar on top, if requested, and if we are not disabled & dimmed (error state)
+    bool enabled = isEnabled();
+    
+    if (!enabled && dimmed)
+        return;
+    
+    if (progress > 0.0)
+    {
+        bool darkMode = QtSLiMInDarkMode();
+        QPainter painter(this);
+        QRect bounds = rect().adjusted(2, 2, -2, -2);
+        
+        bounds.setWidth(round(bounds.width() * progress));
+        
+        if (darkMode) {
+            // lighten the black background to a dark green; text is unaffected since it's light
+            painter.setCompositionMode(QPainter::CompositionMode_Lighten);
+            painter.fillRect(bounds, QColor(0, 120, 0));
+        } else {
+            // darken the white background to a light green; text is unaffected since it's dark
+            painter.setCompositionMode(QPainter::CompositionMode_Darken);
+            painter.fillRect(bounds, QColor(180, 255, 180));
+        }
+    }
+}
+
 void ColorizePropertySignature(const EidosPropertySignature *property_signature, double pointSize, QTextCursor lineCursor)
 {
     //

QtSLiM/QtSLiMExtras.h

@@ -62,6 +62,8 @@ QString QtSLiMImagePath(QString baseName, bool highlighted);
 
 
 // A subclass of QLineEdit that selects all its text when it receives keyboard focus
+// It also supports showing a "progress bar" under its text, and it has a modified
+// appearance that can be disabled but still show fairly dark text for readability
 class QtSLiMGenerationLineEdit : public QLineEdit
 {
     Q_OBJECT
@@ -71,13 +73,25 @@ class QtSLiMGenerationLineEdit : public QLineEdit
     QtSLiMGenerationLineEdit(QWidget *p_parent = nullptr);
     virtual	~QtSLiMGenerationLineEdit() override;
 
+    // can optionally display "progress" in the background of the lineedit
+    void setProgress(double p_progress);
+    
+    // set its appearance/behavior; do not use setEnabled(), use this!
+    void setAppearance(bool p_enabled, bool p_dimmed);
+    
 protected:
     virtual void focusInEvent(QFocusEvent *p_event) override;
+    virtual void paintEvent(QPaintEvent *p_paintEvent) override;
 
 private:
     QtSLiMGenerationLineEdit() = delete;
     QtSLiMGenerationLineEdit(const QtSLiMGenerationLineEdit&) = delete;
     QtSLiMGenerationLineEdit& operator=(const QtSLiMGenerationLineEdit&) = delete;
+    
+    void _ReconfigureAppearance(void);
+    
+    double progress = 0.0;
+    bool dimmed = false;
 };
 
 void ColorizePropertySignature(const EidosPropertySignature *property_signature, double pointSize, QTextCursor lineCursor);

QtSLiM/QtSLiMWindow.cpp

@@ -298,8 +298,13 @@ void QtSLiMWindow::init(void)
     connect(this, &QtSLiMWindow::controllerChangeCountChanged, this, [this]() { updateRecycleButtonIcon(false); });
 
     // Ensure that the tick lineedit does not have the initial keyboard focus and has no selection; hard to do!
+    // BCH 5 August 2022: this code is no longer working, the tick lineedit still has initial focus, sigh; I added
+    // the call to ui->scriptTextEdit->setFocus() and that seems to do it, not sure why I didn't do that before;
+    // but since this seems to be fragile, I'm going to leave *both* approaches in the code here, maybe which
+    // approach works depends on the Qt version or the platform or something.  Forward in all directions!
     ui->tickLineEdit->setFocusPolicy(Qt::FocusPolicy::NoFocus);
     QTimer::singleShot(0, [this]() { ui->tickLineEdit->setFocusPolicy(Qt::FocusPolicy::StrongFocus); });
+    ui->scriptTextEdit->setFocus();
 
     // watch for a change to light mode / dark mode, to customize display of the play speed slider for example
     connect(qtSLiMAppDelegate, &QtSLiMAppDelegate::applicationPaletteChanged, this, &QtSLiMWindow::applicationPaletteChanged);
@@ -2040,11 +2045,25 @@ void QtSLiMWindow::updateTickCounter(void)
          ui->cycleLineEdit->setText(QString::number(displaySpecies->Cycle()));
 
     if (!community)
+    {
         ui->tickLineEdit->setText("");
+        ui->tickLineEdit->setProgress(0.0);
+    }
     else if (community->Tick() == 0)
+    {
         ui->tickLineEdit->setText("initialize()");
+        ui->tickLineEdit->setProgress(0.0);
+    }
     else
-        ui->tickLineEdit->setText(QString::number(community->Tick()));
+    {
+        slim_tick_t tick = community->Tick();
+        slim_tick_t lastTick = community->EstimatedLastTick();
+        
+        double progress = (lastTick > 0) ? (tick / (double)lastTick) : 0.0;
+        
+        ui->tickLineEdit->setText(QString::number(tick));
+        ui->tickLineEdit->setProgress(progress);
+    }
 }
 
 void QtSLiMWindow::updateSpeciesBar(void)
@@ -2480,9 +2499,25 @@ void QtSLiMWindow::updateUIEnabling(void)
     ui->recycleButton->setEnabled(!continuousPlayOn_);
 
     ui->playSpeedSlider->setEnabled(!invalidSimulation_);
-    ui->tickLineEdit->setEnabled(!reachedSimulationEnd_ && !continuousPlayOn_);
-    ui->cycleLineEdit->setEnabled(!reachedSimulationEnd_ && !continuousPlayOn_);
-
+    
+    if (invalidSimulation_)
+    {
+        // when an error occurs, we want these textfields to have a dimmed/disabled appearance
+        ui->tickLineEdit->setAppearance(/* enabled */ false, /* dimmed */ true);
+        ui->cycleLineEdit->setAppearance(/* enabled */ false, /* dimmed */ true);
+    }
+    else
+    {
+        // otherwise, we want an enabled _appearance_ at all times, but we have to disable them
+        // to prevent editing during play; so we set the text color to prevent it from dimming
+        // note that the cycle lineedit is always disabled, but follows the appearance of the tick lineedit;
+        // the "editable but dimmed" visual appearance is actually a little different so hopefully this is clear
+        bool editingAllowed = (!reachedSimulationEnd_ && !continuousPlayOn_);
+        
+        ui->tickLineEdit->setAppearance(/* enabled */ editingAllowed, /* dimmed */ false);
+        ui->cycleLineEdit->setAppearance(/* enabled */ false, /* dimmed */ false);
+    }
+    
     ui->toggleDrawerButton->setEnabled(true);
 
     ui->clearDebugButton->setEnabled(true);

QtSLiM/QtSLiMWindow.ui

@@ -517,7 +517,7 @@ QSlider::handle:horizontal:disabled {
              </widget>
             </item>
             <item>
-             <widget class="QLineEdit" name="cycleLineEdit">
+             <widget class="QtSLiMGenerationLineEdit" name="cycleLineEdit">
               <property name="maximumSize">
                <size>
                 <width>100</width>