simpleVariableWidget.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCoreQt/taskSetVariableWidget.h>

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

#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;

namespace makVrf
{
   class DtScriptedTaskEntityTypeDataWidget;

   class DT_DLL_VRFGUICOREQT DtSimpleVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT

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

      //DTOR
      virtual ~DtSimpleVariableWidget();

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

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

      virtual void setLabel(const QString&);

      virtual QString label() const;

      virtual QString text() const;

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

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

   public:
      QHBoxLayout* myLayout;
      QLabel* myLabel;
      QLineEdit* myValue;
   };

   class DT_DLL_VRFGUICOREQT DtSimpleSeparatorWidget : public DtSimpleVariableWidget
   {
      Q_OBJECT

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

      //DTOR
      virtual ~DtSimpleSeparatorWidget();

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

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

      virtual void setupFrom(const std::vector<makVrv::DtSimEntry*>& data)
      {
      }

      virtual void setRange(double, double)
      {
      }

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

      virtual void setupFromBoundVariable(const DtReaderWriter*)
      {
      }

      virtual bool guiElementOnly() const
      {
         return true;
      }

      virtual bool isValid() const
      {
         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("<vrfGuiCoreQt/simpleVariableWidget.h>").toUtf8().constData();
      }

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

   public:
      QFrame* mySeparator;
   };

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

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

      virtual bool isValid();

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

      virtual void setReadOnly(bool);

   public:
      QLabel* myDefaultValueLabel;
      QLineEdit* myDefaultValue;
      
      QLabel* myVariableDataLabel;
      QLineEdit* myVariableData;

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

   protected:
      bool myAllowVariableDataEntry;
   };

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

   protected:
      QIntValidator myValidator;
   };

   class DT_DLL_VRFGUICOREQT 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();

      virtual void setRange(double bottom, double top);

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

      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("<vrfGuiCoreQt/simpleVariableWidget.h>").toUtf8().constData();
      }

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

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

   public slots:
      virtual void setValue(int);

   protected:
      QIntValidator* myValidator;
   };

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

   protected:
      QDoubleValidator myValidator;
   };

   class DT_DLL_VRFGUICOREQT 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();

      virtual void setRange(double bottom, double top);

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

      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("<vrfGuiCoreQt/simpleVariableWidget.h>").toUtf8().constData();
      }

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

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

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

   protected:
      QDoubleValidator* myValidator;
   }; 

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

   class DT_DLL_VRFGUICOREQT 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();

      virtual void setRange(double bottom, double top);

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

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

      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("<vrfGuiCoreQt/simpleVariableWidget.h>").toUtf8().constData();
      }

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

   class DT_DLL_VRFGUICOREQT 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();

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

      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("<vrfGuiCoreQt/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_VRFGUICOREQT DtSimpleEntityTypeVariableWidgetMenuFactory : public QExtensionFactory
   {
      Q_OBJECT

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

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

   protected:
      makVrv::DtDe& myDe;
   };

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

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

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

      protected slots:
         virtual void editState();

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

   class DT_DLL_VRFGUICOREQT DtSimpleEntityTypesVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT

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

      //DTOR
      virtual ~DtSimpleEntityTypesVariableWidget();

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

      virtual void setLabel(const QString&);

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

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

      virtual void setToolTip(const QString&);

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

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

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

   protected:
      virtual void setupFrom(const std::vector<makVrv::DtSimEntry*>& data)
      {
      }

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

   class DT_DLL_VRFGUICOREQT DtSimpleComboVariableWidgetExtension : public DtTaskSetVariableWidgetExtensionInterface
   {
      Q_OBJECT

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

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

      virtual void setReadOnly(bool);

      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;
      QPushButton* myAdd;
      QPushButton* myDelete;
      QPushButton* myUpdate;
   };

   class DT_DLL_VRFGUICOREQT DtSimpleComboVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT

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

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

      //DTOR
      virtual ~DtSimpleComboVariableWidget();

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

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

      virtual void setVariableData(const QString&);

      virtual void setRange(double bottom, double top);

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

      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;

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

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

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

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

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

   protected:
      QStringList myValues;
      int myDefaultIndex;
   };

   class DT_DLL_VRFGUICOREQT DtSimpleImageComboVariableWidgetExtension : public DtSimpleComboVariableWidgetExtension
   {
      Q_OBJECT

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

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

      virtual void setReadOnly(bool);

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

   protected:
      virtual void onAdd();
      virtual void onUpdate();
      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&);

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

   class DT_DLL_VRFGUICOREQT 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();

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

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

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

      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("<vrfGuiCoreQt/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;
      virtual QPixmap imageFromPath(const std::string&) const;
      virtual std::string variableDataFromUiDesigner(const QDomElement& elem, const DtScriptedTaskVariableLayoutConverter& converter) const;
      virtual bool isValidItemToAddToCombo(const QString& s) const;

   protected:
      int myIconSize;
   };

   class DT_DLL_VRFGUICOREQT DtSimpleImageComboVariableWidgetMenuFactory : public QExtensionFactory
   {
      Q_OBJECT

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

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

   protected:
      makVrv::DtDe& myDe;
   };

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

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

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

      protected slots:
         virtual void editState();

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

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

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

      virtual void setReadOnly(bool);

   public:
      QLabel* myDefaultLabel;
      QComboBox* myValues;
   };

   class DT_DLL_VRFGUICOREQT DtSimpleCheckBoxVariableWidget : public DtTaskSetVariableWidget
   {
      Q_OBJECT

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

      //DTOR
      virtual ~DtSimpleCheckBoxVariableWidget();

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

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

      virtual void setRange(double bottom, double top);

      virtual bool checked() const;

      virtual void setChecked(bool checked);

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

      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("<vrfGuiCoreQt/simpleVariableWidget.h>").toUtf8().constData();
      }

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

   protected:
      virtual void widgetInitializedForDialog(DtScriptedTaskDialog*);

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

   public:
      QCheckBox* myValue;
   };

   class DT_DLL_VRFGUICOREQT DtSimpleSingleRadioButtonVariableWidgetExtension : public DtTaskSetVariableWidgetExtensionInterface
   {
      Q_OBJECT

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

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

      virtual void setReadOnly(bool);

   protected:
      bool myReadOnly;

   public:
      QCheckBox*  myIsDefault;
   };

   class DT_DLL_VRFGUICOREQT DtSimpleRadioButtonVariableWidgetExtension : public DtSimpleComboVariableWidgetExtension
   {
      Q_OBJECT

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

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

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

   protected:
      bool myReadOnly;

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

   class DT_DLL_VRFGUICOREQT 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();

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

      virtual void setVariableData(const QString&);

      virtual void setRange(double bottom, double top);

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

      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("<vrfGuiCoreQt/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;

      virtual void widgetInitializedForDialog(DtScriptedTaskDialog*);

      virtual void onButtonToggled(QAbstractButton*, bool);
      virtual void onButtonToggled(int, bool);

      virtual void changeToggleState();

   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_VRFGUICOREQT 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();

      virtual void setVariableData(const QString&);

      virtual void setRange(double bottom, double top);

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

      virtual void setupFromBoundVariable(const DtReaderWriter* variableName);

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

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

      virtual std::string scriptedTaskVariableName() const;

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

      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("<vrfGuiCoreQt/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&);

      virtual void setLabel(const QString&);

      virtual QString label() const;

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

      virtual void widgetInitializedForDialog(DtScriptedTaskDialog*);

   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<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;
}