simulationObjectEditorList.h

Go to the documentation of this file.

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


#pragma once

#if !defined(Q_MOC_RUN)
#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "simulationObjectEditorImpl/simulationModelSetLoader.h"
#include "simulationObjectEditorImpl/displayDefinitionWidget.h"
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfGuiCommonQt/treeWidget.h>
#include <vrfExtProtocol/objectType.h>
#include "vrfutil/rwForces.h"
#include <vrvUtil/DtVirtualBaseClass.h>
#endif

#include <QtCore/QHash>
#include <QtGui/QImage>
#include <QtCore/QMap>
#include <QtCore/QDir>
#include <QtCore/QString>
#include <QtCore/QVariant>
#include <QtWidgets/QMessageBox>
#include <QtWidgets/QStyledItemDelegate>

#include <boost/function.hpp>

#include <set>

class QToolButton;

namespace makVrf
{
   class DtEntityMapperKey;
   class DtCountrySelectionEntryWidget;
   class DtSearchWidget;
}

class DtVrfSubObjectParameterList;
class DtFilename;
class DtAddObjectToHierarchy;
class DtList;
class QComboBox;
class QDir;
class DtEntityPaletteFilter;
class DtRwNLengthStringVector;
class DtModelSetEntry;
class QLabel;
class DtUiElementEvent;
class QPushButton;
class QToolButton;
class QCheckBox;
class QLineEdit;
class DtSimulationObjectGroupModelSetEntry;
class DtSimulationObjectEditorTagSelectorWidget;
class QGridLayout;
class QSplitter;

enum DtSimulationObjectEditorListRoles
{
   DtModelRole = Qt::UserRole,
   DtGlobalForcesRole = Qt::UserRole + 1,
   DescriptionRole = Qt::UserRole + 2,
   CategoriesRole = Qt::UserRole + 3,
   VisibilityRole = Qt::UserRole + 4,
   RankRole = Qt::UserRole + 5,
   TopLevelItemRole = Qt::UserRole + 6,
   ToolTipAddition = Qt::UserRole + 7
};

class DtSimulationObjectEditorList;

typedef boost::function<bool (const DtModelSetEntry*, bool& showWarningIcon)> DtEntityFilterFunction;

class DT_DLL_simulationObjectEditorimpl DtEntityPaletteFilter
{
public:
   DtEntityPaletteFilter(makVrv::DtDe&);
   DtEntityPaletteFilter(const DtEntityPaletteFilter&);
   virtual bool isValid(const DtModelSetEntry*, bool& failedUserFilter);

   void setCategories(const std::vector<std::string>&);
   void setUsedByCountry(const std::string&, const std::string& countryName);
   void setFilterOnForces(const DtRwForces&);

   virtual void ignoreObjectType(const DtObjectType&);

   virtual void clearIgnoreObjectTypes() { myIgnoreObjectTypes.clear(); };

   virtual void removeIgnoreObjectType(const DtObjectType&);

   virtual DtEntityPaletteFilter* clone() const { return new DtEntityPaletteFilter(*this); };

   virtual void addFilterFunction(DtEntityFilterFunction f) { myFilterFunctions.push_back(f); };

protected:
   std::vector<DtEntityFilterFunction> myFilterFunctions;
   std::set<std::string> myCategories;
   std::string myUsedByCountry;
   std::string myCountryName;
   DtRwForces myFilterOnForces;
   makVrv::DtDe& myDe;

   std::set<DtString> myIgnoreObjectTypes;
};

class DT_DLL_simulationObjectEditorimpl DtEntityPaletteItem : public QTreeWidgetItem
{
public:
   DtEntityPaletteItem(makVrv::DtDe& de);
   virtual QVariant data(int column, int role) const;

   virtual DtModelSetEntry* proxyModel() const;
   virtual QList<QVariant> proxyForces() const;

   void setPaletteParent(DtSimulationObjectEditorList* p) { myPaletteParent = p; };
   QString forcePixmapKey(DtModelSetEntry*, const QList<QVariant>&) const;
   bool isInMasterSMS() const;

   virtual bool operator<(const QTreeWidgetItem & other ) const;
   virtual void clearVisuals();

   virtual void setShowWarning(bool);
   bool showWarning() const
   {
      return myShowWarning;
   }

   virtual void setWarning(const QString&);
   const QString& warning() const
   {
      return myWarning;
   }

protected:
   virtual QImage getPixmap(const DtObjectType& o, int force) const;
   virtual void createGrayscaleForcePixmap() const;

protected:
   DtSimulationObjectEditorList* myPaletteParent;
   mutable QString myForcePixmapKey;
   mutable QImage myForcePixmap;
   mutable QImage myGrayscaleForcePixmap;
   makVrv::DtDe& myDe;
   bool myShowWarning;
   QString myWarning;
   QImage* myWarningIcon;
};

