simpleVariableWidget.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include <vrfGuiDataEntryWidgets/taskSetVariableWidget.h>
#include <makArchives/DtDisplayUnitsSettingsRecord.h>

#include <QtWidgets/QWidget>
#include <QtCore/QVariant>
#include <QtGui/QValidator>

#include <QtDesigner/QExtensionFactory>
#include <QtDesigner/QDesignerTaskMenuExtension>

class QLabel;
class QHBoxLayout;
class QLineEdit;
class QComboBox;
class QCheckBox;
class QRadioButton;
class QGridLayout;
class QPushButton;
class QFrame;
class QSpacerItem;
class QAbstractButton;
class QButtonGroup;
class QIntValidator;
class QToolButton;

namespace makVrf
{
   class DtScriptedTaskEntityTypeDataWidget;

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT

   public:
      DtSimpleVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleVariableWidget() override;

      virtual void setLabel(const std::string&) override;

      virtual void setDefaultValue(const std::string&) override;

      virtual void setLabel(const QString&) override;

      virtual QString label() const override;

      virtual QString text() const;

      virtual void setShowWarningLabel(bool b);
      virtual bool showWarningLabel() const
      {
         return myShowWarningLabel;
      }

      virtual void setEntryInvalid(bool b);
      virtual bool isValid() const override;

      virtual bool checkValidity(const QString&);

      boost::signals2::signal<void(bool)> signal_validityChanged;

   public slots:
      virtual void setText(const QString&);
      virtual void validateTextByEdit(const QString&);
      virtual void validateTextByChange(const QString&);

   signals:
      void textChanged(const QString&);
      void textEdited(const QString&);

   public:
      QHBoxLayout* myLayout;
      QHBoxLayout* myValueLayout;
      QLabel* myLabel;
      QLineEdit* myValue;
      QWidget* myValueCanvas;
      QLabel* myWarningLabel;

   protected:
      bool myShowWarningLabel = true;
      bool myEntryInvalid = false;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleSeparatorWidget : public DtSimpleVariableWidget
   {
      Q_OBJECT

   public:
      DtSimpleSeparatorWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleSeparatorWidget() override;

      virtual void setVariableData(const std::string&) override
      {
      }

      virtual void setDefaultValue(const std::string&) override
      {
      }

      virtual void setupFrom(const std::set<makVrv::DtUniqueID>& data) override
      {
      }

      virtual void setRange(double, double) override
      {
      }

      virtual DtReaderWriter* createBoundVariable(const std::string&) override {
         return 0;
      }

      virtual void setupFromBoundVariable(const DtReaderWriter*) override {
      }

      virtual bool guiElementOnly() const override {
         return true;
      }

      virtual bool isValid() const override {
         return true;
      }

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("Separator");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("separator").toUtf8().constData();
      }

