vrfTaskSetMenu.h

Go to the documentation of this file.

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

#pragma once

#if !defined(Q_MOC_RUN)
#include <vrfGuiTaskSetQt/vrfGuiTaskSetQt.h>
#include <vrfGuiCommonQt/selectionEnabledMenu.h>
#include <vrfGuiCommonQt/configurableMenu.h>
#include <vrfGuiCore/guiSimObject.h>
#include <vrfutil/rwUUID.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrftasks/vrfObjectMessageTypeTemplate.h>
#include <vrftasks/setDataRequest.h>
#include <vrvCoreQt/DtMenuItem.h>
#include <vrvCoreQt/DtQtMenuAssembler.h>
#include <vrvCoreQt/DtMenuManager.h>
#include <vrvCore/DtSelectionManager.h>
#endif
#include <boost/signals2.hpp>

#include <QtWidgets/QAction>

class QEvent;
class DtSimTask;
class QToolBar;

namespace makVrv
{
   ;
}

namespace makVrf
{
   class DtVrfBackendState;
   class DtVrfTaskSetMenu;
   class DtScriptedTaskConfigurableMenu;
   class DtTaskSetDialogInterface;
   class DtVrfTaskSetAction;
   class DtCommandAssignmentWidgetInterface;

   class DT_DLL_VRFGUITASKSETQT DtVrfTaskSetMenu : public DtSelectionEnabledMenu
   {
      Q_OBJECT

   public:
      enum MenuType
      {
         TaskMenu = 1,
         SetMenu = 2
      };

      DtVrfTaskSetMenu(const std::string& className, const QString& title, int flags, QWidget* parent, makVrv::DtDe&,
         const DtSubMenuConfiguration& c);

      virtual ~DtVrfTaskSetMenu() override;

      virtual void setValidate(bool b);

      virtual void setShowAllItems(bool b);

      virtual void setPartOfPlanDialog(int b);
      virtual void setEntitySet(const makVrv::DtSelectionManager::IdSet& set);
      virtual void setMenuItemValidation(bool b);

      virtual void setHideDisabledItem(bool yesNo);

      virtual void setSignalDialogCreation(bool b);

      virtual void setFlags(int flags);

      bool signalDialogCreation() const
      {
         return mySignalDialogCreation;
      }

      virtual void setValidationsDisabled(bool);
      bool validationsDisabled() const
      {
         return myValidationsDisabled;
      }

      virtual void setSignalTaskSetRequests(bool b);

      bool signalTaskSetRequests() const
      {
         return mySignalTaskSetRequests;
      }

      int partOfPlanDialog() const
      {
         return myPartOfPlanDialog;
      }

      virtual bool hasPendingRequests() const;

      const makVrv::DtSelectionManager::IdSet& entitySet() const
      {
         return myEntitySet;
      }

      virtual MenuType menuType() const = 0;

      virtual void setAlwaysStartAsEnabled(bool b);

      bool alwaysStartAsEnabled() const
      {
         return myAlwaysStartAsEnabled;
      }

      void setValidateIfNoPendingRequests(bool b)
      {
         myValidateIfNoPendingRequests = b;
      }

      bool validateIfNoPendingRequests() const
      {
         return myValidateIfNoPendingRequests;
      }

      virtual makVrv::DtSelectionManager::IdSet selectionsToUseForTaskSetDialog() const;

      void setParentMenu(DtVrfTaskSetMenu* p)
      {
         myParentMenu = p;
      }

      DtVrfTaskSetMenu* parentMenu()
      {
         return myParentMenu;
      }
      
      virtual void clearMenu();

      virtual bool updateSubMenuVisibilityState(QMenu*, bool hasRadio = true, bool* anyEnabled = nullptr);

      typedef std::map<int, std::set<QAction*> > TaskActions;

      const TaskActions& taskActions() { return myTaskSetActions; };

      virtual void filterByTaskCategory(const DtString&);
      virtual void removeFilterByTaskCategory(const DtString&);
      const std::set<DtString>& filterByTaskCategories() const
      {
         return myFilterByTaskCategories;
      }

