entityCreatePaletteLogic.h

Go to the documentation of this file.

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

 
#pragma once

#include <vrfGuiCoreQt/vrfGuiCoreQt.h>
#include <vrfGuiCore/entityMapperKey.h>
#include <vrvCore/DtMenuPath.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <vector>
#include <set>

class DtSimulationAddress;
class QString;

namespace makVrv
{
   class DtDe;
}

class DtModelSetEntry;

namespace makVrf
{
   class DtVrfBackendState;

   class DtEntityCreatePaletteInterface;

   struct DtEntityPaletteItem
   {
      DtEntityPaletteItem() : myItemsToCreate(0) {};
      DtEntityPaletteItem(const DtEntityPaletteItem& orig) : myName(orig.myName), myMapperKey(orig.myMapperKey),
         myCategories(orig.myCategories), myForces(orig.myForces), myDeployedCountries(orig.myDeployedCountries),
         myDescription(orig.myDescription), myItemsToCreate(orig.myItemsToCreate) {};

      std::string       myName;
      DtEntityMapperKey myMapperKey;
      std::set<std::string> myCategories;
      std::vector<int>  myForces;
      std::set<std::string> myDeployedCountries;
      std::string myDescription;
      int myItemsToCreate;
   };

   typedef boost::shared_ptr<DtEntityPaletteItem> DtEntityPaletteItemHandle;

   class DT_DLL_VRFGUICOREQT DtPaletteFilter
   {
   public:
      DtPaletteFilter() {};
      DtPaletteFilter(const DtPaletteFilter&) {};
      virtual ~DtPaletteFilter() {};

      virtual bool shouldAddCreationItem(const DtEntityPaletteItem&, const std::set<std::string>& categories, const std::string& deployedCountry,
         int force) const = 0;

      virtual DtPaletteFilter* clone() const = 0;

      virtual bool operator==(const DtPaletteFilter&) const { return true; };
      virtual bool operator!=(const DtPaletteFilter& rhs) const { return !(*this == rhs); };
   };

   class DT_DLL_VRFGUICOREQT DtEntityTypePaletteFilter: public DtPaletteFilter
   {
   public:
      DtEntityTypePaletteFilter();
      DtEntityTypePaletteFilter(const DtEntityTypePaletteFilter&);
      virtual ~DtEntityTypePaletteFilter();

      virtual bool shouldAddCreationItem(const DtEntityPaletteItem&, const std::set<std::string>& categories, const std::string& deployedCountry,
         int force) const;

      virtual void addEntityType(const DtEntityType& type);

      virtual DtPaletteFilter* clone() const;
      virtual bool operator==(const DtPaletteFilter&) const;

   protected:
      std::vector<DtEntityType>  myEntityTypes;
   };

   class DT_DLL_VRFGUICOREQT DtEntityCreatePaletteLogic
   {

   public: 
      
      static DtEntityCreatePaletteLogic* create(makVrv::DtDe& de, 
         DtEntityCreatePaletteInterface* iFace );
         
      virtual ~DtEntityCreatePaletteLogic();

      virtual void createAndAddItem(const std::string& name,
        const DtEntityMapperKey& key,const std::set<std::string>& categories,const std::vector<int>& forces,
        const std::string& description = "", int itemsToCreate = 0);

      virtual void removeItem(const DtEntityMapperKey& key, bool matchesPattern = false);

      virtual void disconnectCreationSignal(bool disconnect);

      virtual void setFavorite(const DtEntityMapperKey&, bool);

      virtual void setCombinePalettes(bool combine);
      virtual bool combinePalettes() const;

      static void addGlobalPaletteFilter(const DtPaletteFilter&);
      static void removeGlobalPaletteFilter(const DtPaletteFilter&);

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

      bool showNonCreatableUnits() const { return myShowNonCreatableUnits; };
      virtual void setShowNonCreatableUnits(bool);

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

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

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

      virtual void slot_defaultIconListChanged();

   protected:
      DtEntityCreatePaletteLogic(makVrv::DtDe& de, DtEntityCreatePaletteInterface* iFace );

      virtual void slot_postInitialize(makVrv::DtDe& de);
      virtual void slot_modelSetChanged();
      virtual void slot_categoriesChanged(std::vector<std::string> newCategories);
      virtual void slot_deployedCountryChanged(std::string newCategory);
      virtual void slot_executeFilter();

      virtual void slot_selectedBackEndChanged(const DtSimulationAddress& old, const DtSimulationAddress& newaddr);
      virtual void slot_backendUpdated(const DtVrfBackendState&, int);

      virtual void slot_createObject(const DtEntityMapperKey&);

      virtual bool modelIsCreatable(DtModelSetEntry*) const;

      virtual bool ignoreType(const DtEntityType&) const;

      virtual bool forceCanBeCreatedByUser(int) const;

      virtual bool shouldAddCreationItem(const DtEntityPaletteItem&, const std::set<std::string>& categories, const std::string& deployedCountry, int force) const;
      virtual void enablePalette(int terrainPatchOffset = 0);
      virtual void slot_terrainPatchToBeDeleted();
      virtual void slot_terrainPatchAdded();
      virtual void slot_sessionStatusChanged();

      virtual void slot_forceChanged();

      virtual bool includeModelOnPage(DtModelSetEntry* model) const;

   protected:
      makVrv::DtDe& myDe;
      DtEntityCreatePaletteInterface* myInterface;
      typedef std::map<std::string, std::set<DtEntityPaletteItemHandle> > CategoriesMap;
      CategoriesMap myCategoriesMap;
      std::vector<DtEntityPaletteItemHandle> myItems;
      makVrv::DtMenuPath myOrderedPath;
      bool myAllowOverlays;

      static std::vector<DtPaletteFilter*> theGlobalPaletteFilters;
      std::vector<DtPaletteFilter*> myLocalPaletteFilters;
      std::map<int, std::string> myPotentialForces;
      makVrv::DtSignalConnectionManager myConnectionManager;
      std::vector<DtEntityType> myRemoveItems;
      bool myShowNonCreatableUnits;
      bool myAllowCombineMode;

      std::vector<DtEntityType> myToIgnore;
   };
}