uiElement.h

Go to the documentation of this file.

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


#pragma once

#if !defined(Q_MOC_RUN)
#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "simulationObjectEditorImpl/unitConversions.h"
#include <readerWriter/readerWriter.h>
#include <readerWriter/rwString.h>
#include "simulationObjectEditorImpl/rwVariableBindingsList.h"
#include <readerWriter/rwBoolean.h>
#include <readerWriter/rwInt.h>
#include <readerWriter/noArgumentCallbackList.h>
#include <vrfExtProtocol/objectType.h>
#endif

#include <QtCore/QObject>
#include <QtCore/QVariant>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QBoxLayout>
#include <boost/function.hpp>
#include <boost/bind.hpp>

class QWidget;
class DtUiForParameter;
class DtVrfObjectParameters;
class DtReaderWriterRegistryData;
class DtSystemParameterData;
class DtModelSetEntry;
class DtUiElement;
class QWidget;
class QCheckBox;
class QDoubleSpinBox;
class QLabel;
class DtComponentSystemDefinition;

typedef boost::function<void (DtUiElement*)> DtElementChangedCallbackFcn;


class DT_DLL_simulationObjectEditorimpl DtUiElementEvent
{
public:
   enum DtUiElementEventTypes
   {
      DtUiElementTypeUnknown = 0,
      DtUiElementItemExpand   = 1,
      DtUiElementItemCollapse = 2,
      DtUiElementHierarchySelectionChanged = 3,
      DtUiElementAddedToHierarchy = 5,
      DtUiElementRemovedFromHierarchy = 6,
      DtUiElementMovedInHierarchy = 7,
      DtUiElementReplacedInHierarchy = 8,
      DtUiElementForceChanged = 9,
      DtUiElementPositionModified = 12,
      DtUiElementPositionDestroyed = 13,
      DtUiBoundingVolumeModified = 14,
      DtUiCanvasInitialized = 15,
      DtUiCreateController = 19,
      DtUiCleanup = 20,
      DtUiElementHierarchyChanged = 21,
      DtUiEnterEditMode = 22,
      DtUiLeaveEditMode = 23,
      DtUiSupportPointsModified = 24,
      DtUiPreSaveEvent = 25,
      DtSystemsRemoved = 26,
      DtUiSuportPointsCalculated = 27,
      DtUiBoundingVolumeCalculated = 28,
      DtUiCalculateBoundingVolume = 29,
      DtUiCalculateSupportPoints = 30,
      DtUiMarkingChanged = 31,
      DtUiChangeTrailEffect = 32,
      DtUiStartSimulation = 33,
      DtUiSetSpeedPercentage = 34,
      DtUiSystemParameterDataChanged = 35,
      DtUiAffectGui = 36,
      DtUiDetonationPowerChanged = 37,
      DtUiDamageTableChanged = 38,
      DtUiHitTableChanged = 39,
      DtUiElementDataChanged = 40,
      DtUiAmmunitionChanged = 41,
      DtUiHealthFix = 42,
      DtUiIconListsChanged = 43,
      DtUiSystemEvent = 44,
      DtArtPartUpdated = 45,
      DtArtPartAssociated = 46,
      DtUiAccept = 47
   };

public:
   DtUiElementEvent(DtUiElement* owner= 0, DtUiElementEventTypes type = DtUiElementTypeUnknown) : myOwner(owner), myType(type) {};
   DtUiElementEvent(const DtUiElementEvent& orig) : myOwner(orig.myOwner), myType(orig.myType), myValue(orig.myValue) {};

   DtUiElementEvent& operator=(const DtUiElementEvent& rhs) { myOwner = rhs.myOwner; myValue = rhs.myValue; myType = rhs.myType; return *this; };

   DtUiElement* owner() const { return myOwner; };
   DtUiElementEventTypes type() const { return myType; };
   void setType(DtUiElementEventTypes t) { myType = t; };
   void setValue(const QVariant& val) { myValue = val; };
   const QVariant& value() const { return myValue; };

protected:
   DtUiElement*            myOwner;
   QVariant                myValue;
   DtUiElementEventTypes   myType;
};


class DT_DLL_simulationObjectEditorimpl DtUiElement : public QObject
{
   Q_OBJECT

public:
   typedef boost::function<DtUiElement* (makVrv::DtDe&)> CreatorFunction;
   typedef std::map<std::string, CreatorFunction> UiElementFactoryMap;

   DtUiElement
   (
      makVrv::DtDe&
   );

   virtual ~DtUiElement();

   virtual bool blockSignals(bool);