      virtual std::set<QAction*> actionsThatSupport(int) const;
      virtual std::set<QAction*> actionsThatSupport(const std::string&) const;

      virtual void setMenuProxy(DtScriptedTaskConfigurableMenu*);
      virtual DtScriptedTaskConfigurableMenu* menuProxy();

      virtual const char* supportedToolbar() const = 0;
      virtual const char* supportedMenu() const = 0;
      virtual const DtSubMenuConfiguration& defaultMenuConfiguration() const = 0;
      virtual const makVrv::DtQtMenuAssembler::MenuBuilderMap& defaultMenuBuilderMap() const = 0;
      virtual const makVrv::DtQtMenuAssembler::MenuItemBuilderMap& defaultMenuItemBuilderMap() const = 0;
      virtual void recreateMenu() = 0;
      virtual DtScriptedTaskConfigurableMenu* mainMenuInstance() = 0;

      virtual void sortMenu();

      virtual void editingDialog(DtTaskSetDialogInterface*);

      DtTaskSetDialogInterface* currentDialog() { return myCurrentDialog; };

      virtual bool hasSupportFor(const DtSetMessageType&) const;

      virtual bool hasSupportFor(const DtSimTaskMessageType&) const;

      virtual bool hasSupportForActionType(int) const;
      virtual void validateMenuItems(int terrainPatchOffset) override;

   public:
      boost::signals2::signal<void (std::vector<DtUUID> names, const DtSetDataRequest&)> signal_sendSetRequest;
      boost::signals2::signal<void (std::vector<DtUUID> names, const DtSimTask&)> signal_sendTaskRequest;
      boost::signals2::signal<void (QAction*)> signal_validateMenuItem;
      boost::signals2::signal<void ()> signal_menuValidated;
      boost::signals2::signal<void ()> signal_menuCleared;

      boost::signals2::signal<void (DtTaskSetDialogInterface*)> signal_dialogCreated;

      boost::signals2::signal<void (DtTaskSetDialogInterface*)> signal_dialogDestroyed;
      boost::signals2::signal<void (DtCommandAssignmentWidgetInterface*)> signal_commandDialogDestroyed;

      virtual void slot_sendSetRequest(std::vector<DtUUID> names, const DtSetDataRequest& s);
      virtual void slot_sendTaskRequest(std::vector<DtUUID> names, const DtSimTask& s);

      virtual void slot_createTaskSetDialog(int menuItemType, QWidget*, DtVrfTaskSetAction*,
         const std::set<makVrv::DtUniqueID>&, int, bool oneClick);
      boost::signals2::signal<void (int menuItemType, QWidget*, DtVrfTaskSetAction*,
         const std::set<makVrv::DtUniqueID>&, int, DtVrfTaskSetMenu*, bool oneClick)> signal_createTaskSetDialog;

      virtual void signalCommandDialogCreation(int menuItemType, QWidget* parent, DtVrfTaskSetAction* forAction,
         const std::set<makVrv::DtUniqueID>& data, int partOfPlan);
      boost::signals2::signal<void (int menuItemType, QWidget*, DtVrfTaskSetAction*,
         const std::set<makVrv::DtUniqueID>&, int, DtVrfTaskSetMenu*)> signal_createCommandDialog;

      virtual void mergeChangesFrom(const std::string& menu, const DtSubMenuConfiguration&, DtSubMenuConfiguration&,
         bool maintainOriginalOrder = false);
      virtual makVrv::DtSelectionManager::IdSet selectionToUseToValidate() const;

   public slots:
      virtual void validate();

   protected slots:
      virtual void radioMenuDestroyed();
      virtual void dialogDestroyed();

   protected:
      virtual void renameIfDuplicate(QAction*);

      virtual QString alternateName(QAction*) const;

      virtual void revalidate(makVrv::DtUniqueID);

      virtual bool eventFilter(QObject*, QEvent*) override;
      virtual void actionAdded(QEvent*);
      virtual void addTaskAction(QAction*);
      virtual void rebuildToolbar(const std::string&);

