CMultiPageGuiCompBase.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// Qt includes
#include <QtCore/QMap>
#include <QtCore/QVector>
 
// ACF includes
#include <imod/CMultiModelDispatcherBase.h>
#include <imod/CModelUpdateBridge.h>
#include <iprm/IEnableableParam.h>
#include <iprm/CSelectionParam.h>
#include <iprm/COptionsManager.h>
#include <iqtgui/IMultiVisualStatusProvider.h>
#include <iqtgui/CGuiComponentBase.h>
#include <iwidgets/CMultiPageWidget.h>
 
 
namespace iqtgui
{
 
class CMultiPageGuiCompAttr: public iqtgui::CGuiComponentBase
{
public:
       typedef iqtgui::CGuiComponentBase BaseClass;
 
       I_BEGIN_BASE_COMPONENT(CMultiPageGuiCompAttr);
              I_ASSIGN_MULTI_0(m_pageNamesAttrPtr, "Names", "List of the page titles", true);
              I_ASSIGN_MULTI_0(m_pageIdsAttrPtr, "PageIds", "List of unique page IDs", true);
              I_ASSIGN(m_iconSizeAttrPtr, "IconSize", "Size for page icons", false, 16);
              I_ASSIGN(m_useHorizontalLayoutAttrPtr, "UseHorizontalLayout", "Use horizontal layout", true, false);
              I_ASSIGN(m_useSameStretchingFactorAttrPtr, "UseSameStretchingFactor", "Set the same stretching factor for all widgets. Only for group box mode", false, false);
              I_ASSIGN(m_insertSpacerAttrPtr, "InsertSpacer", "If enabled, insert spacer after the last page widget", false, false);
              I_ASSIGN(m_lazyPagesInitializationAttrPtr, "LazyPagesInitialization", "If enabled, CreateGui for a page will be called only when this page will be selected", true, false);
              I_ASSIGN(m_supressPageTitleAttrPtr, "SupressPageTitle", "Supress page title on the container widget", true, false);
              I_ASSIGN(m_defaultPageIndexAttrPtr, "DefaultStartPageIndex", "Index of the start page", true, 0);
              I_ASSIGN(m_filterWheelEventAttrPtr, "FilterWheelEvents", "If true, the container will filter the wheel events for ComboBoxes and SpinBoxes to avoid an accident changing values in them", true, true);
       I_END_COMPONENT;
 
protected:
       I_MULTITEXTATTR(m_pageNamesAttrPtr);
       I_MULTIATTR(QByteArray, m_pageIdsAttrPtr);
       I_ATTR(int, m_iconSizeAttrPtr);
       I_ATTR(bool, m_useHorizontalLayoutAttrPtr);
       I_ATTR(bool, m_useSameStretchingFactorAttrPtr);
       I_ATTR(bool, m_insertSpacerAttrPtr);
       I_ATTR(bool, m_lazyPagesInitializationAttrPtr);
       I_ATTR(bool, m_supressPageTitleAttrPtr);
       I_ATTR(int, m_defaultPageIndexAttrPtr);
       I_ATTR(bool, m_filterWheelEventAttrPtr);
};
 
 
class CMultiPageGuiCompBase:
                     public CMultiPageGuiCompAttr,
                     protected imod::CMultiModelDispatcherBase
{
       Q_OBJECT
public:
       typedef CMultiPageGuiCompAttr BaseClass;
       typedef imod::CMultiModelDispatcherBase BaseClass2;
 
       enum ModelId
       {
              MI_USER = 1000
       };
 
       I_BEGIN_BASE_COMPONENT(CMultiPageGuiCompBase);
              I_REGISTER_SUBELEMENT(PageModel);
              I_REGISTER_SUBELEMENT_INTERFACE_T(PageModel, iprm::ISelectionParam, ExtractPageModel);
              I_REGISTER_SUBELEMENT_INTERFACE_T(PageModel, iprm::IOptionsList, ExtractPageModel);
              I_REGISTER_SUBELEMENT_INTERFACE_T(PageModel, iser::ISerializable, ExtractPageModel);
              I_REGISTER_SUBELEMENT_INTERFACE_T(PageModel, imod::IModel, ExtractPageModel);
              I_REGISTER_SUBELEMENT_INTERFACE_T(PageModel, istd::IChangeable, ExtractPageModel);
              I_REGISTER_SUBELEMENT_INTERFACE_T(PageModel, IMultiVisualStatusProvider, ExtractPageModel);
              I_ASSIGN_MULTI_0(m_slaveWidgetsVisualCompPtr, "GuiVisualInfos", "Provide visual information for each GUI", false);
              I_ASSIGN_TO(m_slaveWidgetsModelCompPtr, m_slaveWidgetsVisualCompPtr, false);
              I_ASSIGN_MULTI_0(m_pageActivatorsCompPtr, "PageActivators", "Optional activators for each page (enable/disable)", false);
              I_ASSIGN_TO(m_pageActivatorsModelCompPtr, m_pageActivatorsCompPtr, false);
              I_ASSIGN_MULTI_0(m_pageVisibilityActivatorsCompPtr, "PageVisibilityActivators", "Optional visibility activators for each page (show/hide)", false);
              I_ASSIGN_TO(m_pageVisibilityActivatorsModelCompPtr, m_pageVisibilityActivatorsCompPtr, false);
              I_ASSIGN(m_defaultPageSelectionCompPtr, "DefaultStartPageSelection", "If connected, it overrides DefaultStartPageIndex", false, "");
       I_END_COMPONENT;
 
       CMultiPageGuiCompBase();
 
       iprm::ISelectionParam& GetPageModelRef();
 
       virtual int GetPagesCount() const = 0;
 
       virtual iqtgui::IGuiObject* GetPageGuiComponent(int pageIndex) const = 0;
 
protected:
       virtual int GetDesignType() const = 0;
 
       virtual int GetLogicalPageIndex(int physicalWidgetIndex) const;
 
       virtual bool CreatePage(int pageIndex);
 
       virtual void RemovePage(int pageIndex);
 
       virtual void SetCurrentPage(int pageIndex);
 
       virtual void UpdateVisualElements();
 
       virtual void CreatePages();
 
       virtual void ResetPages();
 
       // reimplemented (iqtgui::CGuiComponentBase)
       virtual QWidget* CreateQtWidget(QWidget* parentPtr) override;
 
       // reimplemented (iqtgui::CGuiComponentBase)
       virtual void OnGuiCreated() override;
       virtual void OnGuiDestroyed() override;
       virtual void OnGuiRetranslate() override;
       virtual void OnTryClose(bool* ignoredPtr = NULL) override;
 
       // reimplemented (icomp::CComponentBase)
       virtual void OnComponentCreated() override;
       virtual void OnComponentDestroyed() override;
 
       // reimplemented (imod::CMultiModelDispatcherBase)
       virtual void OnModelChanged(int modelId, const istd::IChangeable::ChangeSet& changeSet) override;
 
protected Q_SLOTS:
       virtual void OnPageChanged(int widgetIndex);
 
private:
       class PageModel:
                            public iprm::CSelectionParam,
                            public iprm::IOptionsList,
                            public IMultiVisualStatusProvider
       {
       public:
              typedef iprm::CSelectionParam BaseClass;
 
              PageModel();
 
              void SetParent(CMultiPageGuiCompBase* parentPtr);
              void UpdatePageState();
 
              // reimplemented (iprm::ISelectionParam)
              virtual bool SetSelectedOptionIndex(int index) override;
              virtual ISelectionParam* GetSubselection(int index) const override;
 
              // reimplemented (iprm::IOptionsList)
              virtual int GetOptionsFlags() const override;
              virtual int GetOptionsCount() const override;
              virtual QString GetOptionName(int index) const override;
              virtual QString GetOptionDescription(int index) const override;
              virtual QByteArray GetOptionId(int index) const override;
              virtual bool IsOptionEnabled(int index) const override;
 
              // reimplemented (iqtgui::IMultiVisualStatusProvider)
              virtual int GetStatusesCount() const override;
              virtual const IVisualStatus* GetVisualStatus(int statusIndex) const override;
 
       protected:
              // reimplemented (istd::IChangeable)
              virtual void OnEndChanges(const ChangeSet& changeSet) override;
 
       private:
              CMultiPageGuiCompBase* m_parentPtr;
 
              imod::CModelUpdateBridge m_updateBridge;
       };
 
       template <class InterfaceType>
       static InterfaceType* ExtractPageModel(CMultiPageGuiCompBase& component)
       {
              return &component.m_pageModel;
       }
 
protected:
       bool EnsurePageInitialized(int pageIndex);
 
       I_MULTIREF(IVisualStatus, m_slaveWidgetsVisualCompPtr);
       I_MULTIREF(imod::IModel, m_slaveWidgetsModelCompPtr);
       I_MULTIREF(iprm::IEnableableParam, m_pageActivatorsCompPtr);
       I_MULTIREF(imod::IModel, m_pageActivatorsModelCompPtr);
       I_MULTIREF(iprm::IEnableableParam, m_pageVisibilityActivatorsCompPtr);
       I_MULTIREF(imod::IModel, m_pageVisibilityActivatorsModelCompPtr);
       I_REF(iprm::ISelectionParam, m_defaultPageSelectionCompPtr);
 
       imod::TModelWrap<PageModel> m_pageModel;
 
private:
       struct PageInfo
       {
              PageInfo(): isCreated(false), widgetIndex(-1), widgetPtr(NULL){}
 
              bool isCreated;             // true, if page was created
              QString pageTitle;   // title of this page
              QByteArray pageId;
              int widgetIndex;     // index of widget in widget container
              QWidget* widgetPtr;  // widget whera page contents will be placed
       };
       typedef QMap<int, PageInfo> PageIndexToInfoMap;
       PageIndexToInfoMap m_pageIndexToInfoMap;
};
 
 
} // namespace iqtgui