planTreeWidget.h

Go to the documentation of this file.

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


#pragma once

#if !defined(Q_MOC_RUN)

#include <vrfGuiCoreQt/vrfGuiCoreQt.h>
#include <vrfGuiCommonQt/treeWidget.h>
#include <vrfplan/rwTriggersList.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfutil/rwUUID.h>
#include <vrvCore/DtUniqueID.h>
#endif
#include <boost/signals2.hpp>

#include <QtWidgets/QTreeWidget>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QStyledItemDelegate>

#include <set>

//

class QMenu;
class QAction;
class QTreeWidget;
class DtPlan;
class DtStmtIndex;
class DtSimBlock;
class DtSimStatement;
class DtRwTriggersList;
class QToolButton;

namespace makVrv
{
   class DtDe;
}

#define planPasteType "text/x-myPlanText@Type"
#define planTopLevelPasteType "text/x-myPlanText@TopType"

namespace makVrf
{
   class DtPlanStatementItem;
   class DtPlanListBoxItem;
   class DtPlanTriggerItem;

   class DT_DLL_VRFGUICOREQT DtPlanTreeWidget : public DtTreeWidget
   {
      Q_OBJECT

      Q_PROPERTY(QColor DropLineColor MEMBER myDropLineColor USER true)
      Q_PROPERTY(QColor BlockActiveColor MEMBER myBlockActiveColor USER true)
      Q_PROPERTY(QColor MainBlockBackgroundColor MEMBER myMainBlockBackgroundColor USER true)
      Q_PROPERTY(QColor TriggerBlockBackgroundColor MEMBER myTriggerBlockBackgroundColor USER true)

   public:

      DtPlanTreeWidget(makVrv::DtDe&, QWidget* parent = NULL);

      virtual ~DtPlanTreeWidget();

      virtual void setExecutingTriggers(const std::vector<DtUUID>&);
      virtual bool triggerIsExecuting(const DtUUID&) const;

      virtual void setRegisteredTriggers(const std::vector<DtUUID>&);
      virtual bool triggerIsRegistered(const DtUUID&) const;

      virtual void setExecutingTriggerStatementIds(const std::vector<int>&);
      virtual bool triggerStatementIdIsBeingExecuted(int) const;

      virtual DtPlanStatementItem* currentlySelectedItem() const;
      virtual DtPlanStatementItem* currentlyExecutingItem() const;

      virtual bool hasItem(const DtPlanStatementItem*);

      virtual makVrv::DtUniqueID entityId() const;

      virtual void print();

      virtual void setName(const DtUUID&);
      const DtUUID& name() const;

      virtual void displayPlan(bool andSelectStatement = true);

      virtual void setIsGlobalPlan(bool);

      virtual void clearAllStatements();

      virtual void clearPlan();

      virtual void copySelectedPlanStatementToClipboard();

      virtual void copyPlanToClipboard();

      virtual void addStatementsToPlan(const std::vector<DtSimStatement*>&, bool append, bool redisplay = true);

      virtual void addStatementAfter(DtSimStatement* stmt,
         const DtPlanStatementItem* listItem = 0, bool redisplay = true, bool addAtEndOfParentBlock = false,
         DtSimStatement* lastStatementAdded = nullptr);

      virtual void replaceStatement(DtSimStatement* stmt, DtPlanStatementItem* item);

      virtual bool isBeingDragged(QTreeWidgetItem*) const;

      virtual void setPlan(DtPlan*);
      virtual DtPlan* plan() const;
      virtual DtPlan* plan() { return getOrCreatePlan(); };

      virtual void selectTrigger(const DtUUID&);

      virtual DtPlanTriggerItem* triggerItem(const DtUUID&) const;

      virtual DtPlanListBoxItem* mainPlanItem();

      virtual DtPlan* getOrCreatePlan();

      virtual void setCanDropOn(int, bool);
      virtual bool canDropOn(int) const;
      virtual bool canDropOn(QTreeWidgetItem*) const;
      virtual bool canDropOnCurrentItem() const;

      virtual DtSimStatement* selectStatement(int, DtPlanListBoxItem* inPlan = nullptr, bool andMakeCurrent = false);

      virtual DtPlanStatementItem* findItemByIndex(int statementIndex, DtPlanListBoxItem*, int subBlock = 0);

      virtual void setIsComplete(bool);

      virtual void addPlanMimeDataAfter(const QMimeData*, DtPlanStatementItem*, bool copy = true, bool redisplay = true, bool reselectCurrentItem = true);

      virtual DtPlanStatementItem* findLastItemByIndex(int statementIndex, DtPlanListBoxItem* plan, int subBlock = 0);

      virtual void setPlanTitle(const QString&);
      virtual const QString& planTitle() const;

      virtual bool planIsModified() const;
      virtual void clearPlanIsModified();
      virtual void markPlanIsModified();

      boost::signals2::signal<void (bool)> signal_planIsModified;
      boost::signals2::signal<void ()> signal_addedTriggers;

      virtual DtSimStatement* selectedBlockStatement() const;

      virtual DtSimStatement* selectedStatement() const;
      
      virtual DtSimStatement* displayBlockStatement() const;

      virtual void setShowRightClickMenu(bool);
      bool showRightClickMenu() const { return myShowRightClickMenu; };

      virtual QString planDescriptiveName() const;

      virtual void removeTrigger(const DtUUID&);

      virtual void renameTrigger(const DtUUID& uuid, const DtString& newName);

      virtual void unusedTriggers(DtRwTriggersList&) const;

      bool dragDraw() const { return myDragDraw; };

      virtual bool clearing() const;

      virtual void selectLastStatement();

      virtual DtPlanListBoxItem* currentPlanItem();

      virtual void setPlanIsModified(bool);