      virtual void slot_taskSetMenuSortChanged(bool);

      virtual void slot_backendUpdated(const DtVrfBackendState&, int);
      virtual bool available(int menu, std::set<int>& l) const;

      virtual bool needsValidation() const override;

      virtual void availableMenuItems(
         const makVrv::DtSelectionManager::IdSet& selections, 
         std::set<int>& available,
         bool noTaskSetValueMeansAll);

      virtual bool isFilteredByTaskCategories(const DtEntityType&, int) const;

      virtual bool shouldAddAsPartOfMenu(const QList<QAction*>& acts, QAction* toMatch) const;

      virtual void destroyActions(const QList<QAction*>& actions);

      virtual void stateRemoved(DtSimObjectReference state);

      //
      virtual void setupMenu(const makVrv::DtMenuConfiguration& initialCreateMenuConfiguration = makVrv::DtMenuConfiguration(),
         const makVrv::DtToolbarConfiguration& initialCreateToolbarConfiguration = makVrv::DtToolbarConfiguration(),
         bool useGlobalMenuManager = false, bool recreateToolbars = false);

   protected:
      TaskActions myTaskSetActions;
      makVrv::DtSelectionManager::IdSet myEntitySet;
      bool           myValidate;
      bool           myValidationsDisabled;
      bool           myShowAllItems;
      bool           myMenuItemValidation;
      int            myPartOfPlanDialog;
      bool           mySignalTaskSetRequests;
      bool           mySignalDialogCreation;
      std::vector<DtVrfTaskSetMenu*>   myRadioMenus;
      DtVrfTaskSetMenu* myParentMenu;
      std::string myClassName;
      bool myHideDisabledItems;
      bool myConnectedForValidate;
      DtScriptedTaskConfigurableMenu* myMenuProxy;
      bool myRecreateToolbars;
      bool myUseGlobalMenuManager;
      bool           myRecreateMenuOnSelectionChange;
      DtSubMenuConfiguration myConfiguration;
      DtTaskSetDialogInterface* myCurrentDialog;
      bool myAlwaysStartAsEnabled;
      bool myValidateIfNoPendingRequests;
      bool myHasBeenValidatedOnce;
      std::set<DtString> myFilterByTaskCategories;
      int myFlags;
   }; 

   class DT_DLL_VRFGUITASKSETQT DtMenuReadyMenuManager : public makVrv::DtMenuManager
   {
   public:
      DtMenuReadyMenuManager() : makVrv::DtMenuManager()
      {
      }

      void clear()
      {
         myMenuItems.clear();
         myMenus.clear();
      }
   };

   class DT_DLL_VRFGUITASKSETQT DtMenuReadyMenuAssembler : public makVrv::DtQtMenuAssembler
   {
   public:
      DtMenuReadyMenuAssembler(makVrv::DtDe&, QWidget*, QMenuBar*);

      virtual ~DtMenuReadyMenuAssembler() override
      {
         myMenuManager.clear();

         myMenuBuilders.clear();
         myMenuItemBuilders.clear();
      }

      virtual void unregisterMenu(const std::string& s)
      {
         makVrv::DtMenu* b = menuBuilder(s);

         if (b)
         {
            MenuBuilderMap::iterator iter = myMenuBuilders.begin();

            while (iter != myMenuBuilders.end())
            {
               if (iter->second == b)
               {
                  myMenuBuilders.erase(iter);
               }
               ++iter;
            }
         }
      }

      virtual QMenuBar* menuBar() override {
         return myMenuBar;
      }

      virtual QWidget* menuWindow() override;

      virtual makVrv::DtMenuManager& menuManager() override;

      QMenu* findMenu(const makVrv::DtMenuPath& path)
      {
         return myMenuManager.findMenu(path);
      }

   protected:
      QWidget*              myMainWindow;
      QMenuBar*             myMenuBar;
      DtMenuReadyMenuManager myMenuManager;
   };
}