class DT_DLL_simulationObjectEditorimpl DtSimulationObjectEditorListItemDelegate : public QStyledItemDelegate
{
public:
   DtSimulationObjectEditorListItemDelegate(QWidget* parent) : QStyledItemDelegate(parent) {};
   virtual ~DtSimulationObjectEditorListItemDelegate() {};

protected:
   virtual void paint(QPainter *painter,
                          const QStyleOptionViewItem &option,
                          const QModelIndex &index) const;
};

class DT_DLL_simulationObjectEditorimpl DtSimulationObjectEditorList : public QWidget
{
   Q_OBJECT
   
public:   

   DtSimulationObjectEditorList(makVrv::DtDe&, QWidget*);
   
   virtual ~DtSimulationObjectEditorList();

   virtual void init();

   bool hasSelection() const;
   virtual void clear();
   virtual std::set<makVrf::DtEntityMapperKey> getSelectedInformation() const;
   virtual std::set<makVrf::DtEntityMapperKey> getRevertableKeys() const;
   virtual void getSelectedInformation(DtObjectType& key) const;
   virtual void getInformation(QTreeWidgetItem*, makVrf::DtEntityMapperKey& key) const;
   virtual void getInformation(QTreeWidgetItem*, DtObjectType& key) const;
   virtual std::vector<DtEntityPaletteItem*> itemsFor(const DtEntityType& t) const;

   virtual bool canRevertExisting() const;
   virtual bool canMakeTemplate() const;

   virtual bool addNewData(const std::vector<DtSimulationModelSetLoader::EntityData*>&);

   virtual bool canDeleteExisting(bool any = false) const;
   virtual bool selectedIsInMasterSMS() const;
   virtual bool selectedParentIsInMasterSMS() const;
   virtual bool parentIsUnit() const;

   virtual bool canAddSubordinateToSelected() const;

   virtual void getCategorySelections(DtRwForces&, DtRwNLengthStringVector&);
   virtual bool hasCategory(const QString&) const;

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

   virtual std::vector<std::string> selectedCategories() const;

   virtual QString textFilter() const;
   virtual void setTextFilter(const QString&);

   virtual DtObjectType selectedObjectType() const;
   virtual std::vector<DtObjectType> selectedObjectTypes() const;
   virtual QTreeWidgetItem* selectedItem() const;
   virtual DtModelSetEntry* selectedModel() const;
   virtual void setSelected(const QString&, bool forceReselect = true);
   virtual void setSelected(DtModelSetEntry*, bool forceReselect = true);
   virtual void selectPath(const QString& path);
   virtual DtModelSetEntry* modelFor(QTreeWidgetItem*) const;
   virtual int selectedItemsCount() const;
   virtual bool selectedIsPartOfSimulationObjectGroup() const;
   virtual bool itemIsPartOfSimulationObjectGroup(QTreeWidgetItem*) const;
   virtual void addFilterFunction(DtEntityFilterFunction f);
   virtual void addAllItems();
   virtual QList<QTreeWidgetItem*> findItems(const QString& text, int column = 0) const;
   virtual void updateUsedByCountries();

   virtual void ignoreObjectType(const DtObjectType&);

   virtual void removeIgnoreObjectType(const DtObjectType&);
   virtual void clearIgnoreObjectTypes();

   virtual void selectUncategorized();
   virtual void selectCategory(const QString&);
   virtual void selectUsedByCountry(const std::string&);
   virtual QColor outlineColor() const;

   QTreeWidget* entityList();

   static DtSimulationObjectEditorList* create(QWidget* parent = NULL);
   virtual void setRightClickEnabled(bool b);
   bool rightClickEnabled() const;

   virtual void setShowWarningForFilteredItems(bool b);
   bool showWarningForFilteredItems() const;

   virtual QStringList selectedNames() const;
   virtual void selectNames(const QStringList&);

   QTreeWidgetItem* currentlyDisplaying() const;

   virtual void setFilterOnForces(const DtRwForces& forces);
   const DtRwForces& filterOnForces() const;

   virtual void changeModel(DtModelSetEntry* oldModel, DtModelSetEntry* newModel);

   virtual bool selectModel(DtModelSetEntry* m, bool clear = true);

   virtual bool checkSMSValid(QTreeWidgetItem*) const;

   virtual QString selectedUsedByCountry() const;
   virtual std::string selectedCountryCode() const;
   virtual QString selectedPath() const;

   virtual makVrf::DtTreeWidget* createEntitiesList(QWidget* p);

   virtual void setShowIncluded(bool);
   bool showIncluded() const
   {
      return myShowIncluded;
   }

   virtual void setShowAllTags(bool);
   bool showAllTags() const
   {
      return myShowAllTags;
   }

   static DtObjectType stringToType(const QString&);