      virtual bool deleteStatement(DtPlanStatementItem*);

      const QColor& dropLineColor() const { return myDropLineColor; };
      const QColor& blockActiveColor() const { return myBlockActiveColor; };
      const QColor& mainBlockBackgroundColor() const { return myMainBlockBackgroundColor; };
      const QColor& triggerBlockBackgroundColor() const { return myTriggerBlockBackgroundColor; };

      virtual void displayTriggers();

      virtual std::map<DtUUID, bool> clearTriggers();

      virtual void addSeparator(const QString&);

      virtual void computeUnusedTriggers();

      const DtRwTriggersList& unusedTriggers() const
      {
         return myUnusedTriggers;
      }

      virtual bool triggerIsUnused(const DtUUID&) const;

      virtual void setPlanLocked(bool);
      bool planLocked() const
      {
         return myPlanLocked;
      }

   protected:
      virtual void internalComputeUnusedTriggers();

      virtual void initializeRightClickMenu();

      virtual void resizeEvent(QResizeEvent*);

      virtual QMimeData* mimeData(const QList<QTreeWidgetItem*> list) const;
      virtual void dragEnterEvent(QDragEnterEvent* event);
      virtual void dragMoveEvent(QDragMoveEvent* event);
      virtual bool dropMimeData(QTreeWidgetItem* parent, int index, const QMimeData* mimeData, Qt::DropAction action);
      virtual void dropEvent(QDropEvent *event);
      virtual void dragLeaveEvent(QDragLeaveEvent*);

      virtual void reissueStatementIds(DtSimStatement* stmt);

      virtual void startDrag(Qt::DropActions supportedActions);
      virtual bool eventFilter(QObject* o, QEvent*);

      virtual void itemRightClickedOn(QTreeWidgetItem*, QMouseEvent*, int col);

      virtual void unusedTriggers(DtSimBlock*, DtRwTriggersList&, std::set<DtUUID>& visited) const;

      virtual void uuidChanged(makVrv::DtUniqueID, const DtUUID&, const DtUUID&);

      virtual void storeCurrentContext();
      virtual void restoreCurrentContext();
      virtual void clearCurrentContext();

      friend class DtPlanStatementItem;
      friend class DtPlanListBoxItem;
      virtual void statementDeleted(DtPlanStatementItem*);

   signals:
      void editCurrentlySelectedPlanStatement();
      void deleteCurrentlySelectedPlanStatement();
      void copyCurrentlySelectedPlanStatement();
      void pastePlanStatement();
      void planRightClickMenuCreated(QMenu*);
      void rightClickToBeShown(bool&);
      void editCurrentlySelectedTrigger();
      void addNewTriggerBlock();
      void removeTriggerBlock(const DtUUID&);
      void editTriggerBlock(const DtUUID&);

   public:
      QMenu* myRightClickMenu;
      QAction* myEditAction;
      QAction* myEditTriggerAction;
      QAction* myDeleteAction;
      QAction* myCopyAction;
      QAction* myPasteAction;
      QToolButton* myAddNewTriggerBlock;

   protected:
      QColor myDropLineColor;
      QColor myBlockActiveColor;
      QColor myMainBlockBackgroundColor;
      QColor myTriggerBlockBackgroundColor;

      bool myIsGlobalPlan;
      QList<DtPlanStatementItem*> myLastDraggedItems;
      DtPlanStatementItem* myDraggingOver;
      DtPlanStatementItem* myCurrentlyExecutingItem;
      bool myPlanIsModified;
      bool myShowRightClickMenu;

      bool myFirstShow;
      QString myPlanTitle;
      
      bool myDragDraw;
      int myProposedAction;
      bool myPlanLocked = false;
      makVrv::DtSignalConnectionManager myConnections;

      QObject* myDropSource;
      bool myDropIsInsertAtTopIfNoEntry;

      struct StoredSelectionInformation
      {
         void clear()
         {
            selectedStatementId = 0;
            selectedPlanId = DtUUID::nullUUID();
            executingStatementId = 0;
            executingPlanId = DtUUID::nullUUID();
         }

         int selectedStatementId = 0;
         DtUUID selectedPlanId = DtUUID::nullUUID();

         int executingStatementId = 0;
         DtUUID executingPlanId = DtUUID::nullUUID();
      };

      StoredSelectionInformation myStoredSelectionInformation;

      std::set<DtUUID> myExecutingTriggers;
      std::set<DtUUID> myRegisteredTriggers;

      boost::signals2::scoped_connection myComputeUnusedTriggersConnection;
      DtRwTriggersList myUnusedTriggers;

      std::vector<int> myExecutingTriggerStatementIds;

   private:
      DtPlanTreeWidget(const DtPlanTreeWidget& orig);

      DtPlanTreeWidget& operator=(const DtPlanTreeWidget& rhs);
   };

   class DT_DLL_VRFGUICOREQT DtPlanTreeWidgetCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      DtPlanTreeWidgetCreator(makVrv::DtDe&);

      virtual ~DtPlanTreeWidgetCreator();

      static DtPlanTreeWidgetCreator& instance(makVrv::DtDe&);

      static void registerInstance(makVrv::DtDe&, DtPlanTreeWidgetCreator*);

      virtual DtPlanTreeWidget* create( QWidget* parent);

   protected:
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUICOREQT DtPlanWidgetItemDelegate : public QStyledItemDelegate
   {
   public:
      DtPlanWidgetItemDelegate(makVrv::DtDe& de, QObject* parent);
      virtual ~DtPlanWidgetItemDelegate();

      virtual void paint(QPainter *painter,
                        const QStyleOptionViewItem &option,
                        const QModelIndex &index) const override;

   protected:
      DtPlanTreeWidget* myPlanTreeWidget;
      makVrv::DtDe& myDe;
   };
}