createObjectPalette.h

Go to the documentation of this file.

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


#pragma once

#if !defined(Q_MOC_RUN)

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtUserInterfaceAssembler.h>
#include <vrvCoreQt/DtPage.h>
#include <vrfGuiCommonQt/treeWidget.h>
#include <vrfGuiCore/entityMapperKey.h>

#include <vrfGuiCoreQt/vrfGuiCoreQt.h>
#include <vrfGuiCoreQt/createObjectPaletteInterface.h>
#include <vrfGuiCoreQt/vrfSimulationMenuItem.h>
#include <vrfGuiCommonQt/keepAlivePage.h>
#include <vrfGuiCore/entityMapperKey.h>
#endif
#include <boost/signals2.hpp>

#include <QtWidgets/QWidget>
#include <QtWidgets/QToolButton>
#include <QtGui/QPixmap>
#include <QtGui/QImage>
#include <QtCore/QHash>
#include <QtWidgets/QTreeWidget>
#include <QtWidgets/QStyledItemDelegate>

class QTreeWidget;
class QVBoxLayout;
class QGridLayout;
class QSpacerItem;
class QComboBox;
class QCheckBox;
class QTextBrowser;
class QTreeWidgetItem;
class QLabel;
class QPushButton;
class QLineEdit;
class QAbstractButton;
class QFrame;
class QToolButton;
class QSplitter;

namespace makVrv
{
   class DtDe;
}

#define DtCreateObjectFromPaletteType "text/x-vrlCreateObjectFromPalette@Type"

namespace makVrf
{
   class DtCreateObjectPaletteLogic;
   class DtPaletteFilter;
   class DtCreateObjectPaletteTreeWidget;
   class DtCreateObjectPaletteTreeWidgetItem;
   struct DtCreateObjectPaletteItem;
   class DtTagSelectorWidget;
   class DtForceSelectionEntryWidget;
   class DtCountrySelectionEntryWidget;
   class DtSearchWidget;