   virtual void hierarchyChanged(const DtUiElementEvent& e);
   virtual void hierarchyChanged(const DtObjectType& obj);

   const QList<QVariant>& allForces() const;

   virtual void disableItemsThatHaveThisAsAChild(const DtObjectType&);
   virtual void enableAllItems();

   virtual bool itemContains(const DtVrfSubObjectParameterList&, const DtObjectType&) const;
   virtual void addObjectToHierarchy(const DtObjectType&, QTreeWidgetItem*, int index = -1);

   bool executingFilter() const;
   virtual QSize sizeHint() const;
   virtual QSize minimumSizeHint() const;

public:
   virtual void removeFromHierarchy();
   virtual void moveUp();
   virtual void moveDown();
   virtual void replaceInHierarchy();
   virtual void addNewSubordinate();
   virtual void addNewSubordinateFromExisting();
   virtual void addToHierarchy();
   virtual void addSubordinatesFromPalette();
   virtual void opdEntryAdded(DtModelSetEntry*, bool select = false);

public slots:
   virtual void fillInList();
   virtual void deleteExisting();
   virtual void revertExisting();
   virtual void executeFilter();
   virtual void redisplayListIcons();
   virtual void executeTextFilter();
   virtual void selectionChanged();
   virtual void copyListContentsToClipboard();

protected slots:
   virtual void resetTextFilter();
   virtual void exitAddSubordinatesFromPalette();
   virtual void itemRightClicked(QTreeWidgetItem*, QMouseEvent*);
   virtual void itemExpanded(QTreeWidgetItem*);
   virtual void addObjectToHierarchy(const DtObjectType&);

protected:
   virtual DtEntityPaletteItem* addItem(DtModelSetEntry*, bool attachToRootNode = true);
   virtual void resetParentVisibility();
   virtual void moveInHierarchy(int iFrom, int iTo, QTreeWidgetItem* parent);
   virtual void replaceObjectInHierarchy(const DtObjectType& t, QTreeWidgetItem* toReplace);

   virtual void loadSubordinatesFor(QTreeWidgetItem*, const DtVrfSubObjectParameterList&);
   virtual void loadSimulationObjectGroup(QTreeWidgetItem* parent, DtSimulationObjectGroupModelSetEntry*);

   struct LoadInformation
   {
      LoadInformation(DtModelSetEntry* model, bool sw = false, const QString& w = "") : mse(model), showWarning(sw), warning(w) {};
      LoadInformation() : mse(0), showWarning(false) {};
      LoadInformation(const LoadInformation& orig) : mse(orig.mse), showWarning(orig.showWarning), warning(orig.warning) {};

      DtModelSetEntry* mse;
      bool showWarning;
      QString warning;
   };

   virtual void attachItemsToParent(QTreeWidgetItem* parent, const std::vector<LoadInformation>& toLoad);
   virtual void slot_processUIEvent(const DtUiElementEvent& e);

   virtual void revertChanged(const makVrf::DtEntityMapperKey&);
   virtual void revertChanged(DtModelSetEntry*);
   virtual void addModelEntry(DtModelSetEntry*);
   virtual DtEntityPaletteFilter* createFilter();
   virtual DtEntityPaletteItem* createPaletteItem();
   virtual DtEntityPaletteItem* createPaletteItem(DtModelSetEntry*);
   virtual void createForcesList();
   virtual void preloadModelSet();
   virtual QTreeWidgetItem* topLevelItemFor(const std::string&);

   virtual void disableInvalidItems();

   virtual void createTreeWidgetItemsFor(const std::vector<LoadInformation>&, QVector<QTreeWidgetItem*>& items, bool attachToRootNode = true);
   virtual void slot_entityEntryAboutToBeRemoved(DtSimulationModelSetLoader::EntityData*);
   virtual void slot_entityEntryAdded(DtSimulationModelSetLoader::EntityData*);
   virtual void hideAllObjectsByObjectType(QTreeWidgetItem*, DtSimulationModelSetLoader::EntityData*);
   virtual bool showAllObjectsByObjectType(QTreeWidgetItem*, DtSimulationModelSetLoader::EntityData*);
   virtual void runHealthCheck();
   virtual void updateHealthResults();
   virtual void removeFromItems(QTreeWidgetItem*);

signals:
   void itemDoubleClicked(QTreeWidgetItem*, int);
   void healthCheckResults(const QString&);

public:
   boost::signals2::signal<void ()> signal_itemSelectionChanged;
   boost::signals2::signal<void ()> signal_itemStatusChanged;
   boost::signals2::signal<void (const QVector<QTreeWidgetItem*>&)> signal_itemsAdded;

public:
   makVrf::DtTreeWidget*   myEntities;
   DtSimulationObjectEditorTagSelectorWidget* myTags;
   makVrf::DtCountrySelectionEntryWidget* myUsedByCountry;
   DtEntityPaletteFilter* myFilter;
   DtDisplayWidget* displayWidget;
   QList<QVariant> myForces;
   DtRwForces   myFilterOnForces;
   bool           myRightClickEnabled;
   DtAddObjectToHierarchy* myAddToHierarchyDialog;
   DtModelSetEntry*     mySelectedModel;
   QTreeWidgetItem* myNextAddIsTo;
   std::vector<QTreeWidgetItem*> myItemsToGrab;
   QTreeWidgetItem* myGrabbing;
   QTreeWidgetItem* myCurrentlySelectedBeforeGrab;