   public:
      QFrame* mySeparator;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleVariableWidgetExtension : public DtTaskSetVariableWidgetExtensionInterface
   {
      Q_OBJECT
   public:
      DtSimpleVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleVariableWidgetExtension() override;

      virtual int setFrom(const DtScriptedTaskVariable&, QGridLayout* parentLayout, int startRow) override;
      virtual void setTo(DtScriptedTaskVariable&) const override;

      virtual bool isValid() override;

      virtual void setAllowVariableDataEntry(bool);
      bool allowVariableDataEntry() const
      {
         return myAllowVariableDataEntry;
      }

      virtual void setReadOnly(bool) override;

   public slots:

      virtual void processInitializeFromStatePropertyStateChange(int state);

   public:
      QLabel* myDefaultValueLabel;
      QLineEdit* myDefaultValue;
      QCheckBox* myInitializeFromStatePropertyEnabled;
      QLabel* myInitializeFromStatePropertyLabel;
      QLineEdit* myInitializeFromStateProperty;
      
      QLabel* myVariableDataLabel;
      QLineEdit* myVariableData;

      QLabel* myRangeBottomLabel;
      QLineEdit* myRangeBottom;
      QLabel* myRangeTopLabel;
      QLineEdit* myRangeTop;

   protected:
      bool myAllowVariableDataEntry;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleIntegerVariableWidgetExtension : public DtSimpleVariableWidgetExtension
   {
   public:
      DtSimpleIntegerVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleIntegerVariableWidgetExtension() override;

   protected:
      QIntValidator myValidator;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleIntegerVariableWidget : public DtSimpleVariableWidget
   {
      Q_OBJECT
      Q_PROPERTY(int rangeTop READ rangeTop WRITE setRangeTop)
      Q_PROPERTY(int rangeBottom READ rangeBottom WRITE setRangeBottom)
      Q_PROPERTY(int defaultValue READ defaultValue WRITE setDefaultValue)

   public:
      DtSimpleIntegerVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleIntegerVariableWidget() override;

      virtual void setRange(double bottom, double top) override;

      virtual void setDefaultValue(const std::string&) override;

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags = 0) const override;

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("Integer");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("integerValue").toUtf8().constData();
      }

      virtual void setDefaultValue(int);
      virtual int defaultValue() const;
      virtual int value() const;
      virtual bool checkValidity(const QString&) override;

   public slots:
      virtual void setValue(int);

   public:
      QIntValidator* myValidator;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleDoubleVariableWidgetExtension : public DtSimpleVariableWidgetExtension
   {
   public:
      DtSimpleDoubleVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleDoubleVariableWidgetExtension() override;

   protected:
      QDoubleValidator myValidator;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleDoubleVariableWidget : public DtSimpleVariableWidget
   {
      Q_OBJECT
      Q_PROPERTY(qreal rangeTop READ rangeTop WRITE setRangeTop)
      Q_PROPERTY(qreal rangeBottom READ rangeBottom WRITE setRangeBottom)
      Q_PROPERTY(qreal defaultValue READ defaultValue WRITE setDefaultValue)

   public:
      DtSimpleDoubleVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleDoubleVariableWidget() override;

      virtual void setRange(double bottom, double top) override;
      virtual void setDecimals(int);

      virtual void setDefaultValue(const std::string&) override;

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags = 0) const override;

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("Real");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("doubleValue").toUtf8().constData();
      }

      virtual void setDefaultValue(double);
      virtual double defaultValue() const;
      virtual double value() const;
      virtual bool checkValidity(const QString&) override;

   public slots:
      virtual void setValue(double);
      virtual void setValue(int);

      virtual void editingFinished();
   
   protected:
      virtual void updateDecimalsDisplay();

   public:
      QDoubleValidator* myValidator;
   }; 

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleStringVariableWidgetExtension : public DtSimpleVariableWidgetExtension
   {
   public:
      DtSimpleStringVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleStringVariableWidgetExtension() override;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleStringVariableWidget : public DtSimpleVariableWidget
   {
      Q_OBJECT
      Q_PROPERTY(QString defaultValue READ defaultValue WRITE setDefaultValue)

   public:
      DtSimpleStringVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleStringVariableWidget() override;

      virtual void setRange(double bottom, double top) override;

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual void setDefaultValue(const QString&);
      virtual QString defaultValue() const;
      virtual QString value() const;

      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags = 0) const override;

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("String");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("stringValue").toUtf8().constData();
      }
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleEntityTypeVariableWidget : public DtSimpleStringVariableWidget
   {
      Q_OBJECT
      Q_PROPERTY(QString defaultValue READ defaultValue WRITE setDefaultValue)

   public:
      DtSimpleEntityTypeVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleEntityTypeVariableWidget() override;

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual void setDefaultValue(const std::string& s) override;
      virtual void setDefaultValue(const QString& s) override;
      virtual QString defaultValue() const override;

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("String Entity Type");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("entityType").toUtf8().constData();
      }

      static void initializeForQtDesignerExtension(makVrv::DtDe&, QDesignerFormEditorInterface*);

   protected slots:
      virtual void onSelectEntityType();
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleEntityTypeVariableWidgetMenuFactory : public QExtensionFactory
   {
      Q_OBJECT

   public:
      explicit DtSimpleEntityTypeVariableWidgetMenuFactory(makVrv::DtDe&, QExtensionManager *parent = 0);

   protected:
      virtual QObject * createExtension(QObject* object, const QString& iid, QObject* parent) const override;

   protected:
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleEntityTypeVariableWidgetTaskMenu : public QObject, public QDesignerTaskMenuExtension
   {
      Q_OBJECT
      Q_INTERFACES(QDesignerTaskMenuExtension)

   public:
      explicit DtSimpleEntityTypeVariableWidgetTaskMenu(makVrv::DtDe&, DtSimpleEntityTypeVariableWidget* widget, QObject* parent);

      virtual QAction * preferredEditAction() const override;
      virtual QList<QAction *> taskActions() const override;

      protected slots:
         virtual void editState();

   protected:
      QAction *myEditStateAction;
      DtSimpleEntityTypeVariableWidget *myWidget;
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleEntityTypesVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT

   public:
      DtSimpleEntityTypesVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleEntityTypesVariableWidget() override;

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual void setDefaultValue(const std::string& s) override;

      virtual void setLabel(const QString&) override;

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("String List of Entity Types");
      }

      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags) const override;

