toolButtonWrapperWidget.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCommonQt/vrfGuiCommonQt.h>
#include <vrvCoreQt/DtWidgetIconStyleManager.h>

#include <QtWidgets/QFrame>
#include <QtGui/QPixmap>
#include <boost/signals2.hpp>

class QAction;
class QHBoxLayout;
class QAbstractButton;
class QSpacerItem;

namespace makVrf
{
   class DT_DLL_VRFGUICOMMONQT DtToolButtonWrapperWidget : public QWidget
   {
      Q_OBJECT

   public:
      struct Layout
      {
         int spacers = 0;
         QHBoxLayout* layout;
         std::vector<QAbstractButton*> buttons;
         int currentWidth;
         QSpacerItem* spacerItem;
      };

   public:
      DtToolButtonWrapperWidget(makVrv::DtDe& de, QWidget* parent, const Qt::WindowFlags& flags = 0);

      //DTOR
      virtual ~DtToolButtonWrapperWidget();

      template <typename T> T* createPrototype()
      {
         T* b = new T(this);

         b->setFocusPolicy( Qt::NoFocus );
         b->setIconSize(myIconSize);
         b->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);

         return b;
      }

      template <typename T> T* createButton()
      {
         T* b = createPrototype<T>();

         this->myButtons.push_back(b);

         return b;
      }

      template <typename T> T* addAction(const QString& action, bool resetLayout = true)
      {
         T* b = createButton<T>();
         b->setText(action);

         if (resetLayout)
         {
            this->addToLayout(b);
         }

         return b;
      }

      template <typename T> T* addActionWithIcon(const std::string& icon, bool resetLayout = true)
      {
         T* b = createButton<T>();

         makVrv::DtWidgetIconStyleManager::instance(myDe).manageWidget(b, icon);

         if (resetLayout)
         {
            this->addToLayout(b);
         }

         return b;
      }

      template <typename T> T* addAction(const QIcon& icon, bool resetLayout = true)
      {
         T* b = createButton<T>();

         b->setIcon(icon);

         if (resetLayout)
         {
            this->addToLayout(b);
         }

         return b;
      }

      template <typename T> T* addAction(QAction* act, bool resetLayout = true)
      {
         T* b = createButton<T>();
         b->setAutoRaise(true);
         b->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
         b->setDefaultAction(act);

         if (resetLayout)
         {
            this->addToLayout(b);
         }

         return b;
      }

      virtual int rightMarginForLine(int) const;

      virtual void setRightMarginForLine(int margin, int line = -1);

      virtual void removeRightMarginForLine(int line = -1);

      virtual void removeButton(QAbstractButton*, bool resetLayout = true);

      virtual void layoutButtons(bool force = false);

      virtual void setButtons(const std::vector<QAbstractButton*>& buttons, bool deleteCurrentButtons = false);

      virtual void setRightToLeftLayout(bool);
      bool setRightToLeftLayout() const
      {
         return myRightToLeftLayout;
      }

      bool needsLayout() const
      {
         return myNeedsLayout;
      }

      enum SizeMode
      {
         FillAtEnd = 1,    
         SizeToFit = 2,    
         SingleColumn = 3,  
         Center = 4        
      };

      virtual void setSizeMode(SizeMode);
      SizeMode sizeMode() const
      {
         return mySizeMode;
      }

      int buttonsShown() const
      {
         return myButtonsShown;
      }

      const std::vector<QAbstractButton*>& buttons() const
      {
         return myButtons;
      }

      std::vector<QAbstractButton*>& buttons()
      {
         return myButtons;
      }
      
      virtual bool hasButton(QAbstractButton*) const;

      virtual void setIconSize(const QSize&);
      const QSize& iconSize() const
      {
         return myIconSize;
      }

      virtual void setIconSpacing(int);
      int iconSpacing() const
      {
         return myIconSpacing;
      }

      virtual void clear();

      virtual void setUseFixedWidth(bool);
      bool useFixedWidth() const
      {
         return myUseFixedWidth;
      }

      virtual void fixWidth();
      virtual void fixHeight();

      virtual void setFixedButtonWidth(int);
      int fixedButtonWidth() const
      {
         return myFixedButtonWidth;
      }

      virtual void setFixedButtonHeight(int);
      int fixedButtonHeight() const
      {
         return myFixedButtonHeight;
      }

      int layoutHeight() const
      {
         return myLayouts.size() * fixedButtonHeight();
      }

      virtual void setShowMaximum(int);
      int showMaximum() const
      {
         return myShowMaximum;
      }

      virtual void setMaximumLines(int);
      int maximumLines() const
      {
         return myMaximumLines;
      }

      bool reachedMaximum() const
      {
         return myReachedMaximum;
      }

      virtual bool buttonsLeftToDisplay() const;

      int numRows() const
      {
         return myLayouts.size();
      }

      const std::vector<Layout>& layouts() const
      {
         return myLayouts;
      }

      std::vector<Layout>& layouts()
      {
         return myLayouts;
      }

      virtual void setBlockResizeLayout(bool);
      bool blockResizeLayout() const
      {
         return myBlockResizeLayout;
      }

      virtual void setSignalResizeLayout(bool);
      bool signalResizeLayout() const
      {
         return mySignalResizeLayout;
      }

      virtual void setCreateDefaultIcon(bool b);
      bool createDefaultIcon() const
      {
         return myCreateDefaultIcon;
      }

      virtual void setSetToolTipToText(bool);
      bool setToolTipToText() const
      {
         return mySetToolTipToText;
      }

      virtual void setSizeHeightToLayout(bool);
      bool sizeHeightToLayout() const
      {
         return mySizeHeightToLayout;
      }

      boost::signals2::signal<void ()> signal_resizeLayout;
      boost::signals2::signal<void (bool)> signal_maximumReached;

   public:
      boost::signals2::signal<void ()> signal_buttonsLayedOut;
      boost::signals2::signal<void (Layout&, QAbstractButton*)> signal_buttonLayedOut;

   protected slots:
      virtual void layoutFromTimer();

   protected:
      virtual QPixmap createDefaultIcon(const QString&) const;
      virtual void resizeEvent(QResizeEvent*);
      virtual void showEvent(QShowEvent*);
      virtual void addToLayout(QAbstractButton*, bool forceLayout = false);

   protected:
      std::vector<Layout> myLayouts;
      std::vector<QAbstractButton*> myButtons;
      std::map<int, int> myRightMarginForLine;

      QSize myIconSize;
      int myIconSpacing;
      int myMaximumLines;
      bool myNeedsLayout;
      bool myReachedMaximum;
      int myFixedButtonWidth;
      int myFixedButtonHeight;
      bool myRightToLeftLayout;
      int myShowMaximum;
      int myButtonsShown;
      bool myInResize;
      bool mySetTimer;
      bool myBlockResizeLayout;
      bool mySignalResizeLayout;
      bool myUseFixedWidth;
      bool myCreateDefaultIcon;
      bool mySetToolTipToText;
      bool mySizeHeightToLayout = false;

      SizeMode mySizeMode;
      makVrv::DtDe& myDe;
   };
}