   makVrf::DtSearchWidget* mySearchWidget;

   QSplitter* mySplitter;
   QWidget* myControlsWidget;

protected:
   std::set<DtString> myTopLevelTags;
   std::map<std::string, QTreeWidgetItem*>   myTopLevelItems;
   DtObjectType myDisableIfContains;
   bool myDisableIfContainsObject;
   bool myInFreeFormAddMode;
   QTreeWidgetItem* myCurrentlyDisplaying;
   bool myExecutingFilter;
   std::map<DtString, bool> myExpandedStates;
   std::map<DtModelSetEntry*, std::vector<DtEntityPaletteItem*>> myItems;
   DtObjectType mySelectObjectTypeIfAvailable;
   bool myShowIncluded;
   bool myShowAllTags;
   bool myShowWarningForFilteredItems;

   makVrv::DtDe& myDe;
   makVrv::DtSignalConnectionManager myConnections;
   makVrv::DtSignalConnectionManager myEntryConnections;
};

class DT_DLL_simulationObjectEditorimpl DtSimulationObjectEditorListTreeWidget : public makVrf::DtTreeWidget
{
   Q_OBJECT
   Q_PROPERTY(QColor OutlineColor MEMBER myOutlineColor USER true)

public:
   DtSimulationObjectEditorListTreeWidget(makVrv::DtDe&,QWidget*);
   virtual ~DtSimulationObjectEditorListTreeWidget();

   void setBlockSelectionByKeypad(bool b)
   {
      myBlockSelectionByKeypad = b;
   }

   bool blockSelectionByKeypad() const
   {
      return myBlockSelectionByKeypad;
   }

   virtual void keyPressEvent(QKeyEvent*);
   virtual void focusOutEvent(QFocusEvent* e);

   void setListParent(DtSimulationObjectEditorList* p) { myListParent = p; };
   DtSimulationObjectEditorList* listParent() const { return myListParent; };

   const QColor& outlineColor() const
   {
      return myOutlineColor;
   }

protected:

   virtual QSize sizeHint() const;
   virtual QSize minimumSizeHint() const;

   virtual QMimeData* mimeData(const QList<QTreeWidgetItem*> list) const;
   virtual QStringList mimeTypes() const;
   virtual void dragEnterEvent(QDragEnterEvent *d);
   virtual void dragMoveEvent(QDragMoveEvent *d);
   virtual void dropEvent(QDropEvent* d);

protected:
   bool myBlockSelectionByKeypad;
   DtSimulationObjectEditorList* myListParent;
   QColor myOutlineColor;
};

inline void DtSimulationObjectEditorList::setRightClickEnabled(bool b)
{
   myRightClickEnabled = b;
}

inline bool DtSimulationObjectEditorList::rightClickEnabled() const
{
   return myRightClickEnabled;
}

inline bool DtSimulationObjectEditorList::hasSelection() const
{
   return (myEntities && (myEntities->selectedItems().count() != 0));
}

inline QTreeWidget* DtSimulationObjectEditorList::entityList()
{
   return myEntities;
}

inline const DtRwForces& DtSimulationObjectEditorList::filterOnForces() const
{
   return myFilterOnForces;
}

inline const QList<QVariant>& DtSimulationObjectEditorList::allForces() const
{
   return myForces;
}

inline QTreeWidgetItem* DtSimulationObjectEditorList::currentlyDisplaying() const
{
   return myCurrentlyDisplaying;
}

inline bool DtSimulationObjectEditorList::executingFilter() const
{
   return myExecutingFilter;
}

class DT_DLL_simulationObjectEditorimpl DtSimulationObjectEditorListCreator : public makVrv::DtVirtualBaseClass
{
public:
   DtSimulationObjectEditorListCreator(makVrv::DtDe&);

   virtual ~DtSimulationObjectEditorListCreator();

   static DtSimulationObjectEditorListCreator& instance(makVrv::DtDe&);

   static void registerInstance(makVrv::DtDe&, DtSimulationObjectEditorListCreator*);

   virtual DtSimulationObjectEditorList* create(QWidget* parent);

protected:
   makVrv::DtDe& myDe;
};