informationDialogPage.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 <vrfGuiObjectInformationQt/vrfGuiObjectInformationQt.h>
#include <vrfGuiObjectInformationQt/informationDialogHandler.h>
#include <vrfGuiCommonQt/treeWidget.h>
#include <vrfGuiCore/guiSimObject.h>

#include <vrvCoreQt/DtPage.h>
#include <vrvCore/DtPageConfiguration.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#endif
#include <boost/signals2.hpp>

#include <QtWidgets/QTreeWidget>

class QLabel;
class QVBoxLayout;
class DtFrame;

namespace makVrv
{
   class DtDe;
   class DtPersistenceToolbarWidget;
}

namespace makVrf
{
   class DtGuiSimObject;
   class DtTimedSimObjectModifiedSignaler;

   namespace makVrfGuiObjectInformationQt
   {
      class DtInformationDialogPageLogic;
      class DtInformationTreeWidgetItem;
      class DtInformationDialog;

      class DT_DLL_VRFGUIOBJECTINFORMATIONQT DtLineBreakWidget : public QWidget
      {
      public:
         DtLineBreakWidget(QWidget* parent, QWidget* containing);

         virtual bool eventFilter(QObject*, QEvent*) override;

         virtual void setLineBreak(int);

         void setSelectable(bool b) { mySelectable = b; };
         bool selectable() const { return mySelectable; };

      public:
         QWidget* myContaining;
         QFrame* myLine;

      protected:
         bool mySelectable;
      };

      class DT_DLL_VRFGUIOBJECTINFORMATIONQT DtShadedWidget : public QWidget
      {
      public:
         DtShadedWidget(QWidget*);
         virtual ~DtShadedWidget() override;

         void setDown(bool);
         bool down() const { return myDown; };

         void setSelectable(bool);
         bool selectable() const { return mySelectable && isEnabled(); };

         virtual void paintEvent(QPaintEvent*) override;

      protected:
         bool myDown;
         bool mySelectable;
      };

      class DT_DLL_VRFGUIOBJECTINFORMATIONQT DtItemUpdateFunction : public DtInformationSectionDisplayHandler,
         public QObject
      {
      public:
         DtItemUpdateFunction(makVrv::DtDe&);
         DtItemUpdateFunction(DtInformationDialogPageLogic* l);

         virtual ~DtItemUpdateFunction() override;

         virtual QWidget* createWidgetRepresentation(QWidget* parent,  DtSimObjectReference, const std::string& keywords);
         virtual QWidget* widgetRepresentation(QWidget* parent,  DtSimObjectReference);

         virtual void setLogic(DtInformationDialogPageLogic* l);
         DtInformationDialogPageLogic* logic()
         {
            return myLogic;
         }

         virtual void slot_onStateViewUpdated() override {
            stateViewUpdated(myState);
         }

         virtual void stateViewUpdated(DtSimObjectReference);
         virtual void setTreeWidgetItem(DtInformationTreeWidgetItem*);

         virtual void adjustWidgetForColumnSpan(int colSpan) override;
         virtual void adjustWidgetForRowSpan(int rowSpan) override;

         virtual bool shouldBeHidden(DtSimObjectReference) const;

         virtual void activate(DtSimObjectReference) override;

         virtual void deactivate(DtSimObjectReference)
         {
            deactivate();
         }

         makVrv::DtDe* de() const;

         virtual void deactivate() override;

         virtual std::string icon() const;

         DtInformationTreeWidgetItem* treeWidgetItem()
         {
            return myTreeWidgetItem;
         }

         const DtInformationTreeWidgetItem* treeWidgetItem() const
         {
            return myTreeWidgetItem;
         }

         virtual void setFixedItemWidth(int) override;
         virtual void setFixedItemHeight(int) override;

         virtual DtFilename pixmapFile() const;

         virtual QSize minimumSizeHint() const override;
         virtual void setMaximumSize(const QSize&) override;
         virtual void setMinimumSize(const QSize&) override;
         virtual QRect geometry() const override;

         virtual void setMinimumHeight(int) override;
         virtual void setMinimumWidth(int) override;
         virtual void setMaximumHeight(int) override;
         virtual void setMaximumWidth(int) override;

         virtual bool eventFilter(QObject*, QEvent*) override;

         virtual bool mouseEnterEvent() override;
         virtual bool mouseLeaveEvent() override;

         virtual void setItemParameters(const std::vector<std::string>& params);
         virtual const std::vector<std::string>& itemParameters() const;

         virtual QVariant widgetValue(int col, int role, DtSimObjectReference) const;
         virtual QString toolTip(DtSimObjectReference s) const;

         virtual QString title(DtSimObjectReference s) const;
         virtual QVariant value(int col, int role) const;
         virtual QVariant value(int col, int role, DtSimObjectReference) const;

         virtual bool needsPageLogicForWidgetRepresentation() const;

         QWidget* container() const
         {
            return myContainer;
         }

         virtual QWidget* createContainerData() const;

         const QString& toolTip() const
         {
            return myToolTip;
         }

      protected:
         virtual void fixupPixmapsOnResize();

      protected:
         DtInformationDialogPageLogic* myLogic;
         DtInformationTreeWidgetItem* myTreeWidgetItem;
         makVrv::DtSignalConnectionManager myConnections;
         std::vector<std::string> myItemParams;
         QString myToolTip;

      public:
         QWidget* myDefaultText = nullptr;
         QLabel* myIconTitle = nullptr;
         QWidget* myContainer = nullptr;
      };