   class DT_DLL_VRFGUICOREQT DtCreateObjectPalette
      : public DtKeepAlivePage
      , public DtCreateObjectPaletteInterface
   {
      Q_OBJECT

   public:
      DtCreateObjectPalette( makVrv::DtDe& de, QWidget* parent = 0, Qt::WindowFlags flags = 0, bool hasDeployedCountries = true);

      virtual ~DtCreateObjectPalette();

      virtual QIcon icon();

      virtual makVrv::DtQIconConfigurations qIconConfigurations() const;

      virtual QString title();

      virtual const std::string& pageClassName() const;

      static const std::string& thePageClassName();

      virtual void activate() {};
      virtual void deactivate() {};

      virtual void setSignalSelectionOnly(bool);

      virtual void setFavoritesSupported(bool);
      virtual bool favoritesSupported() const;

      virtual DtEntityMapperKey selectedObjectType() const;

      virtual std::vector<DtEntityMapperKey> selectedObjects() const;

      virtual void selectObject(const DtEntityMapperKey&);

      virtual void setDragCreateModeEnabled(bool);

      virtual bool showNonCreatableUnits() const;
      virtual void setShowNonCreatableUnits(bool);

      virtual bool hideTitle() const { return true; };

      virtual void addIgnore(const DtEntityType&);
      
      virtual void clearIgnore();

      virtual void setIgnore(const std::vector<DtEntityType>&);

      virtual const std::vector<DtEntityType>& ignoring() const;

      virtual void setShowFavoritesIcon(bool);
      virtual bool showFavoritesIcon() const;

      virtual void setHideCountries(const std::set<std::string>&);

      virtual bool keepAlive() const override;

      virtual void setHasDeployedCountries(bool);
      virtual bool hasDeployedCountries() const { return myHasDeployedCountries; };

      virtual void setShowCountsOnObjectList(bool);
      bool showCountsOnObjectList() const
      {
         return myShowCountsOnObjectList;
      }

  protected:
      void setupUi(QWidget* p, bool favoritesSupported);
      void createObjectCreationInformation();

      virtual void closeEvent(QCloseEvent*);
      virtual void showEvent(QShowEvent*);

      virtual void aboutToShow() override;

   public:
      virtual void clear();

      virtual void update();

      virtual QString currentForce() const;

      virtual int currentForceType() const;

      virtual int forceTypeAtIndex(int) const;

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

      virtual std::string currentDeployedCountry() const;

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

      virtual void initializeCountries();

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

      virtual void selectDeployedCountry(int);

      virtual int numForces() const;

      virtual int numCategories() const;

      virtual void addForce(const QString&, int, const QColor&, const std::string& countryCode, bool forceLayout = false);

      virtual QString force(int) const;

      virtual bool hasForce(int) const;

      virtual void setCategories(const DtTagSelectorWidget::Categories&);

      virtual bool hasCategory(const QString&) const;

      virtual void selectForce(const QString&);

      virtual void showForce(bool);

      virtual void enableForce(bool);

      virtual void selectForce(int);

      virtual bool isStickyCategory(const std::string&) const;

      virtual void setStickyCategories(const std::vector<std::string>&);

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

      virtual DtString topLevelCategory(int) const;

      virtual QTreeWidgetItem* itemFor(const DtCreateObjectPaletteItem& paletteItem, int force) const;

      virtual const std::vector<std::string>& stickyCategories() const;

      virtual void selectCategories(const std::vector<std::string>&);

      virtual void clearCreateList();

      virtual void sortItems();

      virtual void sizeColumns();

      virtual void addItem(const DtCreateObjectPaletteItem&, int force);

      virtual void addPaletteItem(const DtCreateObjectPaletteItem&);

      virtual void removePaletteItem(const DtEntityMapperKey& key, bool matchPattern = false);

      virtual void setEnabled(bool);

      void createFavoriteIcon();

      virtual void clearForces();
      virtual void clearDeployedCountries();
      virtual void clearCategories();

      virtual void initialize();

      virtual void addLocalPaletteFilter(const DtPaletteFilter&);
      virtual void removeLocalPaletteFilter(const DtPaletteFilter&);

      virtual QMenu* createRightClickMenu(DtCreateObjectPaletteTreeWidgetItem*);

      virtual void slot_onTagsChanged(const std::vector<std::string>&);

      virtual void setCategoriesFromCounts(const std::map<std::string, int>&, const std::set<std::string>&, int totalItems,
         const std::vector<std::string>& categoriesToResetTo = std::vector<std::string>());

      virtual void resetVisuals();

      virtual void loadCustomTags();
      virtual void fillInObjectCreationInformation(DtCreateObjectPaletteTreeWidgetItem*);

      virtual void slot_setTagFromObjectInformation(std::vector<std::string> tag);
      virtual QTreeWidgetItem* topLevelItemFor(const std::string&);

      virtual void resetCategoriesBasedOnVisibleItems();
      virtual void resetParentVisibility();

   protected slots:
      virtual void showInformationForItem(const QModelIndex&);
      virtual void onItemSelectionChanged();
      virtual void slot_onForceChanged();
      virtual void slot_onDeployedCountryChanged();
      virtual void slot_onItemPressed(QTreeWidgetItem*, QMouseEvent*, int);
      virtual void slot_onItemRightClickedOn(QTreeWidgetItem*, QMouseEvent*, int);
      virtual void filterItems();
      virtual void resetFilter();
      virtual void addToFavoritesRightClick();
      virtual void removeFromFavoritesRightClick();

   protected:
      bool myInitialized;
      makVrv::DtSignalConnectionManager myConnections;
      DtCreateObjectPaletteLogic* myLogic;
      std::map<std::string, QTreeWidgetItem*>   myItems;
      std::map<std::string, QTreeWidgetItem*>   myTopLevelItems;
      bool myFavoritesSupported;
      bool myHasDeployedCountries;
      bool myCloseEventSent;

      bool                             myInCreationProcess;
      bool myKeepSameInformation = false;

      bool myShowFavoritesIcon;
      QMenu* myRightClickMenu;
      bool myShowCountsOnObjectList = false;

   public:
      QVBoxLayout*                     myMainLayout;
      QWidget*                         myObjectSelection;
      QGridLayout*                     myGridLayout;
      DtTagSelectorWidget*             myTags;
      DtForceSelectionEntryWidget*     myForces;
      DtCreateObjectPaletteTreeWidget* myObjects;
      QImage                           myFavoriteOn;
      DtSearchWidget*                  mySearchWidget;
      DtCountrySelectionEntryWidget*   myUsedByCountry;

      QAbstractButton*                 myCurrentForceButtonSelected;
      QAbstractButton*                 myCurrentTopLevelButtonSelected;

      QSplitter*                       mySplitter;
      QWidget*                         myObjectCreationInformation;
      QVBoxLayout*                     myObjectInformationLayout;
      QLabel*                          myGuiLabel;
      QLabel*                          myObjectCreationPicture;
      QLabel*                          myObjectCreationDescription;
      DtTagSelectorWidget*             myObjectTags;
   };

   typedef makVrv::DtPageCreatorTemplate<DtCreateObjectPalette> 
      DtCreateObjectPalettePageCreator;

   class DT_DLL_VRFGUICOREQT DtCreateObjectPaletteTreeWidgetItem : public QTreeWidgetItem
   {
   public:
      DtCreateObjectPaletteTreeWidgetItem(makVrv::DtDe& de, const QImage* on = 0);

      virtual ~DtCreateObjectPaletteTreeWidgetItem();

