TObjectShapeBase.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/QGraphicsSceneMouseEvent>
 
// ICF includes
#include <istd/CChangeGroup.h>
#include <imod/TSingleModelObserverBase.h>
#include <i2d/IObject2d.h>
#include <icmpstr/TShapeBase.h>
 
 
namespace icmpstr
{
 
 
template <class GraphicsItemClass, class ObjectClass>
class TObjectShapeBase: 
            public TShapeBase<GraphicsItemClass>,
            public imod::TSingleModelObserverBase<ObjectClass>
{
public:
    typedef TShapeBase<GraphicsItemClass> BaseClass;
    typedef imod::TSingleModelObserverBase<ObjectClass> BaseClass2;
 
    TObjectShapeBase(bool isEditable = false, const ISceneProvider* providerPtr = nullptr);
 
protected:
    void DoShapeUpdate();
 
    // reimplemented (TShapeBase)
    void OnSelectionChanged(bool isSelected) override;
    void OnPositionChanged(const QPointF& position) override;
 
    // reimplemented (QGraphicsItem) 
    QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value) override;
    void mousePressEvent(QGraphicsSceneMouseEvent* eventPtr) override;
    void mouseReleaseEvent(QGraphicsSceneMouseEvent* eventPtr) override;
    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* eventPtr) override;
 
    // reimplemented (imod::IObserver)
    bool OnModelAttached(imod::IModel* modelPtr, istd::IChangeable::ChangeSet& changeMask) override;
    void AfterModelChange(imod::IModel* modelPtr, const istd::IChangeable::ChangeSet& changeSet) override;
 
    // abstract methods
    virtual void UpdateGraphicsItem(const ObjectClass& object) = 0;
 
private:
    QPointF m_lastPosition;
 
    bool m_isShapeUpdateBlocked;
 
    std::unique_ptr<istd::CChangeGroup> m_dragNotifierPtr;
 
    static const istd::IChangeable::ChangeSet s_moveObjectChangeSet;
};
 
 
// public methods
 
template <class GraphicsItemClass, class ObjectClass>
TObjectShapeBase<GraphicsItemClass, ObjectClass>::TObjectShapeBase(bool isEditable, const ISceneProvider* providerPtr)
:   BaseClass(isEditable, providerPtr),
    m_isShapeUpdateBlocked(false)
{
    BaseClass::SetPen(BaseClass::InactiveColor, QPen(Qt::darkGreen, 0));
    BaseClass::SetPen(BaseClass::EditableColor, QPen(Qt::green, 0));
    BaseClass::SetPen(BaseClass::SelectedColor, QPen(Qt::yellow, 0));
 
    if (isEditable){
        BaseClass::setFlags(BaseClass::ItemIsMovable | BaseClass::ItemIsSelectable | BaseClass::ItemSendsGeometryChanges);
        BaseClass::setCursor(QCursor(Qt::ArrowCursor)); 
 
        BaseClass::SwitchColorSheme(BaseClass::EditableColor);
    }
    else{
        BaseClass::SwitchColorSheme(BaseClass::InactiveColor);
    }
}
 
 
// protected methods
 
template <class GraphicsItemClass, class ObjectClass>
void TObjectShapeBase<GraphicsItemClass, ObjectClass>::DoShapeUpdate()
{
    if (auto* objectPtr = BaseClass2::GetObservedObject()){
        m_isShapeUpdateBlocked = true;
 
        UpdateGraphicsItem(*objectPtr);
 
        m_isShapeUpdateBlocked = false;
 
        BaseClass::update();
    }
}
 
 
// reimplemented (TShapeBase<GraphicsItemClass, ObjectClass>) 
 
template <class GraphicsItemClass, class ObjectClass>
void TObjectShapeBase<GraphicsItemClass, ObjectClass>::OnSelectionChanged(bool isSelected)
{
    if (isSelected){
        BaseClass::SwitchColorSheme(BaseClass::SelectedColor);
    }
    else{
        if (BaseClass::IsEditable()){
            BaseClass::SwitchColorSheme(BaseClass::EditableColor);
        }
        else{
            BaseClass::SwitchColorSheme(BaseClass::InactiveColor);      
        }
    }
}
 
 
template <class GraphicsItemClass, class ObjectClass>
void TObjectShapeBase<GraphicsItemClass, ObjectClass>::OnPositionChanged(const QPointF& position)
{
    i2d::IObject2d* objectPtr = BaseClass2::GetObservedObject();
    if (objectPtr != nullptr){
        QPointF offset = position - m_lastPosition;
 
        objectPtr->MoveCenterTo(i2d::CVector2d(offset) + objectPtr->GetCenter());
 
        m_lastPosition = position;
    }
 
    BaseClass::OnPositionChanged(position);
}
 
 
template <class GraphicsItemClass, class ObjectClass>
QVariant TObjectShapeBase<GraphicsItemClass, ObjectClass>::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant& value)
{
    if (!m_isShapeUpdateBlocked){
        return BaseClass::itemChange(change, value);
    }
 
    return value;
}
 
 
template <class GraphicsItemClass, class ObjectClass>
void TObjectShapeBase<GraphicsItemClass, ObjectClass>::mousePressEvent(QGraphicsSceneMouseEvent* eventPtr)
{
    BaseClass::mousePressEvent(eventPtr);
 
    if (BaseClass::IsEditable() && (eventPtr->button() == Qt::LeftButton)){
        m_lastPosition = BaseClass::pos();
 
        m_dragNotifierPtr = std::make_unique<istd::CChangeGroup>(BaseClass2::GetObservedObject(), &s_moveObjectChangeSet);
    }
}
 
 
template <class GraphicsItemClass, class ObjectClass>
void TObjectShapeBase<GraphicsItemClass, ObjectClass>::mouseReleaseEvent(QGraphicsSceneMouseEvent* eventPtr)
{
    BaseClass::mouseReleaseEvent(eventPtr);
 
    m_dragNotifierPtr = nullptr;
}
 
 
template <class GraphicsItemClass, class ObjectClass>
void TObjectShapeBase<GraphicsItemClass, ObjectClass>::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* eventPtr)
{
    BaseClass::mouseDoubleClickEvent(eventPtr);
 
    m_dragNotifierPtr = nullptr;
}
 
 
// reimplemented (imod::IObserver)
 
template <class GraphicsItemClass, class ObjectClass>
bool TObjectShapeBase<GraphicsItemClass, ObjectClass>::OnModelAttached(imod::IModel* modelPtr, istd::IChangeable::ChangeSet& changeMask)
{
    if (BaseClass2::OnModelAttached(modelPtr, changeMask)) {
        DoShapeUpdate();
 
        return true;
    }
 
    return false;
}
 
 
template <class GraphicsItemClass, class ObjectClass>
void TObjectShapeBase<GraphicsItemClass, ObjectClass>::AfterModelChange(imod::IModel* modelPtr, const istd::IChangeable::ChangeSet& changeSet)
{
    Q_ASSERT(!m_isShapeUpdateBlocked);
 
    if (!changeSet.ContainsExplicit(istd::IChangeable::CF_DESTROYING)) {
        DoShapeUpdate();
    }
 
    BaseClass2::AfterModelChange(modelPtr, changeSet);
}
 
 
// static attributes
 
template <class GraphicsItemClass, class ObjectClass>
const istd::IChangeable::ChangeSet TObjectShapeBase<GraphicsItemClass, ObjectClass>::s_moveObjectChangeSet(i2d::IObject2d::CF_OBJECT_POSITION, QObject::tr("Move component"));
 
 
} // namespace icmpstr