      virtual void setToolTip(const QString&) override;

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("entityTypes").toUtf8().constData();
      }

   protected:
      virtual void setupFrom(const std::set<makVrv::DtUniqueID>& data) override
      {
      }

      virtual void setRange(double, double) override {};
   public:
      DtScriptedTaskEntityTypeDataWidget* myEntityTypes;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtFilenameVariableWidget : public DtSimpleStringVariableWidget
   {
      Q_OBJECT
         Q_PROPERTY(QString defaultValue READ defaultValue WRITE setDefaultValue)

   public:
      DtFilenameVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtFilenameVariableWidget() override;

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("String Filename");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("filename").toUtf8().constData();
      }

      protected slots:
      virtual void onBrowseFilename();
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleComboVariableWidgetExtension : public DtTaskSetVariableWidgetExtensionInterface
   {
      Q_OBJECT

   public:
      DtSimpleComboVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleComboVariableWidgetExtension() override;

      virtual int setFrom(const DtScriptedTaskVariable&, QGridLayout* parentLayout, int startRow) override;
      virtual void setTo(DtScriptedTaskVariable&) const override;

      virtual void setReadOnly(bool) override;

      virtual bool initialValueIsDefaultValue() const;

   protected slots:
      virtual void onAdd();
      virtual void onUpdate();
      virtual void onDelete();

   protected:
      virtual void addValues(const DtScriptedTaskVariable&);

   signals:
      void activated(int);

   public:
      QLabel* myLabel;
      QComboBox* myValues;
      QCheckBox* myInitializeFromStatePropertyEnabled;
      QLabel* myInitializeFromStatePropertyLabel;
      QLineEdit* myInitializeFromStateProperty;
      QToolButton* myAdd;
      QToolButton* myDelete;
      QToolButton* myUpdate;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleComboVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT

      Q_PROPERTY(QStringList values READ values WRITE setValues)
      Q_PROPERTY(int defaultIndex READ defaultIndex WRITE setDefaultIndex)
      Q_PROPERTY(int invalidIfSelected READ invalidIfSelected WRITE setInvalidIfSelected)

   public:
      DtSimpleComboVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleComboVariableWidget() override;

      virtual void setLabel(const QString&) override;
      virtual QString label() const override;

      virtual void setDefaultValue(const std::string&) override;

      virtual void setVariableData(const QString&) override;

      virtual void setRange(double bottom, double top) override;

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags = 0) const override;

      static makVrv::DtUnicode codeVariableType()
      {

         return makVrv::DtUnicode::tr("Integer (0 - choice limit)");
      }

      virtual int currentIndex() const;
      virtual void setCurrentIndex(int index);

      virtual void addItem(const QString&, const QVariant& data = QVariant());

      virtual QStringList values() const;
      virtual void setValues(const QStringList&);

      virtual void setDefaultIndex(int);
      virtual int defaultIndex() const;

      virtual void setInvalidIfSelected(int);
      virtual int invalidIfSelected() const;

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("comboValue").toUtf8().constData();
      }

      virtual bool isValid() const override;

   protected:
      virtual std::string variableDataFromUiDesigner(
         const QDomElement& elem, const DtScriptedTaskVariableLayoutConverter& converter) const override;
      virtual bool isValidItemToAddToCombo(const QString& s) const;

   public:
      QHBoxLayout* myLayout;
      QLabel* myLabel;
      QComboBox* myValue;
      QString myDefaultValue;

   protected:
      QStringList myValues;
      int myDefaultIndex;
      int myInvalidIfSelected;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleImageComboVariableWidgetExtension : public DtSimpleComboVariableWidgetExtension
   {
      Q_OBJECT

   public:
      DtSimpleImageComboVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleImageComboVariableWidgetExtension() override;

      virtual int setFrom(const DtScriptedTaskVariable&, QGridLayout* parentLayout, int startRow) override;
      virtual void setTo(DtScriptedTaskVariable&) const override;

      virtual void setReadOnly(bool) override;

      virtual void setValues(const QStringList& values);
      virtual QStringList values() const;

   protected:
      virtual void onAdd() override;
      virtual void onUpdate() override;
      virtual bool selectImageName(const std::string&, QString& outputName) const;

      virtual QPixmap imageFromPath(const std::string&) const;

   protected slots:
      virtual void iconSizeChanged();
      virtual void clearImageLocation();
      virtual void selectImageLocation();
      virtual void dlgImageLocationChanged();

   protected:
      virtual void addValues(const DtScriptedTaskVariable&) override;

   public:
      QLabel* myIconSizeLabel;
      QLineEdit* myIconSize;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleImageComboVariableWidget : public DtSimpleComboVariableWidget
   {
      Q_OBJECT

      Q_PROPERTY(int iconSize READ iconSize WRITE setIconSize)

   public:
      DtSimpleImageComboVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleImageComboVariableWidget() override;

      virtual void setVariableData(const std::string&) override;

      virtual void addItem(const QString&, const QVariant& data = QVariant()) override;

      virtual void setIconSize(int);
      virtual int iconSize() const;
      virtual void setValues(const QStringList& s) override;

      static void initializeForQtDesignerExtension(makVrv::DtDe&, QDesignerFormEditorInterface*);

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("Integer (0 - choice limit)");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("imageComboValue").toUtf8().constData();
      }

   protected:
      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags = 0) const override;
      virtual QPixmap imageFromPath(const std::string&) const;
      virtual std::string variableDataFromUiDesigner(
         const QDomElement& elem, const DtScriptedTaskVariableLayoutConverter& converter) const override;
      virtual bool isValidItemToAddToCombo(const QString& s) const override;

   protected:
      int myIconSize;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleImageComboVariableWidgetMenuFactory : public QExtensionFactory
   {
      Q_OBJECT

   public:
      explicit DtSimpleImageComboVariableWidgetMenuFactory(makVrv::DtDe&, QExtensionManager *parent = 0);

   protected:
      virtual QObject * createExtension(QObject* object, const QString& iid, QObject* parent) const override;

   protected:
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleImageComboVariableWidgetTaskMenu : public QObject, public QDesignerTaskMenuExtension
   {
      Q_OBJECT
      Q_INTERFACES(QDesignerTaskMenuExtension)

   public:
      explicit DtSimpleImageComboVariableWidgetTaskMenu(makVrv::DtDe&, DtSimpleImageComboVariableWidget* widget, QObject* parent);

      virtual QAction * preferredEditAction() const override;
      virtual QList<QAction *> taskActions() const override;

      protected slots:
         virtual void editState();

   protected:
      QAction *myEditStateAction;
      DtSimpleImageComboVariableWidget *myWidget;
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleCheckBoxVariableWidgetExtension : public DtTaskSetVariableWidgetExtensionInterface
   {
   public:
      DtSimpleCheckBoxVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleCheckBoxVariableWidgetExtension() override;

      virtual int setFrom(const DtScriptedTaskVariable&, QGridLayout* parentLayout, int startRow) override;
      virtual void setTo(DtScriptedTaskVariable&) const override;

      virtual void setReadOnly(bool) override;

   public:
      QLabel* myDefaultLabel;
      QComboBox* myValues;
      QCheckBox* myInitializeFromStatePropertyEnabled;
      QLabel* myInitializeFromStatePropertyLabel;
      QLineEdit* myInitializeFromStateProperty;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleCheckBoxVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT
      Q_PROPERTY(bool defaultValue READ defaultValue WRITE setDefaultValue)

   public:
      DtSimpleCheckBoxVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleCheckBoxVariableWidget() override;

      virtual void setLabel(const QString&) override;
      virtual QString label() const override;

      virtual void setDefaultValue(const std::string&) override;

      virtual void setRange(double bottom, double top) override;

      virtual bool checked() const;

      virtual void setChecked(bool checked);

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags = 0) const override;

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("Bool (on/off)");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("checkValue").toUtf8().constData();
      }

      virtual bool defaultValue() const;
      virtual void setDefaultValue(bool);

   protected:
      virtual void widgetInitializedForDialog(DtScriptedTaskDialog*, const std::set<makVrv::DtUniqueID>& data) override;

   signals:
      void toggled(bool);
      void clicked(bool);

   public:
      QCheckBox* myValue;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleSingleRadioButtonVariableWidgetExtension : public DtTaskSetVariableWidgetExtensionInterface
   {
      Q_OBJECT

   public:
      DtSimpleSingleRadioButtonVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleSingleRadioButtonVariableWidgetExtension() override;

      virtual int setFrom(const DtScriptedTaskVariable&, QGridLayout* parentLayout, int startRow) override;
      virtual void setTo(DtScriptedTaskVariable&) const override;

      virtual void setReadOnly(bool) override;

   protected:
      bool myReadOnly;

   public:
      QCheckBox*  myIsDefault;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleRadioButtonVariableWidgetExtension : public DtSimpleComboVariableWidgetExtension
   {
      Q_OBJECT

   public:
      DtSimpleRadioButtonVariableWidgetExtension(makVrv::DtDe&, QWidget* w, const Qt::WindowFlags& f = 0);
      virtual ~DtSimpleRadioButtonVariableWidgetExtension() override;

      virtual int setFrom(const DtScriptedTaskVariable&, QGridLayout* parentLayout, int startRow) override;
      virtual void setTo(DtScriptedTaskVariable&) const override;

      virtual void setReadOnly(bool) override;
   
   protected:
      virtual void onAdd() override;
      virtual void onDelete() override;

   protected:
      bool myReadOnly;

   public:
      QLabel* myDefaultIndexLabel;
      QLineEdit*  myDefault;
      QIntValidator* myValidator;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleRadioButtonVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT
      Q_PROPERTY(QStringList values READ values WRITE setValues)

   public:
      DtSimpleRadioButtonVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleRadioButtonVariableWidget() override;

      virtual void setDefaultValue(const std::string&) override;

      virtual void setVariableData(const QString&) override;

      virtual void setRange(double bottom, double top) override;

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags = 0) const override;

      virtual QStringList values() const;
      virtual void setValues(const QStringList&);

      virtual void setDefaultIndex(int);
      virtual int defaultIndex() const;

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("Integer (0 - choice limit)");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("radioValue").toUtf8().constData();
      }

   protected:
      virtual std::string variableDataFromUiDesigner(
         const QDomElement& elem, const DtScriptedTaskVariableLayoutConverter& converter) const override;

      virtual void widgetInitializedForDialog(DtScriptedTaskDialog*, const std::set<makVrv::DtUniqueID>& data) override;
      virtual void changeToggleState();

   protected slots:
      virtual void onButtonToggled(QAbstractButton*, bool);
      virtual void onButtonToggled(int, bool);

   signals:
      void buttonToggled(QAbstractButton*, bool);
      void buttonToggled(int, bool);

      void toggled(bool);

   protected:
      int myDefaultIndex;
      QStringList myValues;
      bool myIsToggled;

   public:
      std::vector<QRadioButton*> myRadioButtons;
      QVBoxLayout* myRadioButtonLayout;
      QButtonGroup* myButtonGroup;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtSimpleSingleRadioButtonVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT
      Q_PROPERTY(bool isDefault READ isDefault WRITE setIsDefault)
      Q_PROPERTY(QString buttonGroup READ buttonGroup WRITE setButtonGroup)

   public:
      DtSimpleSingleRadioButtonVariableWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0, const CreationFlags& cflags = NormalMode);

      //DTOR
      virtual ~DtSimpleSingleRadioButtonVariableWidget() override;

      virtual void setVariableData(const QString&) override;

      virtual void setRange(double bottom, double top) override;

      virtual DtReaderWriter* createBoundVariable(const std::string& variableName) override;

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName) override;

      virtual DtTaskSetVariableWidgetExtensionInterface* parameterContents(
         QWidget* parent, const Qt::WindowFlags& flags = 0) const override;

      virtual void setButtonGroup(const QString&);
      virtual QString buttonGroup() const;

      virtual std::string scriptedTaskVariableName() const override;

      virtual void setDefaultValue(const std::string&) override {
      }

      static makVrv::DtUnicode codeVariableType()
      {
         return makVrv::DtUnicode::tr("Integer (0 - choice limit)");
      }

      static std::string designerGroup()
      {
         return tr("VR-Forces Data Entry").toUtf8().constData();
      }

      static std::string headerFile()
      {
         return tr("<vrfGuiDataEntryWidgets/simpleVariableWidget.h>").toUtf8().constData();
      }

      static std::string variableName()
      {
         return tr("singleRadioValue").toUtf8().constData();
      }

      virtual bool isDefault() const;
      virtual void setIsDefault(bool);

      virtual void setLabel(const std::string&) override;

      virtual void setLabel(const QString&) override;

      virtual QString label() const override;

   protected:
      virtual std::string variableDataFromUiDesigner(
         const QDomElement& elem, const DtScriptedTaskVariableLayoutConverter& converter) const override;

      virtual void widgetInitializedForDialog(DtScriptedTaskDialog*, const std::set<makVrv::DtUniqueID>& data) override;

   signals:
      void toggled(bool);

   protected slots:
      virtual void buttonToggled(QAbstractButton*, bool);
      virtual void buttonToggled(int, bool);

   protected:
      bool myIsDefault;
      QString myButtonGroupName;

   public:
      QRadioButton* myRadioButton;
      QButtonGroup* myParentWidgetSharedButtonGroup;
   };

   typedef DtTaskSetVariableWidgetCreator<DtSimpleStringVariableWidget> DtSimpleStringVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtFilenameVariableWidget> DtFilenameVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleIntegerVariableWidget> DtSimpleIntegerVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleDoubleVariableWidget> DtSimpleDoubleVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleEntityTypeVariableWidget> DtSimpleEntityTypeVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleEntityTypesVariableWidget> DtSimpleEntityTypesVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleComboVariableWidget> DtSimpleComboVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleImageComboVariableWidget> DtSimpleImageComboVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleCheckBoxVariableWidget> DtSimpleCheckBoxVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleRadioButtonVariableWidget> DtSimpleRadioButtonVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleSingleRadioButtonVariableWidget> DtSimpleSingleRadioButtonVariableWidgetCreator;
   typedef DtTaskSetVariableWidgetCreator<DtSimpleSeparatorWidget> DtSimpleSeparatorWidgetCreator;

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtDisplayUnitSelectionWidget : public DtSimpleComboVariableWidget
   {
   public:
      DtDisplayUnitSelectionWidget(makVrv::DtDe& de, makArchives::DtDisplayUnitsSettingsRecord::DisplayUnitType, QWidget* parent);

      virtual int displayUnit() const;
      virtual void setDisplayUnit(int);
      virtual std::string displayUnitAsVariableData() const;
      virtual void setupFrom(std::string variableData);

   protected:
      makArchives::DtDisplayUnitsSettingsRecord::DisplayUnitType myUnitType;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtDisplayUnitSettingMenuFactory : public QExtensionFactory
   {
      Q_OBJECT

   public:
      explicit DtDisplayUnitSettingMenuFactory(makVrv::DtDe&, makArchives::DtDisplayUnitsSettingsRecord::DisplayUnitType, QExtensionManager *parent = 0);

   protected:
      virtual QObject * createExtension(QObject* object, const QString& iid, QObject* parent) const override;

   protected:
      makVrv::DtDe& myDe;
      makArchives::DtDisplayUnitsSettingsRecord::DisplayUnitType myUnitType;
   };

   class DT_DLL_VRFGUIDATAENTRYWIDGETS DtDisplayUnitSettingsMenu : public QObject, public QDesignerTaskMenuExtension
   {
      Q_OBJECT
      Q_INTERFACES(QDesignerTaskMenuExtension)

   public:
      explicit DtDisplayUnitSettingsMenu(makVrv::DtDe&, makArchives::DtDisplayUnitsSettingsRecord::DisplayUnitType, DtSimpleVariableWidget* widget, QObject* parent);

      virtual QAction * preferredEditAction() const override;
      virtual QList<QAction *> taskActions() const override;

      protected slots:
         virtual void editState();

   protected:
      QAction *myEditStateAction;
      DtSimpleVariableWidget *myWidget;
      makVrv::DtDe& myDe;
      makArchives::DtDisplayUnitsSettingsRecord::DisplayUnitType myUnitType;
   };
}