toolButtonWrapperWidget.h

Go to the documentation of this file.

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



#pragma once

#include <vrvUtil/signalslib.h>
#include <vrfGuiCoreQt/vrfGuiCoreQt.h>
#include <QWidget>

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

namespace makVrf
{
   class DT_DLL_VRFGUICOREQT DtToolButtonWrapperWidget : public QWidget
   {
      Q_OBJECT

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

   public:
      DtToolButtonWrapperWidget(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* 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 setLeftToRightLayout(bool);
      bool leftToRightLayout() const
      {
         return myLeftToRightLayout;
      }

      bool needsLayout() const
      {
         return myNeedsLayout;
      }

      virtual void setSizeToFit(bool);
      bool sizeToFit() const
      {
         return mySizeToFit;
      }

      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 setFixedButtonWidth(int);
      int fixedButtonWidth() const
      {
         return myFixedButtonWidth;
      }

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

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

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

      bool reachedMaximum() const
      {
         return myReachedMaximum;
      }

      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;
      }

      boost::signal<void ()> signal_resizeLayout;

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

   protected slots:
      virtual void layoutFromTimer();

   protected:
      virtual void resizeEvent(QResizeEvent*);
      virtual void showEvent(QShowEvent*);
      virtual void addToLayout(QAbstractButton*);

   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 mySizeToFit;
      bool myLeftToRightLayout;
      int myShowMaximum;
      int myButtonsShown;
      bool myInResize;
      bool mySetTimer;
      bool myBlockResizeLayout;
      bool mySignalResizeLayout;
   };
}