TShapeParamsGuiCompBase.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.
********************************************************************************/
 
#pragma once
 
 
// Qt includes
#include <QtCore/QtGlobal>
#include <QtWidgets/QMenu>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QToolButton>
#include <QtWidgets/QToolBar>
 
// ICF includes
#include <i2d/ICalibration2d.h>
#include <istdgui/TDesignerGuiObserverCompBase.h>
#include <iview/IColorSchema.h>
#include <iview/IShapeFactory.h>
#include <iview/CInteractiveShapeBase.h>
#include <i2dgui/TViewExtenderCompBase.h>
#include <iprm/IEnableableParam.h>
 
 
namespace i2dgui
{
 
 
template <class Ui, class Shape, class ShapeModel>
class TShapeParamsGuiCompBase:
    public i2dgui::TViewExtenderCompBase<
    istdgui::TDesignerGuiObserverCompBase<Ui, ShapeModel> >,
    virtual public iview::IShapeFactory
{
public:
    typedef i2dgui::TViewExtenderCompBase<istdgui::TDesignerGuiObserverCompBase<Ui, ShapeModel> > BaseClass;
 
    I_BEGIN_BASE_COMPONENT(TShapeParamsGuiCompBase);
        I_REGISTER_INTERFACE(iview::IShapeFactory);
        I_ASSIGN(m_defaultUnitInfoCompPtr, "DefaultUnitInfo", "Provide default information about the logical value units e.g. mm, this will be used if no unit information found in model", false, "DefaultUnitInfo");
        I_ASSIGN(m_colorSchemaCompPtr, "ShapeColorSchema", "Color schema used by displayed shape", false, "ShapeColorSchema");
        I_ASSIGN(m_fixedPositionAttrPtr, "FixedPosition", "If enabled, the shape position will be not editable", true, false);
        I_ASSIGN(m_fixedPositionParamPtr, "FixedPositionParam", "If set, will be used instead of FixedPosition attribute", false, "FixedPositionParam");
        I_ASSIGN(m_allowToolsMenuAttrPtr, "ShowTools", "Show extended shape edit tools", true, true);
        I_ASSIGN(m_toolBarGuiCompPtr, "ToolBarGui", "Toolbar GUI object to fill with actions", false, "ToolBarGui");
        I_ASSIGN(m_shapeToolTipAttrPtr, "ShapeToolTip", "Tool tip will be show on console", false, "");
    I_END_COMPONENT;
 
    TShapeParamsGuiCompBase();
 
    // reimplemented (imod::IObserver)
    bool OnModelAttached(imod::IModel* modelPtr, istd::IChangeable::ChangeSet& changeMask) override;
    bool OnModelDetached(imod::IModel* modelPtr) override;
 
    // reimplemented (iview::IShapeFactory)
    std::unique_ptr<iview::IShape> CreateShape(const istd::IChangeable* objectPtr, bool connectToModel = false) const override;
 
protected:
    typedef typename BaseClass::Shapes Shapes;
    typedef typename BaseClass::ShapesMap ShapesMap;
 
    QString GetUnitName() const;
    bool IsPositionFixed() const;
    bool IsToolsMenuAllowed() const;
    QToolBar* GetToolBar() const;
 
    virtual void CreateToolsMenu(QAbstractButton* buttonPtr);
    virtual bool PopulateActions(QWidget& host, imod::IModel* modelPtr);
    virtual void OnModelAttachedAndGuiShown(imod::IModel* modelPtr);
    virtual void OnModelDetachedOrGuiHidden(imod::IModel* modelPtr);
    virtual void OnActionTriggered(QAction* actionPtr);
 
    virtual std::unique_ptr<iview::IShape> CreateShapeInstance() const;
 
    // reimplemented (i2dgui::TViewExtenderCompBase)
    void CreateShapes(int sceneId, Shapes& result) override;
 
    // reimplemented (istdgui::CGuiComponentBase)
    void OnGuiDestroyed() override;
    void OnGuiShown() override;
    void OnGuiHidden() override;
 
    // reimplemented (istdgui::TGuiObserverWrap)
    void OnGuiModelAttached() override;
    void OnGuiModelDetached() override;
 
    // reimplemented (imod::IModelEditor)
    void SetReadOnly(bool state) override;
 
private:
    QMenu* m_menuPtr;
    QAbstractButton* m_menuButtonPtr;
 
    typedef QSet<QAction*> Actions;
    Actions m_toolBarActions;
 
    I_REF(imath::IUnitInfo, m_defaultUnitInfoCompPtr);
    I_REF(iview::IColorSchema, m_colorSchemaCompPtr);
    I_REF(iprm::IEnableableParam, m_fixedPositionParamPtr);
    I_ATTR(bool, m_fixedPositionAttrPtr);
    I_ATTR(bool, m_allowToolsMenuAttrPtr);
    I_REF(istdgui::IGuiObject, m_toolBarGuiCompPtr);
    I_TEXTATTR(m_shapeToolTipAttrPtr);
};
 
 
// public methods
 
template <class Ui, class Shape, class ShapeModel>
TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::TShapeParamsGuiCompBase()
:   m_menuPtr(nullptr),
    m_menuButtonPtr(nullptr)
{
}
 
 
// reimplemented (imod::IObserver)
 
template <class Ui, class Shape, class ShapeModel>
bool TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnModelAttached(imod::IModel* modelPtr, istd::IChangeable::ChangeSet& changeMask)
{
    if (BaseClass::OnModelAttached(modelPtr, changeMask)) {
        const ShapesMap& shapesMap = BaseClass::GetShapesMap();
        for (typename ShapesMap::const_iterator iter = shapesMap.begin();
                    iter != shapesMap.end();
                    ++iter) {
            const Shapes& shapes = iter.value();
            int shapesCount = shapes.GetCount();
            for (int shapeIndex = 0; shapeIndex < shapesCount; ++shapeIndex) {
                Shape* shapePtr = dynamic_cast<Shape*>(shapes.GetAt(shapeIndex));
                if (shapePtr != nullptr) {
                    if (modelPtr->AttachObserver(shapePtr)) {
                        shapePtr->SetVisible(true);
                    }
                }
            }
        }
 
        return true;
    }
    else {
        return false;
    }
}
 
 
template <class Ui, class Shape, class ShapeModel>
bool TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnModelDetached(imod::IModel* modelPtr)
{
    if (BaseClass::OnModelDetached(modelPtr)) {
        const ShapesMap& shapesMap = BaseClass::GetShapesMap();
        for (typename ShapesMap::const_iterator iter = shapesMap.begin();
                    iter != shapesMap.end();
                    ++iter) {
            const Shapes& shapes = iter.value();
            int shapesCount = shapes.GetCount();
            for (int shapeIndex = 0; shapeIndex < shapesCount; ++shapeIndex) {
                Shape* shapePtr = dynamic_cast<Shape*>(shapes.GetAt(shapeIndex));
                if (shapePtr != nullptr) {
                    if (modelPtr->IsAttached(shapePtr)) {
                        modelPtr->DetachObserver(shapePtr);
                    }
 
                    shapePtr->SetVisible(false);
                }
            }
        }
 
        return true;
    }
    else {
        return false;
    }
}
 
 
// reimplemented (iview::IShapeFactory)
 
template <class Ui, class Shape, class ShapeModel>
std::unique_ptr<iview::IShape> TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::CreateShape(const istd::IChangeable* objectPtr, bool connectToModel) const
{
    std::unique_ptr<iview::IShape> shapePtr = CreateShapeInstance();
    if (auto* interactiveShapePtr = dynamic_cast<iview::CInteractiveShapeBase*>(shapePtr.get())) {
        interactiveShapePtr->SetEditablePosition(!IsPositionFixed());
 
        if (m_colorSchemaCompPtr != nullptr) {
            interactiveShapePtr->SetUserColorSchema(m_colorSchemaCompPtr.get());
        }
 
        if (m_shapeToolTipAttrPtr != nullptr) {
            interactiveShapePtr->SetDefaultDescription(*m_shapeToolTipAttrPtr);
        }
    }
 
    if (connectToModel) {
        imod::IModel* modelPtr = dynamic_cast<imod::IModel*>(const_cast<istd::IChangeable*>(objectPtr));
        if (modelPtr != nullptr) {
            if (modelPtr->AttachObserver(shapePtr.get())) {
                shapePtr->SetVisible(true);
            }
        }
    }
 
    return shapePtr;
}
 
 
// protected methods
 
template <class Ui, class Shape, class ShapeModel>
bool TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::IsPositionFixed() const
{
    if (m_fixedPositionParamPtr != nullptr) {
        return m_fixedPositionParamPtr->IsEnabled();
    }
 
    return *m_fixedPositionAttrPtr;
}
 
 
template <class Ui, class Shape, class ShapeModel>
bool TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::IsToolsMenuAllowed() const
{
    return *m_allowToolsMenuAttrPtr;
}
 
 
template <class Ui, class Shape, class ShapeModel>
QToolBar* TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::GetToolBar() const
{
    return m_toolBarGuiCompPtr != nullptr ? dynamic_cast<QToolBar*>(m_toolBarGuiCompPtr->GetWidget()) : nullptr;
}
 
 
template <class Ui, class Shape, class ShapeModel>
QString TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::GetUnitName() const
{
    const imath::IUnitInfo* unitInfoPtr = nullptr;
 
    const ShapeModel* objectPtr = BaseClass::GetObservedObject();
    if (objectPtr != nullptr) {
        const i2d::ICalibration2dProvider* calibrationProviderPtr = dynamic_cast<const i2d::ICalibration2dProvider*>(objectPtr);
        if (calibrationProviderPtr != nullptr) {
            const i2d::ICalibration2d* calibrationPtr = calibrationProviderPtr->GetCalibration();
            if (calibrationPtr != nullptr) {
                unitInfoPtr = calibrationPtr->GetArgumentUnitInfo();
            }
        }
    }
 
    if (unitInfoPtr != nullptr) {
        return unitInfoPtr->GetUnitName();
    }
 
    if (m_defaultUnitInfoCompPtr != nullptr) {
        return m_defaultUnitInfoCompPtr->GetUnitName();
    }
 
    return QString();
}
 
 
template <class Ui, class Shape, class ShapeModel>
std::unique_ptr<iview::IShape> TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::CreateShapeInstance() const
{
    return std::unique_ptr<iview::IShape>{new Shape()};
}
 
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::CreateToolsMenu(QAbstractButton* buttonPtr)
{
    m_menuButtonPtr = buttonPtr;
 
    if (buttonPtr == nullptr) {
        return;
    }
 
    if (!IsToolsMenuAllowed()) {
        buttonPtr->hide();
        return;
    }
 
    if (m_menuPtr == nullptr) {
        m_menuPtr = new QMenu(buttonPtr);
        QObject::connect(m_menuPtr, SIGNAL(triggered(QAction*)), this, SLOT(OnActionTriggered(QAction*)));
 
        QPushButton* pushButtonPtr = dynamic_cast<QPushButton*>(buttonPtr);
        if (pushButtonPtr != nullptr) {
            pushButtonPtr->setMenu(m_menuPtr);
        }
        else {
            QToolButton* toolButtonPtr = dynamic_cast<QToolButton*>(buttonPtr);
            if (toolButtonPtr != nullptr) {
                toolButtonPtr->setMenu(m_menuPtr);
            }
        }
    }
}
 
 
template <class Ui, class Shape, class ShapeModel>
bool TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::PopulateActions(QWidget& /*host*/, imod::IModel* /*modelPtr*/)
{
    return true;
}
 
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnModelAttachedAndGuiShown(imod::IModel* modelPtr)
{
    if (m_menuPtr != nullptr) {
        m_menuPtr->clear();
 
        if (PopulateActions(*m_menuPtr, modelPtr)) {
            m_menuButtonPtr->setEnabled(true);
        }
        else
            m_menuButtonPtr->setEnabled(false);
    }
 
    QToolBar* toolBarPtr = GetToolBar();
    if (toolBarPtr != nullptr) {
        // get actual toolbar actions
        auto toolbarKeys = toolBarPtr->actions();
        QSet<QAction*> oldActions(toolbarKeys.begin(), toolbarKeys.end());
 
        if (PopulateActions(*toolBarPtr, modelPtr)) {
            auto newToolbarKeys = toolBarPtr->actions();
            // store added actions
            QSet<QAction*> newActions(newToolbarKeys.begin(), newToolbarKeys.end());
            m_toolBarActions = newActions - oldActions;
 
            toolBarPtr->setVisible(true);
 
            // connect toolbar signals ONLY if there is no menu
            // because of a Qt issue, an action added to both of menu and toolbar will emit actionTriggered() signal twice :(
            if (m_menuPtr == nullptr) {
                QObject::connect(toolBarPtr, SIGNAL(actionTriggered(QAction*)), this, SLOT(OnActionTriggered(QAction*)));
            }
        }
        else {
            toolBarPtr->disconnect();
        }
    }
}
 
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnModelDetachedOrGuiHidden(imod::IModel* /*modelPtr*/)
{
    if (m_menuButtonPtr != nullptr) {
        m_menuButtonPtr->setEnabled(false);
    }
 
    QToolBar* toolBarPtr = GetToolBar();
    if (toolBarPtr) {
        toolBarPtr->disconnect();
 
        // depopulate stored actions
        for (Actions::const_iterator iter = m_toolBarActions.constBegin(); iter != m_toolBarActions.constEnd(); ++iter) {
            toolBarPtr->removeAction(*iter);
        }
 
        m_toolBarActions.clear();
    }
}
 
 
// reimplemented (i2dgui::TShapeParamsGuiCompBase)
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnActionTriggered(QAction* /*actionPtr*/)
{
}
 
 
// reimplemented (i2dgui::TViewExtenderCompBase)
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::CreateShapes(int /*sceneId*/, Shapes& result)
{
    bool areShapesVisible = !BaseClass::IsReadOnly();
    auto shapePtr = CreateShape(BaseClass::GetObservedObject(), true);
    if (shapePtr != nullptr) {
        shapePtr->SetVisible(areShapesVisible);
        result.PushBack(shapePtr.release());
    }
}
 
 
// reimplemented (istdgui::CGuiComponentBase)
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnGuiDestroyed()
{
    m_menuButtonPtr = nullptr;
    if (m_menuPtr != nullptr) {
        m_menuPtr->deleteLater();
 
        m_menuPtr = nullptr;
    }
 
    BaseClass::OnGuiDestroyed();
}
 
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnGuiShown()
{
    BaseClass::OnGuiShown();
 
    OnModelAttachedAndGuiShown(BaseClass::GetObservedModel());
}
 
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnGuiHidden()
{
    OnModelDetachedOrGuiHidden(BaseClass::GetObservedModel());
 
    BaseClass::OnGuiHidden();
}
 
 
// reimplemented (istdgui::TGuiObserverWrap)
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnGuiModelAttached()
{
    BaseClass::OnGuiModelAttached();
 
    if (BaseClass::IsGuiShown()) {
        OnModelAttachedAndGuiShown(BaseClass::GetObservedModel());
    }
 
    m_fixedPositionParamPtr.EnsureInitialized();
}
 
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::OnGuiModelDetached()
{
    OnModelDetachedOrGuiHidden(BaseClass::GetObservedModel());
 
    BaseClass::OnGuiModelDetached();
}
 
 
// reimplemented (imod::IModelEditor)
 
template <class Ui, class Shape, class ShapeModel>
void TShapeParamsGuiCompBase<Ui, Shape, ShapeModel>::SetReadOnly(bool state)
{
    BaseClass::SetReadOnly(state);
    BaseClass::SetAllShapesVisible(!state);
}
 
 
} // namespace iview