      virtual void setFavoritesSupported(bool b);

      virtual void setPaletteItem(const QString& i);
      const QString& paletteItem() const
      {
         return myPaletteItem;
      }

      virtual void resetPixmap();

      virtual void setFavorite(bool b);
      bool favorite() const
      {
         return myFavorite;
      }

      virtual void setEntityMapperKey(const DtEntityMapperKey& k);
      const DtEntityMapperKey& entityMapperKey() const
      {
         return myEntityMapperKey;
      }

      DtEntityType entityType() const
      {
         return myEntityMapperKey;
      }

      virtual QVariant data(int iColumn, int iRole) const override;

   protected:
      virtual void updatePixmap();

   protected:
      QString myPaletteItem;
      DtEntityMapperKey myEntityMapperKey;
      makVrv::DtDe& myDe;
      bool myFavorite;
      const QImage* myFavoriteOn;
      QPixmap* myPixmapEnabled;
      QPixmap* myPixmapDisabled;
      bool myFavoritesSupported;
   };

   class DT_DLL_VRFGUICOREQT DtCreateObjectPaletteTreeWidget : public DtTreeWidget
   {
      Q_OBJECT

   public:
      DtCreateObjectPaletteTreeWidget(makVrv::DtDe& de, QWidget* p);
      virtual ~DtCreateObjectPaletteTreeWidget();

      virtual QSize sizeHint() const;

      bool favoritesSupported() const
      {
         return myFavoritesSupported;
      }

      virtual void setFavoritesSupported(bool b);
      virtual bool viewportEvent(QEvent *event) override;

   signals:
      void showInformationForItem(const QModelIndex&);

   protected:
      virtual QMimeData* mimeData(const QList<QTreeWidgetItem*> list) const;

   protected:
      bool myFavoritesSupported;
      QModelIndex myLastHoverIndex;
   };

   class DT_DLL_VRFGUICOREQT DtCreateObjectPaletteTreeWidgetCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      DtCreateObjectPaletteTreeWidgetCreator(makVrv::DtDe&);
      virtual ~DtCreateObjectPaletteTreeWidgetCreator();

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

      static void registerInstance(makVrv::DtDe& de, DtCreateObjectPaletteTreeWidgetCreator* instance);

      virtual DtCreateObjectPaletteTreeWidget* create(QWidget* parent);

   protected:
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUICOREQT DtCreateObjectPaletteTreeWidgetItemCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      DtCreateObjectPaletteTreeWidgetItemCreator(makVrv::DtDe&);

      virtual ~DtCreateObjectPaletteTreeWidgetItemCreator();

      virtual DtCreateObjectPaletteTreeWidgetItem* create(const QImage* on = 0);

      static DtCreateObjectPaletteTreeWidgetItemCreator& instance(makVrv::DtDe& de);
      static void registerInstance(makVrv::DtDe& de, DtCreateObjectPaletteTreeWidgetItemCreator*);

   protected:
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUICOREQT DtLoadObjectTagsMenuItem : public makVrv::DtMenuItem
   {
      Q_OBJECT
   public:
      //CTOR
      DtLoadObjectTagsMenuItem(makVrv::DtDe& de);

      //DTOR
      virtual ~DtLoadObjectTagsMenuItem();

      virtual QAction* createAction(makVrv::DtDe&, QWidget* parent);

   protected:

      virtual void on_triggered();

   protected:
      makVrv::DtDe&  myDe;
   };

   class DT_DLL_VRFGUICOREQT DtCreatePaletteTopLevelTreeWidgetItem : public DtThemedTreeWidgetItem
   {
   public:
      DtCreatePaletteTopLevelTreeWidgetItem(makVrv::DtDe& de);

      virtual QVariant data(int col, int role) const override;
      
      virtual void setTitle(const QString&);
      virtual void setObjectCount(int i);
      virtual void setShowObjectCount(bool b);
      bool showObjectCount() const
      {
         return myShowObjectCount;
      }

      virtual bool operator<(const QTreeWidgetItem&) const override;

   protected:
      int myObjectCount;
      bool myShowObjectCount;
      QString myTitle;
   };

   class DT_DLL_VRFGUICOREQT DtCreatePaletteTopLevelTreeWidgetItemCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      DtCreatePaletteTopLevelTreeWidgetItemCreator(makVrv::DtDe&);

      virtual ~DtCreatePaletteTopLevelTreeWidgetItemCreator();

      virtual DtCreatePaletteTopLevelTreeWidgetItem* create();

      static DtCreatePaletteTopLevelTreeWidgetItemCreator& instance(makVrv::DtDe& de);
      static void registerInstance(makVrv::DtDe& de, DtCreatePaletteTopLevelTreeWidgetItemCreator*);

   protected:
      makVrv::DtDe& myDe;
   };
}