selectionGroupManager.h

Go to the documentation of this file.

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

#pragma once

#include <vrvUtil/signalslib.h>
#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/vrfStateViewCollectionManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtElementAttributes.h>
#include <vrvCore/DtElementData.h>
#include <vrvCore/DtUniqueID.h>
#include <vrfGuiCore/vrfSelectionFilters.h>
#include <vrvCore/DtKeyMapManager.h>
#include <vrvCore/DtStateView.h>
#include <vrvCore/DtEntityState.h>
#include <vrfutil/rwUUID.h>

#include <map>
#include <set>

#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>

#include <vlutil/vlSmartPointers.h>

namespace makVrv
{
   class DtDe;
}

class DtSimMessage;

namespace makVrf
{
   const makVrv::DtKeyMapManager::FunctionCategory DtSelectionGroupFunctionCategory =
      (makVrv::DtKeyMapManager::FunctionCategory)(makVrv::DtKeyMapManager::UserDefined + 52);

   class DT_DLL_VRFGUICORE DtSelectionGroupManager : public makVrv::DtVirtualBaseClass
   {
   public:
      typedef std::set<DtUUID> GroupItems;
      typedef std::map<std::string, GroupItems> SelectionGroups;
      
   public:
      DtSelectionGroupManager(makVrv::DtDe& de);

      virtual ~DtSelectionGroupManager();

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

      virtual void createSelectionGroup(const std::string&, bool signal = true);

      virtual void createSelectionGroupFromCurrentSelection(const std::string& groupName, bool select = false);

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

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

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

      virtual void renameSelectionGroup(const std::string& from, const std::string& to);

      virtual void addItemToSelectionGroup(const std::string&, const DtUUID&, bool signal = true);

      virtual bool atLeastOneItemNotInSelectionGroup(const std::string&, const GroupItems& names) const;
      virtual bool atLeastOneItemNotInSelectionGroup(const std::string&, const std::vector<DtUUID>& names) const;

      virtual bool anyItemsInSelectionGroup(const std::string&, const GroupItems& names) const;
      virtual bool anyItemsInSelectionGroup(const std::string&, const std::vector<DtUUID>& names) const;

      virtual void addItemsToSelectionGroup(const std::string&, const GroupItems& names, bool signal = true);
      virtual void addItemsToSelectionGroup(const std::string&, const std::vector<DtUUID>& names, bool signal = true);

      virtual bool itemInAnySelectionGroup(const DtUUID&) const;

      virtual void removeItemFromSelectionGroup(const std::string&, const DtUUID&);

      virtual void removeItemsFromSelectionGroup(const std::string&, const GroupItems& names);
      virtual void removeItemsFromSelectionGroup(const std::string&, const std::vector<DtUUID>& names);

      virtual const SelectionGroups& selectionGroups() const;

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

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

      virtual void removeAll();

      virtual GroupItems itemsInSelectionGroup(const std::string&) const;

      virtual bool itemIsInSelectionGroup(const std::string& group, const DtUUID&) const;

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

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

      virtual void processCreateSelectionGroup(DtSimMessage*);

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

      virtual void allScenarioObjectsDiscovered();

   public:
      boost::signal<void (std::string)> signal_selectionGroupAdded;

      boost::signal<void (std::string, std::string)> signal_selectionGroupRenamed;

      boost::signal<void (std::string)> signal_selectionGroupRemoved;

      boost::signal<void (std::string)> signal_selectionGroupCleared;

      boost::signal<void (std::string, GroupItems)> signal_itemsAddedToSelectionGroup;

      boost::signal<void (std::string, GroupItems)> signal_itemsRemovedFromSelectionGroup;

      boost::signal<void (DtUUID)> signal_itemRemovedFromGroups;

      boost::signal<void ()> signal_loading;

      boost::signal<void ()> signal_loaded;

      boost::signal<void ()> signal_selectionGroupsCleared;

      boost::signal<void (std::string, std::string)> signal_itemRenamed;

      boost::signal<void (std::string)> signal_selectionGroupSelected;


   protected:
      virtual void slot_stateRemoved(const makVrv::DtStateView<makVrv::DtVrlinkSimulatedBaseState>*);

   protected:
      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         if (version >= 2)
         {
            ar & BOOST_SERIALIZATION_NVP(mySelectionGroupsUUID);
         }
         else
         {
            typedef std::set<std::string> OldGroupItems;
            typedef std::map<std::string, OldGroupItems> OldSelectionGroups;

            OldSelectionGroups mySelectionGroups;

            ar & BOOST_SERIALIZATION_NVP(mySelectionGroups);

            if (Archive::is_loading::value)
            {
               OldSelectionGroups::const_iterator iter = mySelectionGroups.begin();
               bool hasItems = false;

               while (iter != mySelectionGroups.end())
               {
                  GroupItems newGroupItems;
                  OldGroupItems::const_iterator oldIter = iter->second.begin();

                  while (oldIter != iter->second.end())
                  {
                     DtUUID uuid(DtUUID::nullUUID());

                     uuid.setStringUUID(*oldIter);
                     newGroupItems.insert(uuid);
                     ++oldIter;
                  }

                  hasItems |= (newGroupItems.size() != 0);
                  mySelectionGroupsUUID[iter->first] = newGroupItems;
                  ++iter;
               }

               if (hasItems)
               {
                  myWaitingForDiscovery = true;
               }
            }
         }
      }

   protected:
      makVrv::DtDe& myDe;
      SelectionGroups mySelectionGroupsUUID;
      makVrv::DtSignalConnectionManager myConnectionManager;
      std::string mySelectedSelectionGroup;
      bool myWaitingForDiscovery;
   };

   class DT_DLL_VRFGUICORE DtVrfSelectionGroupFilter : public DtVrfSelectionFilter
   {
   public:
      DtVrfSelectionGroupFilter(DtSelectionGroupManager& manager, const makVrv::DtUnicode& name);

      virtual ~DtVrfSelectionGroupFilter();

   protected:
      virtual DtVrfSelectionFilter* clone() const;

      virtual void setForce(int)
      {
      };

      virtual bool isValid(const makVrv::DtVrlinkSimulatedBaseState*, const DtVrfObjectDataState* = 0) const;

   protected:
      DtSelectionGroupManager& mySelectionGroupManager;
   };
}

BOOST_CLASS_VERSION(makVrf::DtSelectionGroupManager,2)