TCommonSupplierGuiCompBase.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 iqtinsp_TCommonSupplierGuiCompBase_included
#define iqtinsp_TCommonSupplierGuiCompBase_included
 
 
// Qt includes
#include<QtCore/QtGlobal>
#include<QtCore/QMap>
#include <QtWidgets/QMessageBox>
 
// ICF includes
#include <istd/CChangeNotifier.h>
#include <istd/CChangeGroup.h>
#include <ifile/IFilePersistence.h>
#include <imod/IObserver.h>
#include <iprm/IParamsSet.h>
#include <iinsp/ISupplier.h>
#include <istdgui/IGuiObject.h>
#include <istdgui/TDesignerGuiObserverCompBase.h>
#include <iinspgui/iinspgui.h>
 
 
namespace iinspgui
{
 
 
template <class UI>
class TCommonSupplierGuiCompBase: public istdgui::TDesignerGuiObserverCompBase<UI, iinsp::ISupplier>
{
public:
    typedef istdgui::TDesignerGuiObserverCompBase<UI, iinsp::ISupplier> BaseClass;
 
    I_BEGIN_BASE_COMPONENT(TCommonSupplierGuiCompBase);
        I_ASSIGN(m_paramsLoaderCompPtr, "ParamsLoader", "Loads and saves parameters from and to file", false, "ParamsLoader");
        I_ASSIGN(m_paramsSetGuiCompPtr, "ParamsSetGui", "Shows parameter set", false, "ParamsSetGui");
        I_ASSIGN_TO(m_paramsSetObserverCompPtr, m_paramsSetGuiCompPtr, false);
        I_ASSIGN(m_connectParametersToEditorAttrPtr, "ConnectParametersToEditor", "If enabled, the parameter set of the supplier will be connected to the parameter editor", true, true);
    I_END_COMPONENT;
 
    TCommonSupplierGuiCompBase();
 
protected:
    using BaseClass::GetObservedObject;
 
    bool AreParamsEditable() const;
 
    bool IsLoadParamsSupported() const;
 
    bool IsSaveParamsSupported() const;
 
    bool LoadParams();
 
    bool SaveParams();
 
    bool DoTest();
 
    virtual void UpdateVisualStatus();
 
    virtual void OnSupplierParamsChanged();
 
    virtual void BeforeSupplierGuiUpdated();
 
    // reimplemented (istdgui::TGuiObserverWrap)
    void OnGuiModelAttached() override;
    void OnGuiModelDetached() override;
 
    // reimplemented (imod::IObserver)
    void AfterModelChange(imod::IModel* modelPtr, const istd::IChangeable::ChangeSet& changeSet) override;
 
    // abstract methods
    virtual QWidget* GetParamsWidget() const = 0;
 
protected:
    class ParamsObserver: public imod::CSingleModelObserverBase
    {
    public:
        ParamsObserver(TCommonSupplierGuiCompBase* parentPtr);
 
        using imod::CSingleModelObserverBase::EnsureModelDetached;
 
    protected:
        // reimplemented (imod::CSingleModelObserverBase)
        void OnUpdate(const istd::IChangeable::ChangeSet& changeSet) override;
 
    private:
        TCommonSupplierGuiCompBase& m_parent;
    };
 
    class StatusObserver: public imod::CSingleModelObserverBase
    {
    public:
        StatusObserver(TCommonSupplierGuiCompBase* parentPtr);
 
        using imod::CSingleModelObserverBase::EnsureModelDetached;
 
    protected:
        // reimplemented (imod::CSingleModelObserverBase)
        void OnUpdate(const istd::IChangeable::ChangeSet& changeSet) override;
 
    private:
        TCommonSupplierGuiCompBase& m_parent;
    };
 
    ParamsObserver m_paramsObserver;
    StatusObserver m_statusObserver;
 
protected:
    using BaseClass::m_visualStatus;
 
private:
    I_REF(ifile::IFilePersistence, m_bitmapLoaderCompPtr);
    I_REF(ifile::IFilePersistence, m_paramsLoaderCompPtr);
 
    I_REF(istdgui::IGuiObject, m_paramsSetGuiCompPtr);
    I_REF(imod::IObserver, m_paramsSetObserverCompPtr);
 
