ModelSettingsWidget.h

Go to the documentation of this file.

#pragma once
 
#include <QWidget>
#include <QComboBox>
#include <QLineEdit>
#include <QLabel>
#include <QPushButton>
#include <QVector>
#include <QString>
#include <QScrollArea>
#include <QCheckBox>
#include <QGroupBox>
#include <memory>
#include <QMetaType>
#include <memory>
#include "ModelManager.h"
 
namespace MCFG {
 
class ModelSettingsWidget : public QWidget {
    Q_OBJECT
 
public:
    explicit ModelSettingsWidget(ModelManager& manager,
                                          QWidget* parent = nullptr);
    ~ModelSettingsWidget() = default;
 
    void refreshModelList();
 
    bool setSelectedModel(const QString& modelName);
 
    QString selectedModel() const;
 
    QVector<uint> selectedClassIds() const;
 
    void setSelectedClassIds(const QVector<uint>& classIds);
 
signals:
    void modelChanged(const QString& modelName, bool isValid);
 
    void classSelectionChanged(const QVector<uint>& selectedClassIds);
 
    void modelConfigChanged();
 
    // Internal signals for communicating with ModelManager on worker thread
    void modelActivationRequested(const QString& modelName);
    void classSelectionRequested(const QString& modelName, uint classId, bool selected);
    void modelsRefreshRequested();
    void applyMeanStdRequested(const QString& modelName, bool apply);
    void normalizeTo01Requested(const QString& modelName, bool normalize);
    void inputAlignmentRequested(const QString& modelName, uint alignment);
 
private slots:
    // Slots to handle responses from ModelManager
    void onModelActivated(const QString& modelName, ModelManager::ModelState modelState, const QString& error);
    void onClassListUpdated(const QVector<ModelConfig::ClassInfo>& classes);
    void onModelsListUpdated(const QVector<ModelManager::ModelEntry>& models);
 
    // Slots to handle UI interactions
    void onModelIndexChanged(int index);
    void onClassCheckBoxToggled();
    void onInvertSelectionClicked();
    void onSearchTextChanged(const QString& text);
    void onApplyMeanStdToggled(bool checked);
    void onNormalizeTo01Toggled(bool checked);
    void onInputAlignmentChanged(const QString& text);
 
protected:
    bool eventFilter(QObject* watched, QEvent* event) override;
 
private:
    void updateModelDisplay();
 
    void updateClassList();
 
    void showModelError(ModelManager::ModelState state,
                       const QString& errorMessage);
 
    void setupUi();
 
    void setupManagerConnections();
 
    QString getResolutionHint(ModelManager::ModelState state) const;
 
    QString getStateString(ModelManager::ModelState state) const;
 
    void updateConfigurationSection();
 
    void checkConfigurationChanges();
 
    // UI Elements
    QComboBox* m_modelCombo = nullptr;
    QLabel* m_statusLabel = nullptr;
    QCheckBox* m_applyMeanStdCheckBox = nullptr;
    QCheckBox* m_normalizeTo01CheckBox = nullptr;
    QLineEdit* m_inputAlignmentEdit = nullptr;
    QLabel* m_meanStdDisplayLabel = nullptr;
    QLabel* m_configChangeWarningLabel = nullptr;
    QPushButton* m_configSectionToggleButton = nullptr;
    QWidget* m_configurationSection = nullptr;
    QGroupBox* m_configContentWidget = nullptr;
    QWidget* m_classContainer = nullptr;
    QWidget* m_errorContainer = nullptr;
    QLabel* m_errorMessageLabel = nullptr;
    QLabel* m_errorHintLabel = nullptr;
    QLineEdit* m_searchEdit = nullptr;
    QPushButton* m_invertButton = nullptr;
    QWidget* m_classGridWidget = nullptr;
    QScrollArea* m_classScrollArea = nullptr;
 
    // Data
    ModelManager& m_manager;
    QString m_currentModelName;
    QVector<QCheckBox*> m_classCheckBoxes;
    QVector<QWidget*> m_classContainers;
    QVector<uint> m_classIds;  // Maps checkbox index to class ID
    
    // Cache for model state (since we can't directly query manager from GUI thread)
    QVector<ModelManager::ModelEntry> m_cachedModels;
    QVector<ModelConfig::ClassInfo> m_cachedClasses;
    ModelManager::ModelState m_cachedModelState = ModelManager::ModelState::MissingConfig;
    QString m_cachedModelError;
    bool m_cachedApplyMeanStd = true;
    bool m_cachedNormalizeTo01 = true;
    uint m_cachedInputAlignment = 1;
    std::vector<float> m_cachedMean;
    std::vector<float> m_cachedStd;
    std::shared_ptr<ModelConfig> m_cachedCurrentConfig;
    
    // Original configuration values (for detecting changes)
    bool m_originalApplyMeanStd = true;
    bool m_originalNormalizeTo01 = true;
    uint m_originalInputAlignment = 1;
    
    bool m_blockSignals = false;
    bool m_configurationSectionExpanded = false;
};
 
} // namespace MCFG