uiPropertiesTable.h

Go to the documentation of this file.

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


#pragma once

#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "simulationObjectEditorImpl/uiElement.h"
#include <readerWriter/rwInt.h>
#include <readerWriter/rwReal.h>
#include <readerWriter/rwString.h>
#include <readerWriter/rwProperties.h>

#include <QTableWidget>
#include <QHeaderView>
#include <QKeyEvent>
#include <QItemDelegate>
#include <QComboBox>

class DtPropertyInterface;
class DtUiTableWidgetItem;
class QTableWidgetItem;
class QHBoxLayout;
class QPushButton;
class QVBoxLayout;
class DtRwPropertiesList;
class DtRwPropertiesMap;
class QCheckBox;

class DtUiPropertiesTableWidget : public QTableWidget
{
public:
   DtUiPropertiesTableWidget(QWidget * parent = 0) : QTableWidget(parent) {}
   ~DtUiPropertiesTableWidget() {}

   virtual QSize sizeHint() const;
   virtual void accept();
};

class DT_DLL_simulationObjectEditorimpl DtUiTableWidgetItem : public QTableWidgetItem
{
public:
   DtUiTableWidgetItem() : myOriginalValue(0), myModifiedValue(0), myIsKey(false), myIsReadOnly(false), myOwnsValues(false), myIsPropertyValue(true) {};

   virtual ~DtUiTableWidgetItem() { if (myOwnsValues) { delete myOriginalValue; delete myModifiedValue; } };

   void setOwnsValues(bool b) { myOwnsValues = b; };
   void setOriginalValue(const DtReaderWriter* rw) { if (myOwnsValues) delete myOriginalValue; myOriginalValue = rw; };
   void setModifiedValue(const DtReaderWriter* rw) { if (myOwnsValues) delete myModifiedValue; myModifiedValue = rw; };
   void setIsPropertyValue(bool b) { myIsPropertyValue = b; };

   bool isInt() const { return dynamic_cast<const DtRwInt*>(myOriginalValue) != 0; };
   bool isReal() const { return dynamic_cast<const DtRwReal*>(myOriginalValue) != 0; };
   void setIsKey(bool b) { myIsKey = b; };
   bool isKey() const { return myIsKey; };

   virtual QVariant data(int role) const
   {
      if (role == Qt::BackgroundColorRole)
      {
         if (flags() & Qt::ItemIsEditable)
         {
            return QTableWidgetItem::data(role);
         }
         else
         {
            return QColor(Qt::lightGray);
         }
      }
      else if (role == Qt::FontRole)
      {
         QFont f = qvariant_cast<QFont>(QTableWidgetItem::data(Qt::FontRole)); 

         bool same = true;
         
         if (!myOriginalValue && myModifiedValue)
         {
            same = false;
         }
         else if (myIsKey)
         {
            same = (myOriginalValue->name() == myModifiedValue->name());
         }
         else if (myOriginalValue && myModifiedValue)
         {
            if (myIsPropertyValue)
            {
               same = DtRwProperties::propertyFactory()->compareReaderWriter(myOriginalValue, myModifiedValue);
            }
            else
            {
               same = DtRwProperties::factory()->compareReaderWriter(myOriginalValue, myModifiedValue);
            }
         }

         f.setBold(!same);

         return f;
      }

      return QTableWidgetItem::data(role);
   }

   void setReadOnly(bool b) { if (b) setFlags((Qt::ItemFlags)(flags() & ~Qt::ItemIsEditable)); else setFlags((Qt::ItemFlags)(flags() | Qt::ItemIsEditable)); };
   const DtReaderWriter* originalValue() const { return myOriginalValue; }
   const DtReaderWriter* modifiedValue() const { return myModifiedValue; }

protected:
   bool myIsKey;
   const DtReaderWriter* myOriginalValue;
   const DtReaderWriter* myModifiedValue;
   bool myIsReadOnly;
   bool myOwnsValues;
   bool myIsPropertyValue;
};

class DT_DLL_simulationObjectEditorimpl DtUiTableWidgetItemDelegate : public QItemDelegate
{
public:
   DtUiTableWidgetItemDelegate(QObject* p, bool b) : QItemDelegate(p), myRowsAsColumns(b), myTable(dynamic_cast<QTableWidget*>(p)) {};

protected:
   virtual QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option,
                        const QModelIndex &index) const;