      class DT_DLL_VRFGUIOBJECTINFORMATIONQT DtInfoIconItem : public DtItemUpdateFunction
      {
      public:
         DtInfoIconItem(makVrv::DtDe& de)
         : DtItemUpdateFunction(de)
         {
         }

         DtInfoIconItem(DtInformationDialogPageLogic* l)
         : DtItemUpdateFunction(l)
         {
         }
         
         virtual void setFixedItemWidth(int i) override {
            myFixedItemWidth = i;
         }

         virtual void setFixedItemHeight(int i) override {
            myFixedItemHeight = i;
         }
         
         virtual void adjustWidgetForColumnSpan(int colSpan) override {
            myColSpan = colSpan;
         }

         virtual void adjustWidgetForRowSpan(int rowSpan) override {
            myRowSpan = rowSpan;
         }
      };

      class DtItemUpdateFunctionCreatorInterface
      {
      public:
         virtual ~DtItemUpdateFunctionCreatorInterface() {};
         virtual std::string creatorName() = 0;
         virtual DtItemUpdateFunction* create(DtInformationDialogPageLogic* l) = 0;
         virtual DtItemUpdateFunction* create(makVrv::DtDe&) = 0;
      };

      template <typename T> class DtItemUpdateFunctionCreator : public DtItemUpdateFunctionCreatorInterface
      {
      public:
         DtItemUpdateFunctionCreator() {};
         virtual ~DtItemUpdateFunctionCreator() override {};

         virtual std::string creatorName() override { return T::creatorName(); };
         virtual DtItemUpdateFunction* create(DtInformationDialogPageLogic* l) override { return new T(l); };
         virtual DtItemUpdateFunction* create(makVrv::DtDe& de) override { return new T(de); };
      };

