TGuiObserverWrap.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/QtGlobal>
#if QT_VERSION >= 0x050000
#include <QtWidgets/QWidget>
#else
#include <QtGui/QWidget>
#endif
 
// ACF includes
#include <imod/IModelEditor.h>
#include <imod/IModel.h>
 
 
namespace iqtgui
{
 
 
template <class Gui, class Observer>
class TGuiObserverWrap:
                     public Gui,
                     public Observer,
                     virtual public imod::IModelEditor
{
public:
       TGuiObserverWrap();
 
       // pseudo-reimplemented (imod::IObserver)
       virtual bool OnModelAttached(imod::IModel* modelPtr, istd::IChangeable::ChangeSet& changeMask) override;
       virtual bool OnModelDetached(imod::IModel* modelPtr) override;
 
protected:
       class UpdateBlocker
       {
       public:
              explicit UpdateBlocker(const TGuiObserverWrap<Gui, Observer>* parentPtr);
              ~UpdateBlocker();
 
       private:
              const TGuiObserverWrap<Gui, Observer>& m_parent;
       };
 
       virtual void OnGuiModelShown();
 
       virtual void OnGuiModelHidden();
 
       virtual void OnGuiModelAttached();
 
       virtual void OnGuiModelDetached();
 
       bool IsUpdateBlocked() const;
 
       bool DoUpdateModel() const;
 
       virtual void UpdateModel() const;
 
       virtual void UpdateGui(const istd::IChangeable::ChangeSet& changeSet);
 
       // reimplemented (imod::IModelEditor)
       virtual void UpdateEditor(const istd::IChangeable::ChangeSet& changeSet) override;
       virtual void UpdateModelFromEditor() const override;
 
       // pseudo-reimplemented (iqtgui::CGuiComponentBase)
       virtual void OnGuiShown() override;
       virtual void OnGuiHidden() override;
       virtual void OnGuiRetranslate() override;
       virtual void OnGuiCreated() override;
       virtual void OnGuiDestroyed() override;
 
       // pseudo-reimplemented (imod::IObserver)
       virtual void AfterUpdate(imod::IModel* modelPtr, const istd::IChangeable::ChangeSet& changeSet) override;
 
       // pseudo-reimplemented (imod::IModelEditor)
       virtual bool IsReadOnly() const override;
       virtual void SetReadOnly(bool state) override;
 
protected:
       void SetDisableUiIfReadOnly(bool state);
 
       bool m_isReadOnly;
 
private:
       void DoUpdate(const istd::IChangeable::ChangeSet& changeSet);
 
private:
       bool m_disableUiIfReadOnly;
       mutable int m_ignoreUpdatesCounter;
 
       bool m_isUpdatePending;
 
       istd::IChangeable::ChangeSet m_onShowChangeIds;
};
 
 
// public methods
 
template <class Gui, class Observer>
TGuiObserverWrap<Gui, Observer>::TGuiObserverWrap()
:      m_isReadOnly(false),
       m_disableUiIfReadOnly(true),
       m_ignoreUpdatesCounter(0),
       m_isUpdatePending(false),
       m_onShowChangeIds(istd::IChangeable::GetAllChanges())
{
}
 
 
// pseudo-reimplemented (imod::IObserver)
 
template <class Gui, class Observer>
bool TGuiObserverWrap<Gui, Observer>::OnModelAttached(imod::IModel* modelPtr, istd::IChangeable::ChangeSet& changeMask)
{
       bool retVal = false;
 
       {
              UpdateBlocker block(this);
 
              retVal = Observer::OnModelAttached(modelPtr, changeMask);
       }
 
       if (retVal && Gui::IsGuiCreated()){
              Q_ASSERT(Observer::IsModelAttached(NULL));
 
              OnGuiModelAttached();
       }
 
       return retVal;
}
 
 
template <class Gui, class Observer>
bool TGuiObserverWrap<Gui, Observer>::OnModelDetached(imod::IModel* modelPtr)
{
       if (Observer::IsModelAttached(modelPtr)){
              if (Gui::IsGuiCreated()){
                     if (!m_isReadOnly && !IsUpdateBlocked() && !m_isUpdatePending){
                            UpdateBlocker updateBlocker(this);
                            Q_UNUSED(updateBlocker);
 
                            UpdateModel();
                     }
 
                     OnGuiModelDetached();
              }
       }
 
       return Observer::OnModelDetached(modelPtr);
}
 
 
// protected methods
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiModelShown()
{
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiModelHidden()
{
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiModelAttached()
{
       Q_ASSERT(Gui::IsGuiCreated());
       Q_ASSERT(Observer::IsModelAttached(NULL));
 
       static const istd::IChangeable::ChangeSet initChangeSet(CF_INIT_EDITOR);
       UpdateEditor(initChangeSet);
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiModelDetached()
{
       if (!m_isReadOnly && Observer::IsModelAttached(NULL) && !IsUpdateBlocked() && !m_isUpdatePending){
              UpdateBlocker updateBlocker(this);
              Q_UNUSED(updateBlocker);
 
              UpdateModel();
       }
}
 
 
template <class Gui, class Observer>
bool TGuiObserverWrap<Gui, Observer>::IsUpdateBlocked() const
{
       return (m_ignoreUpdatesCounter > 0);
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::SetDisableUiIfReadOnly(bool state)
{
       m_disableUiIfReadOnly = state;
}
 
 
// provate methods
 
template <class Gui, class Observer>
bool TGuiObserverWrap<Gui, Observer>::DoUpdateModel() const
{
       if (!m_isReadOnly && !IsUpdateBlocked() && Observer::IsModelAttached()){
              UpdateBlocker updateBlocker(this);
              Q_UNUSED(updateBlocker);
 
              UpdateModel();
 
              return true;
       }
 
       return false;
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::UpdateModel() const
{
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::UpdateGui(const istd::IChangeable::ChangeSet& /*changeSet*/)
{
}
 
 
// reimplemented (imod::IModelEditor)
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::UpdateEditor(const istd::IChangeable::ChangeSet& changeSet)
{
       if (Gui::IsGuiShown()){
              DoUpdate(changeSet);
       }
       else{
              // prepare postponed update
              m_isUpdatePending = true;
              m_onShowChangeIds += changeSet;
       }
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::UpdateModelFromEditor() const
{
       if (!m_isReadOnly && !m_isUpdatePending){
              DoUpdateModel();
       }
}
 
 
// pseudo-reimplemented (iqtgui::CGuiComponentBase)
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiShown()
{
       Gui::OnGuiShown();
 
       if (Observer::IsModelAttached(NULL)){
              if (m_isUpdatePending){
                     // skip update if the UI is not visible:
                     DoUpdate(m_onShowChangeIds);
 
                     m_onShowChangeIds.Reset();
 
                     m_isUpdatePending = false;
              }
 
              OnGuiModelShown();
       }
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiHidden()
{
       Gui::OnGuiHidden();
 
       if (Observer::IsModelAttached(NULL)){
              OnGuiModelHidden();
       }
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiRetranslate()
{
       UpdateBlocker updateBlocker(this);
       Q_UNUSED(updateBlocker);
 
       Gui::OnGuiRetranslate();
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiCreated()
{
       Gui::OnGuiCreated();
 
       if (m_disableUiIfReadOnly){
              QWidget* widgetPtr = Gui::GetWidget();
              Q_ASSERT(widgetPtr != NULL);
 
              widgetPtr->setEnabled(!m_isReadOnly);
       }
 
       if (Observer::IsModelAttached(NULL)){
              OnGuiModelAttached();
       }
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiDestroyed()
{
       if (Observer::IsModelAttached(NULL)){
              OnGuiModelDetached();
       }
 
       Gui::OnGuiDestroyed();
}
 
 
// pseudo-reimplemented (imod::IObserver)
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::AfterUpdate(imod::IModel* modelPtr, const istd::IChangeable::ChangeSet& changeSet)
{
       Q_ASSERT(modelPtr != NULL);
       Q_ASSERT(Observer::IsModelAttached(modelPtr));
 
       Observer::AfterUpdate(modelPtr, changeSet);
 
       if (!Gui::IsGuiCreated() || changeSet.ContainsExplicit(istd::IChangeable::CF_DESTROYING)){
              return;
       }
 
       UpdateEditor(changeSet);
}
 
 
// pseudo-reimplemented (imod::IModelEditor)
 
template <class Gui, class Observer>
bool TGuiObserverWrap<Gui, Observer>::IsReadOnly() const
{
       return m_isReadOnly;
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::SetReadOnly(bool state)
{
       m_isReadOnly = state;
 
       if (m_disableUiIfReadOnly && Gui::IsGuiCreated()){
              QWidget* widgetPtr = Gui::GetWidget();
              Q_ASSERT(widgetPtr != NULL);
 
              widgetPtr->setEnabled(!m_isReadOnly);
       }
}
 
 
// private methods
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::DoUpdate(const istd::IChangeable::ChangeSet& changeSet)
{
       if (changeSet.IsEmpty() || IsUpdateBlocked() || !Gui::IsGuiCreated()){
              return;
       }
 
       UpdateBlocker updateBlocker(this);
       Q_UNUSED(updateBlocker);
 
       UpdateGui(changeSet);
}
 
 
// public methods of embedded class UpdateBlocker
 
template <class Gui, class Observer>
TGuiObserverWrap<Gui, Observer>::UpdateBlocker::UpdateBlocker(const TGuiObserverWrap<Gui, Observer>* parentPtr)
:      m_parent(*parentPtr)
{
       ++m_parent.m_ignoreUpdatesCounter;
}
 
 
template <class Gui, class Observer>
TGuiObserverWrap<Gui, Observer>::UpdateBlocker::~UpdateBlocker()
{
       --m_parent.m_ignoreUpdatesCounter;
}
 
 
} // namespace iqtgui