autoHidePanel.h

Go to the documentation of this file.

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



#pragma once

#include <vrvUtil/signalslib.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrfGuiCoreQt/vrfGuiCoreQt.h>
#include <vrfGuiCoreQt/autoHideDock.h>
#include <vrfGuiCoreQt/entityCreatePalette.h>
#include <vrfGuiCoreQt/tacticalGraphicCreatePalette.h>
#include <vrfGuiCoreQt/hazardAreaCreatePalette.h>
#include <vrfGuiCoreQt/propCreatePalette.h>
#include <vrfGuiCoreQt/widgetAnimator.h>
#include <vrvCore/DtUserInterfaceAssembler.h>
#include <vrvCoreQt/DtDockable.h>
#include <vrvCoreQt/DtMenuItem.h>
#include <vrvCoreQt/DtQtPageCollection.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <QtGui/QIcon>
#include <QtGui/QPixmap>
#include <QtWidgets/QWidget>
#include <QtWidgets/QDockWidget>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QHeaderView>
#include <QtCore/QTimer>
#include <map>

class QVBoxLayout;

namespace makVrv
{
   class DtDe;
   class DtChannelManager;
   class DtChannel;
   class DtObserverObject;
}

namespace makVrf
{
   class DtAutoHidePanelItem;
   class DtPropCreatePalette;
   class DtEntityCreatePalette;
   class DtTacticalGraphicCreatePalette;
   class DtHazardAreaCreatePalette;

   class DT_DLL_VRFGUICOREQT DtAutoHideDockViewItem : public makVrv::DtMenuItem
   {

      Q_OBJECT

   public:

      DtAutoHideDockViewItem(makVrv::DtDe& de, const std::string& dockName, DtAutoHidePanelItem* item);

      virtual ~DtAutoHideDockViewItem();

      virtual QAction* createAction(makVrv::DtDe& de, QWidget* parent);

   protected:

      virtual void on_triggered();

      virtual void on_aboutToShow();

   protected:

      DtAutoHidePanelItem* myPanelItem;
      QAction* myAction;
      makVrv::DtDe& myDe;
   };

   class DT_DLL_VRFGUICOREQT DtAutoHidePanelItem : public QWidget
   {
      Q_OBJECT

   public:
      
      DtAutoHidePanelItem(makVrv::DtDe& de, QWidget* parent, QString title, const std::string& className);

      virtual ~DtAutoHidePanelItem();

      DtAutoHideDock* dockToManage();
      virtual void setDockToManage(DtAutoHideDock* widget);         

      virtual const QPixmap& icon() const;
      virtual void setIcon(const QIcon& p);

      const std::string& className() const { return myClassName; };

      virtual QString iconText();      
      virtual void setIconText(const QString& s);

      virtual bool toggled() const;
      virtual void setToggled(bool flag);
      
      virtual void setSelected(bool flag);

      virtual void setAvailable(bool visible, bool updateVisibilityState = true);
      virtual bool available() const;

      virtual void setAboutToBeShown(bool flag);

      virtual void refreshSize(int minsize=-1);

      virtual void setToggle(bool flag);

   protected:

      virtual void enterEvent(QEvent* e);

      virtual void leaveEvent(QEvent *);

      virtual void mouseReleaseEvent( QMouseEvent * event );

      virtual void paintEvent(QPaintEvent* p);      

   signals:

      void signal_enter(DtAutoHidePanelItem*);

      void signal_leave(DtAutoHidePanelItem*);

      void signal_toggled(DtAutoHidePanelItem*);

      void signal_clicked(DtAutoHidePanelItem*);

      void signal_availabilityChanged(DtAutoHidePanelItem*);

   protected:

      QPixmap myIcon;
      QString myIconText;
      int myLeftMargin;
      int myRightMargin;
      int myTopMargin;
      int myBottomMargin;
      int mySpacing;
      bool myIsSelected;
      bool myIsToggled;
      DtAutoHideDock* myAutoHideDock;      
      bool myAboutToBeShown;
      bool myIsToggleType;
      bool myIsAvailable;
      makVrv::DtDe& myDe;
      std::string myClassName;
   };

   class DT_DLL_VRFGUICOREQT DtAutoHidePanelItemCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      DtAutoHidePanelItemCreator();
      virtual ~DtAutoHidePanelItemCreator();

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

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