      class DT_DLL_VRFGUIOBJECTINFORMATIONQT DtInformationDialogPage : public makVrv::DtPage,
         public DtInformationSectionMouseEventHandler
      {
         Q_OBJECT

      public:
         enum ShowStatus
         {
            AlwaysShow = 0,
            NeverShow = 1,
            InitiallyHideAndCheckToShow = 2
         };

         DtInformationDialogPage(makVrv::DtDe& de, QWidget* parent, Qt::WindowFlags f = Qt::SubWindow);

         virtual ~DtInformationDialogPage() override;

         virtual ShowStatus setupGui(DtSimObjectReference);

         virtual QTreeWidget* dataItems();
         virtual void slot_onStateViewUpdated();

         virtual void activate(DtSimObjectReference state);

         virtual void deactivate() override;

         virtual bool mouseEnterEvent() override;
         virtual bool mouseLeaveEvent() override;

         virtual void setFixedItemHeight(int) override;
         virtual void setFixedItemWidth(int) override;

         virtual void addDataItems(const makVrv::DtPageConfiguration::PagePathList&);
         
         virtual bool selectElement(const std::string&);

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

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

         virtual const makVrv::DtPageConfiguration::PagePathList& informationItems() const
         {
            return myInformationItems;
         }

         virtual QWidget* createWidgetRepresentation(QWidget* parent,  DtSimObjectReference,
            const std::string& keywords);
         virtual QWidget* widgetRepresentation(QWidget* parent,  DtSimObjectReference );
         virtual QSize minimumSizeHint() const override;
         virtual void setMaximumSize(const QSize& size) override;
         virtual void setMinimumSize(const QSize& size) override;
         virtual QRect geometry() const override;

         virtual void setMinimumHeight(int) override;
         virtual void setMinimumWidth(int) override;
         virtual void setMaximumHeight(int) override;
         virtual void setMaximumWidth(int) override;

         virtual void removeTitle();

         virtual void adjustWidgetForColumnSpan(int colSpan) override;
         virtual void adjustWidgetForRowSpan(int rowSpan) override;

         virtual void setLineBreak(int);

         virtual DtInformationDialogPageLogic* createLogic()
         {
            return 0;
         }

         virtual void dialogAboutToShow(DtInformationDialog*);

         DtInformationDialogPageLogic* logic() const
         {
            return myLogic;
         }

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

         const std::string& sectionName() const
         {
            return mySectionName;
         }

         virtual void setLogic(DtInformationDialogPageLogic*);

         virtual void signalToAddWhenReady(bool, DtSimObjectReference s);
         virtual void checkReadyToAdd(DtSimObjectReference) {};

         virtual void setSizeHint(const QSize&);
         virtual QSize sizeHint() const override;

         virtual void mainWindowHidden();
         virtual void mainWindowShown();

         boost::signals2::signal<void (DtInformationDialogPage*)> signal_readyToShow;
         boost::signals2::signal<void ()> signal_stateViewUpdated;
         boost::signals2::signal<void (std::string, DtInformationSectionDisplayHandler*)> signal_showInformationPage;
         boost::signals2::signal<void (std::string, bool)> signal_expandSection;

      protected slots:
         virtual void lineBreakDestroyed();

         virtual void onHeaderClicked(int column);
         virtual void itemRightClickedOn(QTreeWidgetItem* item, QMouseEvent* e, int col);
         virtual void onCopyValue();

      protected:
         virtual QWidget* createPageContents(ShowStatus& status);
         virtual void updateShowState(const std::string& s, bool b);

         virtual void sortPageContents();

         virtual void activate() override;

         virtual bool keepInformationDialogUpOnRewind() const { return true; };

         virtual QMenu* createRightClickMenu(QTreeWidgetItem*);

      protected:
         DtInformationDialogPageLogic* myLogic;
         makVrv::DtPageConfiguration::PagePathList myInformationItems;
         int myLineBreak;
         bool myDeleting;
         QSize mySizeHint;
         std::string mySectionName;

      public:
         QVBoxLayout*   myMainLayout;
         QVBoxLayout*   myContentsLayout;
         QTreeWidget*   myDataItems;
         QWidget*       myWidgetRepresentation;
         DtLineBreakWidget* myLineBreakWidget;
         QMenu* myRightClickMenu = nullptr;
      };

      class DT_DLL_VRFGUIOBJECTINFORMATIONQT DtInformationDialogPageLogic
      {
      public:
         enum AddFlags
         {
            Before = 1,
            ChildOf = 2
         };

