entityCreatePalette.h

Go to the documentation of this file.

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



#pragma once

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

#include <vrfGuiCoreQt/vrfGuiCoreQt.h>
#include <vrfGuiCoreQt/entityCreatePaletteInterface.h>
#include <vrfGuiCore/entityMapperKey.h>

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

class QTreeWidget;
class QVBoxLayout;
class QGridLayout;
class QComboBox;
class QCheckBox;
class QTreeWidgetItem;
class QLabel;
class QPushButton;
class QLineEdit;
class QAbstractButton;
class QFrame;

namespace makVrv
{
   class DtDe;
}

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

namespace makVrf
{
   class DtEntityCreatePaletteLogic;
   class DtToolButtonWrapperWidget;
   class DtPaletteFilter;
   class DtEntityPaletteTreeWidget;
   class DtEntityCreatePaletteItem;
   class DtTagSelectorWidget;

   class DT_DLL_VRFGUICOREQT DtEntityCreatePalette
      : public makVrv::DtPage
      , public DtEntityCreatePaletteInterface
   {
      Q_OBJECT

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

      virtual ~DtEntityCreatePalette();

      virtual QIcon icon();

      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 void setCombinePalettes(bool combine);
      virtual bool combinePalettes() 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 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 layoutForces();

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

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

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

      virtual bool eventFilter(QObject* o, QEvent* e);

   public:
      virtual void clear();

      virtual void update();

      virtual QString currentForce() const;

      virtual int currentForceType() const;

      virtual int currentForceIndex() const;

      virtual int currentDeployedCountryIndex() const;

      virtual int forceTypeAtIndex(int) const;

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

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

      virtual QString currentDeployedCountry() const;

      virtual bool hasDeployedCountry(const QString&) const;

      virtual void insertDeployedCountry(const QString&, int);

      virtual bool initiallyVisible() const
      {
         return true;
      }

      virtual void insertDeployedCountryBefore(const QString&, const QString&);

      virtual void insertDeployedCountryAfter(const QString&, const QString&);

      virtual void addDeployedCountry(const QString&);

      virtual void selectDeployedCountry(const QString&);

      virtual void selectDeployedCountry(int);

      virtual int numForces() const;

      virtual int numCategories() const;

      virtual int numDeployedCountries() const;

      virtual void addForce(const QString&, int, const QColor&, 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 const std::vector<std::string>& stickyCategories() const;

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

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

      virtual void clearCreateList();

      virtual void setSortingEnabled(bool);

      virtual void sizeColumns();

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

      virtual void addPaletteItem(const DtEntityPaletteItem&);

      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(DtEntityCreatePaletteItem*);

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

   protected slots:
      virtual void onItemSelectionChanged();
      virtual void slot_onForceChanged();
      virtual void slot_onForceChangedByButton();
      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;
      DtEntityCreatePaletteLogic* myLogic;
      std::map<std::string, QTreeWidgetItem*>   myItems;
      bool myFavoritesSupported;
      bool myHasDeployedCountries;
      bool myCloseEventSent;

      bool                             myInCreationProcess;

      bool myShowFavoritesIcon;
      QMenu* myRightClickMenu;
      std::set<std::string> myAccessibleCategories;

   public:
      QVBoxLayout*                     myMainLayout;
      QGridLayout*                     myGridLayout;
      QLabel*                          myForceLabel;
      QLabel*                          myDeployedCountriesLabel;
      QComboBox*                       myDeployedCountries;
      DtTagSelectorWidget*             myTags;
      QComboBox*                       myForces;
      DtEntityPaletteTreeWidget*       myEntities;
      QImage                           myFavoriteOn;
      QImage                           myFavoriteOff;
      QLabel*                          mySearchLabel;
      QLineEdit*                       mySearch;
      QPushButton*                     myResetButton;

      QAbstractButton*                 myCurrentForceButtonSelected;
      QAbstractButton*                 myCurrentTopLevelButtonSelected;
      DtToolButtonWrapperWidget*       myForceContainer;
      bool                             myAllowCombineMode;
   };

   typedef makVrv::DtPageCreatorTemplate<DtEntityCreatePalette> 
      DtEntityPalettePageCreator;

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

      virtual ~DtEntityCreatePaletteItem();

      virtual void setFavoritesSupported(bool b);

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

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

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

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

   protected:
      virtual void updatePixmap();

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

   class DT_DLL_VRFGUICOREQT DtEntityPaletteTreeWidget : public DtTreeWidget
   {
   public:
      DtEntityPaletteTreeWidget(makVrv::DtDe& de, QWidget* p);
      virtual ~DtEntityPaletteTreeWidget();

      virtual QSize sizeHint() const;

      bool favoritesSupported() const
      {
         return myFavoritesSupported;
      }

      virtual void setFavoritesSupported(bool b);

      virtual void mousePressEvent(QMouseEvent *event);

      boost::signal<void (DtEntityMapperKey, bool)> signal_favoriteChanged;

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

   protected:
      bool myFavoritesSupported;
   };

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

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

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

      virtual DtEntityPaletteTreeWidget* create(QWidget* parent);

   protected:
      makVrv::DtDe& myDe;
   };

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

      virtual ~DtEntityCreatePaletteItemCreator();

      virtual DtEntityCreatePaletteItem* create(const QImage* on = 0, const QImage* off = 0);

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

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