   virtual void init(QWidget* widget, QWidget* label, DtReaderWriter* originalData, DtReaderWriter* backupData,
      DtElementChangedCallbackFcn = boost::bind(&DtUiElement::theNullFunction, _1));

   virtual void init(QWidget* widget, QWidget* label, const std::vector<DtReaderWriter*>& originalData,
      const std::vector<DtReaderWriter*>& backupData,
      DtElementChangedCallbackFcn = boost::bind(&DtUiElement::theNullFunction, _1));

   virtual void init(QWidget* widget, QWidget* label, const DtObjectType&, const DtString& platformType,
      DtElementChangedCallbackFcn = boost::bind(&DtUiElement::theNullFunction, _1));

   virtual DtString displayUnits() const;
   virtual void setDisplayUnits(const DtString& units);

   virtual void setLabelText(const QString&);

   virtual DtString sourceUnits() const;
   virtual void setSourceUnits(const DtString& units);

   virtual void setFromSystemParameterData(const DtSystemParameterData* data, const DtComponentSystemDefinition*);

   virtual void objectParametersModified() {};

   virtual void connectedTo(QObject*);

   virtual void processUiEvent(const DtUiElementEvent&) {};

   virtual void setModelModified(DtModelSetEntry*);

   virtual DtString uniqueName() const;

   virtual bool supportsSystems() const;

   virtual const DtString& platformType() const;

   virtual void setPlatformType(const DtString&);

   virtual void setObjectTypes(const std::vector<DtObjectType>&);

   virtual void aboutToShow();

   const std::vector<DtReaderWriter*>& values() const { return myValues; };
   const std::vector<DtReaderWriter*>& backupValues() const { return myBackupValues; };

public:
   static void registerUiTypes();
   static DtUiElement* createUiElement(makVrv::DtDe&, const DtString& type);
   static bool hasCreator(const DtString&);

   static void theNullFunction(DtUiElement*);

public:
   virtual bool isModified() const;

   virtual bool isValid() const;

   virtual void decorateElement();

   virtual void setFromParameters(DtReaderWriter* parentRw);

   virtual void setFromParameters(const std::vector<DtComponentSystemDefinition*>&);

   virtual void setFromParameters(const std::vector<DtReaderWriter*>& parentRw);

   virtual bool restoreFromBackup();

   QHBoxLayout* findLayoutThatHas(QWidget* w, QBoxLayout* layout);

   QBoxLayout* findUsableLayoutFor(QWidget* w);

   static UiElementFactoryMap& elementFactory()
   {
      return theFactory;
   }

   const std::vector<DtObjectType>& objectTypes() const
   {
      return myObjectTypes;
   }

   const std::vector<DtComponentSystemDefinition*>& systems() const
   {
      return mySystems;
   }

   virtual void sendEvent(const DtUiElementEvent&);

   virtual bool allValuesTheSame() const;

   static QString mixedText();
   static void setMixedText(const QString&);

   virtual bool isMixedValue() const;

   virtual void setEnabled(bool);
   virtual bool enabled() const;

   virtual void setControllingCheckBox(QCheckBox*);
   QCheckBox* controllingCheckBox()
   {
      return myControllingCheckBox;
   }

   virtual void populateParentValues(std::string elementName);

public slots:
      virtual void toggleDisplayed(bool display);

protected slots:
   virtual void elementChanged();

   virtual void enableIfChecked();

   virtual void disableIfChecked();

signals:
   void uiEvent(const DtUiElementEvent&);
   void changed();

protected:

   virtual double sourceToDisplayUnits(double) const;
   virtual double displayToSourceUnits(double) const;

   virtual QString units() const;

   virtual void updateLabelTitle();

   virtual QString labelTitle() const;

   virtual void createControls(QWidget* parent);

public:
   QWidget* myWidget;
   QWidget* myLabel;

protected:
   static UiElementFactoryMap theFactory;

   DtString  myDisplayUnits;
   DtString  mySourceUnits;

   std::vector<DtReaderWriter*> myValues;
   std::vector<DtReaderWriter*> myBackupValues;

   //cache the value from the parent file
   DtReaderWriter* myParentValue;
   
   bool myIsNew;
   DtElementChangedCallbackFcn myElementChangedCallbackFunction;
   DtUnit mySource;
   DtUnit myDestination;
   makVrv::DtDe& myDe;

   DtString myPlatformType;
   std::vector<DtObjectType> myObjectTypes;
   std::vector<DtComponentSystemDefinition*> mySystems;

   const DtComponentSystemDefinition* mySystemDefinition;

   bool myEnabled;

   std::vector<QObject*> myConnectedTo;
   int myUniqueId;
   QCheckBox* myControllingCheckBox;

   QPushButton* myRevertToParentButton;

};