TGuiObserverWrap.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#ifndef iqtgui_TGuiObserverWrap_included
#define iqtgui_TGuiObserverWrap_included
 
 
// Qt includes
#include <QtCore/QtGlobal>
#include <QtWidgets/QWidget>
 
// ICF includes
#include <imod/IModelEditor.h>
#include <imod/IModel.h>
 
 
namespace istdgui
{
 
 
template <class Gui, class Observer>
class TGuiObserverWrap:
            public Gui,
            public Observer,
            virtual public imod::IModelEditor
{
public:
    TGuiObserverWrap();
 
    // pseudo-reimplemented (imod::IObserver)
    bool OnModelAttached(imod::IModel* modelPtr, istd::IChangeable::ChangeSet& changeMask) override;
    bool OnModelDetached(imod::IModel* modelPtr) override;
 
protected:
    class [[maybe_unused]] 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)
    void UpdateEditor(const istd::IChangeable::ChangeSet& changeSet) override;
    void UpdateModelFromEditor() const override;
 
    // pseudo-reimplemented (istdgui::CGuiComponentBase)
    void OnGuiShown() override;
    void OnGuiHidden() override;
    void OnGuiRetranslate() override;
    void OnGuiCreated() override;
    void OnGuiDestroyed() override;
 
    // pseudo-reimplemented (imod::IObserver)
    void AfterModelChange(imod::IModel* modelPtr, const istd::IChangeable::ChangeSet& changeSet) override;
 
    // pseudo-reimplemented (imod::IModelEditor)
    bool IsReadOnly() const override;
    void SetReadOnly(bool state) override;
 
protected:
    void SetDisableUiIfReadOnly(bool state);
 
    bool m_isReadOnly;
 
private:
    void DoUpdate(const istd::IChangeable::ChangeSet& changeSet);
 
    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(true),
    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(nullptr));
 
        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);
 
                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(nullptr));
 
    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(nullptr) && !IsUpdateBlocked() && !m_isUpdatePending){
        UpdateBlocker updateBlocker(this);
 
        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);
 
        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 (istdgui::CGuiComponentBase)
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiShown()
{
    Gui::OnGuiShown();
 
    if (Observer::IsModelAttached(nullptr)){
        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(nullptr)){
        OnGuiModelHidden();
    }
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiRetranslate()
{
    UpdateBlocker updateBlocker(this);
 
    Gui::OnGuiRetranslate();
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiCreated()
{
    Gui::OnGuiCreated();
 
    if (m_disableUiIfReadOnly){
        QWidget* widgetPtr = Gui::GetWidget();
        Q_ASSERT(widgetPtr != nullptr);
 
        widgetPtr->setEnabled(!m_isReadOnly);
    }
 
    if (Observer::IsModelAttached(nullptr)){
        OnGuiModelAttached();
    }
}
 
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::OnGuiDestroyed()
{
    if (Observer::IsModelAttached(nullptr)){
        OnGuiModelDetached();
    }
 
    Gui::OnGuiDestroyed();
}
 
 
// pseudo-reimplemented (imod::IObserver)
 
template <class Gui, class Observer>
void TGuiObserverWrap<Gui, Observer>::AfterModelChange(imod::IModel* modelPtr, const istd::IChangeable::ChangeSet& changeSet)
{
    Q_ASSERT(modelPtr != nullptr);
    Q_ASSERT(Observer::IsModelAttached(modelPtr));
 
    Observer::AfterModelChange(modelPtr, changeSet);
 
    if (!Gui::IsGuiCreated() || changeSet.ContainsExplicit(istd::IChangeable::CF_DESTROYING)){
        return;
    }
 
    Gui::m_updateGuiCaller.DoCall([this, changeSet]() { 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 != nullptr);
 
        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);
 
    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 istdgui
 
 
#endif // !iqtgui_TGuiObserverWrap_included