    I_ATTR(bool, m_connectParametersToEditorAttrPtr);
 
    bool m_areParamsEditable;
};
 
 
// public methods
 
template <class UI>
TCommonSupplierGuiCompBase<UI>::TCommonSupplierGuiCompBase()
    :m_paramsObserver(this),
    m_statusObserver(this),
    m_areParamsEditable(false)
{
    BaseClass::SetStatusIcon(QIcon(":/IcfIcons/StateUnknown"));
    BaseClass::SetStatusText("Not yet processed");
}
 
 
// protected methods
 
template <class UI>
bool TCommonSupplierGuiCompBase<UI>::AreParamsEditable() const
{
    return m_areParamsEditable;
}
 
 
template <class UI>
bool TCommonSupplierGuiCompBase<UI>::IsLoadParamsSupported() const
{
    const iinsp::ISupplier* supplierPtr = BaseClass::GetObservedObject();
    if ((supplierPtr != nullptr) && m_paramsLoaderCompPtr != nullptr) {
        const iprm::IParamsSet* paramsPtr = supplierPtr->GetModelParametersSet();
        if (paramsPtr != nullptr) {
            if (m_paramsLoaderCompPtr->IsOperationSupported(
                paramsPtr,
                nullptr,
                ifile::IFilePersistence::QF_LOAD | ifile::IFilePersistence::QF_ANONYMOUS)) {
                return true;
            }
        }
    }
 
    return false;
}
 
 
template <class UI>
bool TCommonSupplierGuiCompBase<UI>::IsSaveParamsSupported() const
{
    const iinsp::ISupplier* supplierPtr = BaseClass::GetObservedObject();
    if ((supplierPtr != nullptr) && m_paramsLoaderCompPtr != nullptr) {
        const iprm::IParamsSet* paramsPtr = supplierPtr->GetModelParametersSet();
        if (paramsPtr != nullptr) {
            if (m_paramsLoaderCompPtr->IsOperationSupported(
                paramsPtr,
                nullptr,
                ifile::IFilePersistence::QF_SAVE | ifile::IFilePersistence::QF_ANONYMOUS)) {
                return true;
            }
        }
    }
 
    return false;
}
 
 
template <class UI>
bool TCommonSupplierGuiCompBase<UI>::LoadParams()
{
    iinsp::ISupplier* supplierPtr = BaseClass::GetObservedObject();
    if ((supplierPtr != nullptr) && m_paramsLoaderCompPtr != nullptr) {
        iprm::IParamsSet* paramsPtr = supplierPtr->GetModelParametersSet();
        if (paramsPtr != nullptr) {
            auto loadState = m_paramsLoaderCompPtr->LoadFromFile(*paramsPtr, "");
            if (loadState.WaitForFinished() == iproc::CTaskState::Status::Ready) {
                return true;
            }
            else {
                QMessageBox::warning(
                            BaseClass::GetQtWidget(),
                            QObject::tr("Error"),
                            QObject::tr("Cannot load parameters"));
            }
        }
    }
 
    return false;
}
 
 
template <class UI>
bool TCommonSupplierGuiCompBase<UI>::SaveParams()
{
    const iinsp::ISupplier* supplierPtr = BaseClass::GetObservedObject();
    if ((supplierPtr != nullptr) && m_paramsLoaderCompPtr != nullptr) {
        const iprm::IParamsSet* paramsPtr = supplierPtr->GetModelParametersSet();
        if (paramsPtr != nullptr) {
            auto saveState = m_paramsLoaderCompPtr->SaveToFile(*paramsPtr, "");
            if (saveState.WaitForFinished() != iproc::CTaskState::Status::Failed) {
                return true;
            }
            else {
                QMessageBox::warning(
                            BaseClass::GetQtWidget(),
                            QObject::tr("Error"),
                            QObject::tr("Cannot save parameters"));
            }
        }
    }
 
    return false;
}
 
 
template <class UI>
bool TCommonSupplierGuiCompBase<UI>::DoTest()
{
    iinsp::ISupplier* supplierPtr = BaseClass::GetObservedObject();
    if (supplierPtr != nullptr) {
        istd::CChangeGroup changeGroup(supplierPtr);
 
        supplierPtr->InvalidateSupplier();
        supplierPtr->EnsureWorkInitialized();
        supplierPtr->EnsureWorkFinished();
 
        return supplierPtr->GetWorkStatus() != iinsp::ISupplier::WS_FAILED;
    }
 
    return false;
}
 
 
template <class UI>
void TCommonSupplierGuiCompBase<UI>::UpdateVisualStatus()
{
    QString statusText = "";
    static QIcon unknownIcon(":/IcfIcons/StateUnknown");
    static QIcon warningIcon(":/IcfIcons/StateWarning");
    static QIcon invalidIcon(":/IcfIcons/StateInvalid");
    static QIcon okIcon(":/IcfIcons/StateOk");
 
    QIcon statusIcon = unknownIcon;
 
    QString description;
 
    const iinsp::ISupplier* supplierPtr = BaseClass::GetObservedObject();
    if (supplierPtr != nullptr) {
        const istd::IInformationProvider* infoProviderPtr = dynamic_cast<const istd::IInformationProvider*>(supplierPtr);
        if (infoProviderPtr == nullptr) {
            infoProviderPtr = CompCastPtr<const istd::IInformationProvider>(supplierPtr);
        }
 
        int category = (infoProviderPtr == nullptr) ? istd::IInformationProvider::IC_INFO : infoProviderPtr->GetInformationCategory();
 
        int workStatus = supplierPtr->GetWorkStatus();
 
        switch (workStatus) {
        case iinsp::ISupplier::WS_LOCKED:
            statusText = QObject::tr("Locked");
            break;
 
        case iinsp::ISupplier::WS_OK:
            switch (category) {
            case istd::IInformationProvider::IC_WARNING:
                statusText = QObject::tr("Processing completed with warnings");
                statusIcon = warningIcon;
                break;
 
            case istd::IInformationProvider::IC_ERROR:
                statusText = QObject::tr("Processing completed with errors");
                statusIcon = invalidIcon;
                break;
 
            default:
                statusText = QObject::tr("Processing completed without errors");
                statusIcon = okIcon;
                break;
            }
            break;
 
        case iinsp::ISupplier::WS_CANCELED:
            statusText = QObject::tr("Processing canceled by user");
            break;
 
        case iinsp::ISupplier::WS_FAILED:
            statusText = QObject::tr("Processing not possible");
            statusIcon = invalidIcon;
            break;
 
        default:
            break;
        }
    }
 
    istd::CChangeNotifier visualStatusNotifier(&m_visualStatus);
    BaseClass::SetStatusIcon(statusIcon);
    BaseClass::SetStatusText(statusText);
}
 
 
template <class UI>
void TCommonSupplierGuiCompBase<UI>::OnSupplierParamsChanged()
{
}
 
 
template <class UI>
void TCommonSupplierGuiCompBase<UI>::BeforeSupplierGuiUpdated()
{
}
 
 
// reimplemented (istdgui::TGuiObserverWrap)
 
template <class UI>
void TCommonSupplierGuiCompBase<UI>::OnGuiModelAttached()
{
    BaseClass::OnGuiModelAttached();
 
    iinsp::ISupplier* supplierPtr = BaseClass::GetObservedObject();
    Q_ASSERT(supplierPtr != nullptr);   // model must be attached
 
    iprm::IParamsSet* paramsPtr = const_cast<iprm::IParamsSet*>(supplierPtr->GetModelParametersSet());
    imod::IModel* paramsModelPtr = dynamic_cast<imod::IModel*>(paramsPtr);
 
    m_areParamsEditable = !*m_connectParametersToEditorAttrPtr;
    bool areParamsAttachedToEditor = !*m_connectParametersToEditorAttrPtr;
    QWidget* paramsWidget = GetParamsWidget();
    if (paramsWidget != nullptr) {
        if (m_paramsSetGuiCompPtr != nullptr) {
            m_paramsSetGuiCompPtr->CreateGui(paramsWidget);
        }
 
        if (*m_connectParametersToEditorAttrPtr && (paramsModelPtr != nullptr) && m_paramsSetObserverCompPtr != nullptr) {
            areParamsAttachedToEditor = paramsModelPtr->AttachObserver(m_paramsSetObserverCompPtr.get());
            if (!areParamsAttachedToEditor) {
                qWarning("Supplier parameters could not be connected to the editor");
            }
 
            m_areParamsEditable = true;
 
 
            // Attach internal parameter observer:
            paramsModelPtr->AttachObserver(&m_paramsObserver);
        }
 
        paramsWidget->setVisible(m_areParamsEditable);
        paramsWidget->setEnabled(areParamsAttachedToEditor);
    }
 
    imod::IModel* statusModelPtr = supplierPtr->GetWorkStatusModel();
    if (statusModelPtr != nullptr) {
        statusModelPtr->AttachObserver(&m_statusObserver);
    }
 
    BaseClass::SetStatusIcon(QIcon(":/IcfIcons/StateUnknown"));
}
 
 
template <class UI>
void TCommonSupplierGuiCompBase<UI>::OnGuiModelDetached()
{
    iinsp::ISupplier* supplierPtr = BaseClass::GetObservedObject();
    Q_ASSERT(supplierPtr != nullptr);   // model must be attached
 
    iprm::IParamsSet* paramsPtr = const_cast<iprm::IParamsSet*>(supplierPtr->GetModelParametersSet());
    imod::IModel* paramsModelPtr = dynamic_cast<imod::IModel*>(paramsPtr);
 
    if (m_paramsSetObserverCompPtr != nullptr &&
                (paramsModelPtr != nullptr) &&
                paramsModelPtr->IsAttached(m_paramsSetObserverCompPtr.get())) {
        paramsModelPtr->DetachObserver(m_paramsSetObserverCompPtr.get());
    }
 
    if (m_paramsSetGuiCompPtr != nullptr && m_paramsSetGuiCompPtr->IsGuiCreated()) {
        m_paramsSetGuiCompPtr->DestroyGui();
    }
 
    m_areParamsEditable = false;
 
    m_paramsObserver.EnsureModelDetached();
 
    m_statusObserver.EnsureModelDetached();
 
    BaseClass::OnGuiModelDetached();
}
 
 
// reimplemented (imod::IObserver)
 
template <class UI>
void TCommonSupplierGuiCompBase<UI>::AfterModelChange(imod::IModel* modelPtr, const istd::IChangeable::ChangeSet& changeSet)
{
    if (!BaseClass::IsGuiCreated() || changeSet.ContainsExplicit(istd::IChangeable::CF_DESTROYING)) {
        BaseClass::AfterModelChange(modelPtr, changeSet);
 
        return;
    }
 
    UpdateVisualStatus();
 
    BeforeSupplierGuiUpdated();
 
    BaseClass::AfterModelChange(modelPtr, changeSet);
}
 
 
// public methods of embedded class ParamsObserver
 
template <class UI>
TCommonSupplierGuiCompBase<UI>::ParamsObserver::ParamsObserver(TCommonSupplierGuiCompBase* parentPtr)
    :m_parent(*parentPtr)
{
    Q_ASSERT(parentPtr != nullptr);
}
 
 
// reimplemented (imod::CSingleModelObserverBase)
 
template <class UI>
void TCommonSupplierGuiCompBase<UI>::ParamsObserver::OnUpdate(const istd::IChangeable::ChangeSet& /*changeSet*/)
{
    m_parent.OnSupplierParamsChanged();
}
 
 
// public methods of embedded class StatusObserver
 
template <class UI>
TCommonSupplierGuiCompBase<UI>::StatusObserver::StatusObserver(TCommonSupplierGuiCompBase* parentPtr)
    :m_parent(*parentPtr)
{
    Q_ASSERT(parentPtr != nullptr);
}
 
 
// reimplemented (imod::CSingleModelObserverBase)
 
template <class UI>
void TCommonSupplierGuiCompBase<UI>::StatusObserver::OnUpdate(const istd::IChangeable::ChangeSet& /*changeSet*/)
{
    m_parent.UpdateVisualStatus();
}
 
 
} // namespace iinspgui
 
 
#endif // !iqtinsp_TCommonSupplierGuiCompBase_included