vrfTaskSetManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <vrfDiGuy/diGuyCharacterData.h>
#include "vrftasks/radioMessageTypes.h"

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

#include <vrvUtil/signalslib.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<DtSimTaskMessageType> 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;
      std::vector<DtString>   mySupportedGestures;
      std::map<DtString, std::vector<DtString> > mySupportedHeads;
   };

   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 requestInformationFor( makVrv::DtUniqueID id );

      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 DtSetMessageType setMessageType( int ) const;

      virtual DtSimTaskMessageType taskMessageType( int ) const;

      virtual std::vector<DtString> taskGroupsForTask( const DtEntityType& et, const DtSimTaskMessageType& taskType ) 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<DtSimTaskMessageType> availableSupportingTasks( const makVrv::DtUniqueID&, int type ) const;
      virtual DtTasksAndSets::AvailableSupportingTasks availableSupportingTasks( const makVrv::DtUniqueID& ) const;

      virtual void availableTasks( const makVrv::DtSelectionManager::IdSet&, std::set<int>& available,
         bool noTaskSetValueMeansAll = true );
      virtual void availableTasks( const makVrv::DtSelectionManager::IdSet&, std::vector<int>& available,
         bool noTaskSetValueMeansAll = true );
      virtual void availableSets( const makVrv::DtSelectionManager::IdSet&, std::set<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::set<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::signals2::signal<void (makVrv::DtUniqueID)> signal_supportedTaskInformationChanged;
      boost::signals2::signal<void (makVrv::DtUniqueID)> signal_supportingTaskInformationChanged;
      boost::signals2::signal<void (makVrv::DtUniqueID)> signal_supportedSetInformationChanged;
      boost::signals2::signal<void (makVrv::DtUniqueID)> signal_supportedDiGuyAnimationsInformationChanged;
      boost::signals2::signal<void (makVrv::DtUniqueID)> signal_supportedDiGuyAppearanceInformationChanged;
      boost::signals2::signal<void (makVrv::DtUniqueID)> signal_supportedDiGuyHandItemInformationChanged;
      boost::signals2::signal<void (makVrv::DtUniqueID)> signal_supportedDiGuyGestureInformationChanged;
      boost::signals2::signal<void (makVrv::DtUniqueID)> signal_supportedDiGuyHeadInformationChanged;
      boost::signals2::signal<void ()> signal_taskSetInformationCleared;

      boost::signals2::signal<void ()> signal_allPendingRequestsResolved;

      virtual bool hasPendingRequests() const;

      virtual bool hasPendingRequest( makVrv::DtUniqueID ) 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 setDIGuyGestures( const makVrv::DtUniqueID&, const std::vector<DtString>&, bool signal = true );
      virtual void setDIGuyHeads( const makVrv::DtUniqueID&, const DtString& appearance, 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;

   };

}