vrfTaskSetManager.h

Go to the documentation of this file.

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




#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtStateView.h>
#include <vrvCore/DtEntityState.h>

#include <vrfutil/diGuyCharacterData.h>

#include <boost/signal.hpp>
#include "vrftasks/radioMessageTypes.h"

namespace makVrv
{
   class DtDe;
   class DtSimEntry;
   class DtSimObjectEntry;
}

class DtSimMessage;
class DtIfCapableTaskAndSetResponse;
class DtIfDiGuyAppearAndAnimationsResponse;

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtTasksAndSets
   {
   public:
      DtTasksAndSets()
      {
      };

      DtTasksAndSets(const DtTasksAndSets& orig) :
         mySupportedTasks(orig.mySupportedTasks), mySupportedSets(orig.mySupportedSets)
      {
      };

      std::vector<DtSimTaskMessageType>  mySupportedTasks;
      std::vector<DtSetMessageType>  mySupportedSets;

      typedef std::vector<std::string> SupportingTasks;
      typedef std::map<int, SupportingTasks> AvailableSupportingTasks;
      AvailableSupportingTasks myAvailableSupportingTasks;
   };

   class DT_DLL_VRFGUICORE DtDIGuyAppearancesAndAnimations
   {
   public:
      std::vector<DtString>   mySupportedAppearances;
      AlternateNamesList      mySupportedTaskableAnimations;
      std::vector<DtString>   mySupportedHandItems;
   };

   class DT_DLL_VRFGUICORE DtVrfTaskSetManager : public makVrv::DtVirtualBaseClass
   {
   public:
      typedef std::map<int, std::vector<DtSimTaskMessageType> > DtTaskMap;
      typedef std::map<int, std::vector<DtSetMessageType> > DtSetMap;
      typedef std::vector<makVrv::DtSimEntry*> SimEntries;

   public:
      DtVrfTaskSetManager(makVrv::DtDe&);
      virtual ~DtVrfTaskSetManager();

      static DtVrfTaskSetManager& instance(makVrv::DtDe& de);

   public:
      virtual int menuIdForTaskType(DtSimTaskMessageType) const;

      virtual int menuIdForSetType(DtSetMessageType) const;

      virtual void requestInformationFor(const DtUUID&, makVrv::DtUniqueID id);
      virtual void requestInformationFor(const std::vector<std::pair<DtUUID, makVrv::DtUniqueID> >& names);

      virtual void updateAvailableTaskSetInformation(const makVrv::DtSimEntry* type);
      virtual void updateAvailableTaskSetInformation(const SimEntries&);
      virtual void updateAvailableTaskSetInformation(const DtUUID&);
      virtual void updateAvailableTaskSetInformation(makVrv::DtElementID id);

      virtual void clearInformationFor(makVrv::DtUniqueID id, bool request = false);
      virtual void clearInformationFor(const std::vector<makVrv::DtUniqueID>& ids, bool request = false);

      virtual bool hasTaskSetInformationFor(const makVrv::DtUniqueID&) const;

      virtual bool hasTaskSetInformationFor(const DtUUID&) const;

      virtual std::string diGuyAnimationForKeyword(const std::string& kw) const;

      virtual void setSupportedTasks(const makVrv::DtUniqueID&, const std::vector<DtSimTaskMessageType>&, bool signal = true);
      virtual void setSupportedSets(const makVrv::DtUniqueID&, const std::vector<DtSetMessageType>&, bool signal = true);
      virtual void setSupportingTasks(const makVrv::DtUniqueID&, const std::map<int, std::vector<DtSimTaskMessageType> >&, bool signal = true);

      virtual std::vector<DtSimTaskMessageType> availableTasks(const makVrv::DtUniqueID&) const;
      virtual std::vector<DtSetMessageType> availableSets(const makVrv::DtUniqueID&) const;
      virtual std::vector<std::string> availableSupportingTasks(const makVrv::DtUniqueID&, int type) const;
      virtual DtTasksAndSets::AvailableSupportingTasks availableSupportingTasks(const makVrv::DtUniqueID&) const;

      virtual void availableTasks(const makVrv::DtSelectionManager::IdSet&, std::vector<int>& available,
         bool noTaskSetValueMeansAll = true);
      virtual void availableSets(const makVrv::DtSelectionManager::IdSet&, std::vector<int>& available,
         bool noTaskSetValueMeansAll = true);
      virtual void available(const makVrv::DtSelectionManager::IdSet&, std::vector<int>& available,
         bool noTaskSetValueMeansAll = true);
      virtual std::vector<int> supportedMenuTasks() const;
      virtual std::vector<int> supportedMenuSets() const;

      virtual int lookupTask(const DtSimTaskMessageType type) const;     

      virtual int lookupSet(const DtSetMessageType type) const;     

      boost::signal<void (makVrv::DtUniqueID)> signal_supportedTaskInformationChanged;
      boost::signal<void (makVrv::DtUniqueID)> signal_supportingTaskInformationChanged;
      boost::signal<void (makVrv::DtUniqueID)> signal_supportedSetInformationChanged;
      boost::signal<void (makVrv::DtUniqueID)> signal_supportedDiGuyAnimationsInformationChanged;
      boost::signal<void (makVrv::DtUniqueID)> signal_supportedDiGuyAppearanceInformationChanged;
      boost::signal<void (makVrv::DtUniqueID)> signal_supportedDiGuyHandItemInformationChanged;
      boost::signal<void ()> signal_taskSetInformationCleared;

      boost::signal<void ()> signal_allPendingRequestsResolved;

      virtual bool hasPendingRequests() const;

      virtual void clearInformationForForce(int);

      virtual bool isAvailableTaskMenuItem(int) const;
      virtual bool isAvailableVrfTaskItem(const DtSimTaskMessageType&) const;

      virtual bool isAvailableSetMenuItem(int) const;
      virtual bool isAvailableVrfSetItem(const DtSetMessageType&) const;

      virtual bool hasDIGuyInformationFor(const makVrv::DtUniqueID&) const;
      virtual DtDIGuyAppearancesAndAnimations* diGuyInformationFor(const makVrv::DtUniqueID&);

      virtual void setDIGuyAppearances(const makVrv::DtUniqueID&, const std::vector<DtString>&, bool signal = true);
      virtual void setDIGuyAnimations(const makVrv::DtUniqueID&, const AlternateNamesList&, bool signal = true);
      virtual void setDIGuyHandItems(const makVrv::DtUniqueID&, const std::vector<DtString>&, bool signal = true);


      virtual void clearAllInformation();

      virtual DtTasksAndSets* informationFor(const makVrv::DtUniqueID&);

      virtual void addAvailableSet(int menuItem, const DtSetMessageType& setType);
      virtual void addAvailableTask(int menuItem, const DtSimTaskMessageType& taskType);

      virtual void addAvailableSetForSingleSelection(int menuItem, const DtSetMessageType& setType);

      virtual void addAvailableTaskForSingleSelection(int menuItem, const DtSimTaskMessageType& taskType);

      virtual void setSetIsSingleSelection(int, bool);
      virtual bool setIsSingleSelection(int) const;

      virtual void setTaskIsSingleSelection(int, bool);
      virtual bool taskIsSingleSelection(int) const;

      virtual void removeAvailableSet(int menuItem, const DtSetMessageType& setType);
      virtual void removeAvailableTask(int menuItem, const DtSimTaskMessageType& taskType);

      virtual void requestDIGuyAppearancesAndAnimations(const DtUUID&);
      virtual void requestDIGuyAppearancesAndAnimations(const std::vector<DtUUID>&);

      virtual int nextAvailableId() const;

      virtual bool isAvailableTask(makVrv::DtUniqueID id, DtSimTaskMessageType) const;

      virtual bool isAvailableSet(makVrv::DtUniqueID id, DtSetMessageType) const;

   protected:
      virtual void requestTaskSetInformationFor(const DtUUID&);
      virtual void requestTaskSetInformationFor(const std::vector<DtUUID>&);
      virtual void requestTaskSetInformationFor(const std::vector<DtString>&);
      virtual void processTaskAndSetResponse(DtSimMessage*);

      virtual void processDIGuyResponse(DtSimMessage*);

      virtual void initMenuMappings();

      virtual bool needsUpdateForForce(const makVrv::DtStateView<makVrv::DtVrlinkSimulatedBaseState>* sv);

      virtual bool isAvailableMenuItem(int menu, const DtTaskMap&) const;
      virtual bool isAvailableMenuItem(int menu, const DtSetMap& m) const;
      virtual bool isAvailableVrfItem(const DtSimTaskMessageType& item, const DtTaskMap&) const;
      virtual bool isAvailableVrfItem(const DtSetMessageType& item, const DtSetMap&) const;

      virtual void mergeMenuItems(const std::vector<DtSimTaskMessageType>& entityItems, const DtTaskMap& menuMap,
         std::vector<int>& results);

      virtual void mergeMenuItems(const std::vector<DtSetMessageType>& entityItems, const DtSetMap& menuMap,
         std::vector<int>& results);

   protected:
      virtual void slot_postInitialize(makVrv::DtDe& de);
      virtual void slot_objectRemoved(makVrv::DtSimObjectEntry&);
      virtual void requestNextSetOfNames();

   protected:
      typedef std::map<int, bool> SingleSelectionMap;

      std::map<makVrv::DtUniqueID, int>  myForceMap;
      std::map<makVrv::DtUniqueID, DtTasksAndSets>  myTaskSetInformation;
      std::map<makVrv::DtUniqueID, DtDIGuyAppearancesAndAnimations*> myDIGuyTaskSetCharacterInfo;

      typedef std::map<int, std::set<DtUUID> > PendingNameGroupRequests;
      typedef std::map<DtUUID, std::pair<makVrv::DtUniqueID, int> > PendingRequests;

      PendingNameGroupRequests myPendingNameGroupRequests;
      int                      myPendingGroupRequest;

      PendingRequests     myPendingRequests;
      PendingRequests     myPendingDIGuyRequests;

      typedef std::map<DtUUID, bool> RequestingNames;
      RequestingNames myRequestingNames;


      DtSetMap   mySetMenuMap;
      DtTaskMap   myTaskMenuMap;
      SingleSelectionMap mySingleSelectionSetMap;
      SingleSelectionMap mySingleSelectionTaskMap;

      makVrv::DtDe&       myDe;

      std::map<DtString, DtString> myDiGuyAnimations;
   };
}