protected:
   QTableWidget* myTable;
   QIntValidator myIntValidator;
   QDoubleValidator myDoubleValidator;
   bool myRowsAsColumns;
};   

class DT_DLL_simulationObjectEditorimpl DtUiTableWidgetComboBox : public QComboBox
{
public:
   DtUiTableWidgetComboBox(QWidget* w) : QComboBox(w) { };
   virtual ~DtUiTableWidgetComboBox() {};

   void setTableWidgetItem(DtUiTableWidgetItem* i) { myTableWidgetItem = i; };
   DtUiTableWidgetItem* tableWidgetItem() const { return myTableWidgetItem; };

protected:
   virtual void paintEvent(QPaintEvent *);

protected:
   DtUiTableWidgetItem* myTableWidgetItem;
};

class DT_DLL_simulationObjectEditorimpl DtUiPropertiesTable : public DtUiElement
{
   Q_OBJECT

public:
   DtUiPropertiesTable(makVrv::DtDe&);

   virtual ~DtUiPropertiesTable();

   static DtUiElement* CreatorFunction(makVrv::DtDe&);

   virtual void setEnabled(bool);

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

   virtual void createControls(QWidget* widget);
   virtual void processUiEvent(const DtUiElementEvent& e);

   virtual void columnHeadersFrom(const DtPropertyInterface* prototype, QStringList& columns) const;
   virtual QString columnTitleFor(const QString&) const;
   virtual void fillInAndMapRwItemToTableItems(int row, int& colStart, DtReaderWriter*);

   virtual const DtReaderWriter* readerWriterFromPrototype(const DtReaderWriter* prototype, int col) const;

   virtual void flatten(const DtReaderWriter* prototype, std::vector<const DtReaderWriter*>& list) const;
   virtual void tableItemCreated(DtUiTableWidgetItem*, int row, int col);

   virtual void itemRemoved(DtUiTableWidgetItem*);
   virtual void updateEnableStatus();

   virtual QStringList convertToTitles(const QStringList& cols) const;

   virtual bool canHavePrimary() const;

   virtual void addPrimaryCheckBox(int row, int col);

   virtual DtString currentPrimary() const;
   virtual DtString keyFor(int col) const;
   virtual void updatePrimaryData();
   virtual void setCurrentPrimary(const DtString&, bool, bool updateData = true);
   virtual void elementChanged();
   virtual void clearPrimaryData();
   virtual void setPrimaryDataFrom(int);
   virtual QCheckBox* primaryCheckBox(int) const;

   virtual void setEquipmentAvailable(const DtString&, bool);

   virtual void addPrimaryEntry(DtReaderWriter* rw);

   virtual void fixRowTitle(int row = - 1);
   virtual bool initForPossibleMultiMap(DtRwPropertiesMap*);
   virtual QString getContainedName(const QString& = "") const;

   virtual void fillInTableFromSelection(DtReaderWriter*);
   virtual void addContainedItems(DtReaderWriter*);
   virtual void updateAddButton();

   virtual void removeRow(int);
   virtual void decorateElement();

protected slots:
   virtual void itemChanged(QTableWidgetItem*);
   virtual void addRow();
   virtual void removeRow();
   virtual void itemSelectionChanged();
   virtual void valueComboChanged();
   virtual void primaryChanged();
   virtual void addNewContainerItem();
   virtual void editContainerItem();
   virtual void removeContainerItem();
   virtual void containedItemSelected();

public:
   DtUiPropertiesTableWidget* myTableWidget;
   QPushButton* myAdd;
   QPushButton* myRemove;
   QVBoxLayout* myLayout;
   QHBoxLayout* myButtonLayout;
   bool myInitializing;

   QWidget* myContainerCanvas;
   QPushButton* myAddContainer;
   QPushButton* myRemoveContainer;
   QPushButton* myEditContainer;
   QLabel* myContainerLabel;
   QHBoxLayout* myContainerLayout;
   QComboBox* myContainedItems;
   QString myContainedLabel;
   QLabel* myMapLabel;

protected:
   typedef std::map<DtUiTableWidgetItem*, DtReaderWriter*> TableWidgetItemMap;
   TableWidgetItemMap myTableWidgetItemMap;
   DtRwPropertiesList* myPropertyTable;
   bool myRowsAsColumns;
   bool myIsMultiMap;
   DtPropertyInterface* myPrototype;
   DtRwPropertiesList* myModifiedVariable;
   DtReaderWriter* mySelectedVariable;
};