      public:
         DtInformationDialogPageLogic(makVrv::DtDe&, DtInformationDialogPage* iface);

         virtual ~DtInformationDialogPageLogic();

         virtual void clearInterface();

         makVrv::DtDe& de()
         {
            return myDe;
         }

         void setInterface(DtInformationDialogPage* iFace)
         {
            myInterface = iFace;
         }

         virtual void addDataItems(const makVrv::DtPageConfiguration::PagePathList& pathList);
         DtSimObjectReference state() const
         {
            return mySimObject;
         }

      public:
         virtual DtInformationTreeWidgetItem* addDataItem(const std::string& name, DtItemUpdateFunction* function,
            const std::string& before = "", int flags = Before);

         virtual void replaceUpdateFunction(const std::string& name, DtItemUpdateFunction* function);

         virtual void removeDataItem(const std::string& name);

         virtual void setDataItemVisible(const std::string&, bool);

         virtual void activate(DtSimObjectReference state);
         virtual void deactivate();

         DtSimObjectReference simObject() const
         {
            return mySimObject;
         }

         virtual void setFixedItemHeight(int);
         int fixedItemHeight() const
         {
            return myFixedItemHeight;
         }

         virtual void setFixedItemWidth(int);
         int fixedItemWidth() const
         {
            return myFixedItemWidth;
         }

         virtual const std::set<makVrv::DtUniqueID>& elementIDs() const;
         virtual void stateViewUpdated();
         virtual void updateData();
         virtual void updateItemVisibility();

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

      protected:
         virtual void slot_defaultIconListChanged();
         virtual void setSimObject(DtSimObjectReference);
         virtual DtInformationTreeWidgetItem* createTreeWidgetItem();

      protected:
         DtInformationDialogPage*   myInterface;
         makVrv::DtDe&              myDe;
         DtSimObjectReference             mySimObject;
         makVrv::DtSignalConnectionManager myConnections;
         makVrv::DtSignalConnectionManager myActivatedConnections;
         std::map<std::string, DtInformationTreeWidgetItem*>   myItems;
         bool myFirstUpdate;
         int myFixedItemHeight;
         int myFixedItemWidth;
         mutable std::set<makVrv::DtUniqueID> myElementIDs;
         boost::signals2::connection myTickConnection;
         DtTimedSimObjectModifiedSignaler* myUpdater = nullptr;
      };

      class DT_DLL_VRFGUIOBJECTINFORMATIONQT DtInformationTreeWidgetItem : public DtThemedTreeWidgetItem
      {
      public:
         DtInformationTreeWidgetItem(makVrv::DtDe&);
         virtual ~DtInformationTreeWidgetItem() override;

         virtual bool operator<(const QTreeWidgetItem&) const override;

         DtItemUpdateFunction* setUpdateFunction(DtItemUpdateFunction* f)
         {
            DtItemUpdateFunction* old = myUpdater;

            myUpdater = f;

            return old;
         }

         const std::string& internalName() const
         {
            return myInternalName;
         }

         void setInternalName(const std::string& n)
         {
            myInternalName = n;
         }

         void activate(DtSimObjectReference s)
         {
            myUpdater->activate(s);
         }

         void deactivate(DtSimObjectReference s)
         {
            myUpdater->deactivate(s);
         }

         DtItemUpdateFunction* updater()
         {
            return myUpdater;
         }

      protected:
         virtual QVariant data(int col, int role) const override;

      protected:
         DtItemUpdateFunction* myUpdater;
         std::string myInternalName;
      };

      class DT_DLL_VRFGUIOBJECTINFORMATIONQT DtInformationTreeWidgetItemCreator : public makVrv::DtVirtualBaseClass
      {
      public:
         DtInformationTreeWidgetItemCreator(makVrv::DtDe&);

         virtual DtInformationTreeWidgetItem* create();

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

      protected:
         makVrv::DtDe& myDe;
      };
   }
}