      virtual DtAutoHidePanelItem* create(makVrv::DtDe&, QWidget* parent, const QString& title, const std::string& className);
   };

   class DT_DLL_VRFGUICOREQT DtAutoHidePanel : public QObject, public makVrv::DtQtPageCollection,
      public makVrv::DtVirtualBaseClass
   {
      Q_OBJECT

   public:

      enum DtAppearanceOptions
      {
         Hidden = 0,
         Pinned,
         Docked,
         Floating
      };

      typedef std::list<DtAutoHidePanelItem*> DtAutoHidePanelItemList;
      typedef DtAutoHidePanelItemList::iterator DtAutoHidePanelItemListIterator;

      typedef std::list<DtAutoHideDock*> DtAutoHideDockList;
      typedef DtAutoHideDockList::iterator DtAutoHideDockListIterator;

      typedef std::map<std::string, DtAppearanceOptions> DtAppearanceList;
      typedef std::map<std::string, DtAppearanceOptions>::iterator DtAppearanceListIterator;

   public:

      DtAutoHidePanel(makVrv::DtDe& de, const std::string& name, makVrv::DtQtDeMainWindow* parent);

      virtual ~DtAutoHidePanel();

      virtual DtAutoHidePanelItem* addItem(DtAutoHideDock* dock, bool forceVisible=false, bool initiallVisible = true) ;

      virtual void clear();

      virtual DtAutoHidePanelItem* findItemForClass( const std::string& s );
      virtual DtAutoHidePanelItem* findItemForDock( const DtAutoHideDock* dock );

      virtual void setPanelItemVisible(const std::string& panelClassName, bool, bool updateVisibilityState = false);

      virtual void hideAllDocks();         

      virtual int itemCount();

      virtual void placeItems();

      virtual void removeItem(DtAutoHidePanelItem* item);

      virtual void showDockForItem( DtAutoHidePanelItem* item, bool animate=true);

      virtual void hideDockForItem( DtAutoHidePanelItem* item, bool animate=true);

      static DtAutoHidePanel* instance(makVrv::DtDe&);

      virtual std::vector< std::pair<DtString, QString> > panelsThatCanBeUsedOnCreateMenu() const;

      virtual void changeVisibility(bool);

      virtual bool findDock(DtAutoHideDock* dock);


      virtual void changeLocation(makVrv::DtPageConfiguration::PageCollectionLocation) {};

      virtual void changeFloatingGeometry(int px, int py, int width, int height) {};

      virtual void changeFloatingGeometry(makVrv::DtPageConfiguration::PageCollectionGeometry geometry) {};

      virtual void changeDockedGeometry(int px, int py, int width, int height) {};

      virtual void changeDockedGeometry(makVrv::DtPageConfiguration::PageCollectionGeometry geometry) {};

      virtual void selectPage(const std::string& pageClassName) {};

      const DtAutoHideDockList& docks() const
      {
         return myDocks;
      }

      template <typename PaletteClass>
      PaletteClass* createPalette()
      {
         DtAutoHideDockList::iterator iter = myDocks.begin();

         while (iter != myDocks.end())
         {
            PaletteClass* p = dynamic_cast<PaletteClass*>((*iter)->widget());

            if (p)
            {
               return p;
            }

            ++iter;
         }

         return 0;
      }

      template <typename PaletteClass>
      DtAutoHideDock* creationDock()
      {
         DtAutoHideDockList::iterator iter = myDocks.begin();

         while (iter != myDocks.end())
         {
            PaletteClass* p = dynamic_cast<PaletteClass*>((*iter)->widget());

            if (p)
            {
               return *iter;
            }

            ++iter;
         }

         return 0;
      }

      virtual DtEntityCreatePalette* entityCreatePalette()
      {
         return createPalette<DtEntityCreatePalette>();
      }

      virtual DtAutoHideDock* entityCreationDock()
      {
         return creationDock<DtEntityCreatePalette>();
      }

      virtual DtHazardAreaCreatePalette* hazardAreaCreatePalette()
      {
         return createPalette<DtHazardAreaCreatePalette>();
      }

      virtual DtAutoHideDock* hazardAreaCreationDock()
      {
         return creationDock<DtHazardAreaCreatePalette>();
      }

      virtual DtTacticalGraphicCreatePalette* tacticalGraphicCreatePalette()
      {
         return createPalette<DtTacticalGraphicCreatePalette>();
      }

      virtual DtAutoHideDock* tacticalGraphicCreationDock()
      {
         return creationDock<DtTacticalGraphicCreatePalette>();
      }

      virtual DtPropCreatePalette* propCreatePalette()
      {
         return createPalette<DtPropCreatePalette>();
      }

      virtual DtAutoHideDock* propCreationDock()
      {
         return creationDock<DtPropCreatePalette>();
      }

      virtual void setItemPinned( DtAutoHidePanelItem*, bool );

   protected:

      virtual void setupGui();

      virtual bool eventFilter(QObject* p, QEvent* e);

      virtual void installEventFilters();

      virtual int maxItemWidth();

      virtual void removeDock(DtAutoHideDock* dock);

      virtual void relocateAnyPinnedDock();

      virtual void refreshItems(int minsize);

      virtual void refreshAppearanceOfItem(DtAutoHidePanelItem* autoHideItemWidget, bool forceVisible);

      virtual void addPageToGui(makVrv::DtPage*);
      
      virtual void removePageFromGui(makVrv::DtPage*);

      virtual void selectPageInGui(makVrv::DtPage* page) {};

   protected slots:

      virtual void slot_onItemToggled(DtAutoHidePanelItem*);

      virtual void slot_onItemClicked(DtAutoHidePanelItem*);

      virtual void slot_dockClosed(DtAutoHideDock* dockWidget);

      virtual void slot_dockEntered(DtAutoHideDock* dockWidget);

      virtual void slot_dockLeft(DtAutoHideDock* dockWidget);

      virtual void slot_dockResized(DtAutoHideDock* dockWidget);

      virtual void slot_dockDestroyed(DtAutoHideDock* dockWidget);

      virtual void slot_showDockOfCurrentItem(bool lockIt=false);

      virtual void slot_closeTimerTimeout();

      virtual void slot_onItemAvailabilityChanged(DtAutoHidePanelItem* dockWidget);

      virtual void slot_observerModeSettingChanged( makVrv::DtObserverObject*, int setting, bool value );
      virtual void placeCompass();

      virtual void finalizeSetup();

   protected:
      QMainWindow* myMainWindow;
      QWidget* myCentralWidget;
      DtAutoHidePanelItemList myItems;    
      DtAutoHideDockList myDocks;         
      DtAppearanceList myItemsAppearance; 
      DtWidgetAnimator* myWidgetAnimator; 
      DtAutoHidePanelItem* myCurrentItem; 
      QTimer myTimer;                     
      QTimer myCloseTimer;                

      makVrv::DtSignalConnectionManager myConnections;
   };

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

      virtual ~DtAutoHidePanelCreator();

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

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

      virtual DtAutoHidePanel* create(const std::string& name, QWidget* parent);

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