CViewBase.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
 
 
// ACF includes
#include <i2d/CRectangle.h>
 
#include <iview/IDraggable.h>
#include <iview/IMouseActionObserver.h>
#include <iview/CScreenTransform.h>
#include <iview/CViewLayer.h>
#include <iview/CInteractiveViewLayer.h>
#include <istd/TSmartPtr.h>
 
 
class QPainter;
 
 
namespace iview
{
 
 
class IViewEventObserver;
class ISelectableLayer;
class IInteractiveShape;
 
 
class CViewBase:
                     virtual public IShapeView,
                     virtual public IDraggable,
                     protected IMouseActionObserver
{
public:
       enum ZoomMode{
              ZM_RESET,
              ZM_ZOOM_IN,
              ZM_ZOOM_OUT,
              ZM_FIT,
              ZM_FIT_COVER,
              ZM_FIT_UNPROP,
              ZM_FIT_H,
              ZM_FIT_V
       };
 
       CViewBase();
       virtual ~CViewBase();
 
 
       void SetExternalScreenTransform(const istd::TSmartPtr<iview::CScreenTransform>& screenTransformPtr);
 
       void CenterTo(const iview::IShape& shape);
 
       int GetBackgroundLayerIndex() const;
 
       int GetInactiveLayerIndex() const;
 
       int GetActiveLayerIndex() const;
 
       // reimplemented (iview::IShapeView)
       virtual void AddViewEventObserver(iview::IViewEventObserver* listenerPtr) override;
       virtual void RemoveViewEventObserver(iview::IViewEventObserver* listenerPtr) override;
       virtual void SetZoom(ZoomMode zoom);
       virtual void SetEditMode(int mode) override;
       virtual void SetDisplayMode(int mode) override;
       virtual void Update() override;
       virtual void UpdateAllShapes(const istd::IChangeable::ChangeSet& changeSet);
       virtual void SetScreenPosition(const i2d::CVector2d& client, istd::CIndex2d screen);
       virtual const i2d::CRectangle& GetFitArea() const;
       virtual void SetFitArea(const i2d::CRectangle& area) override;
       virtual void SetViewDraggable(bool state = true);
       virtual void SetMultiselectable(bool state = true);
       virtual void SetDraggable(bool state = true);
       virtual void InsertDefaultLayers();
       virtual bool IsViewDraggable() const override;
       virtual bool IsMultiselectable() const override;
       virtual int InsertLayer(IViewLayer* layerPtr, int index = -1, int layerType = IViewLayer::LT_NONE) override;
       virtual int GetLayerIndex(const IViewLayer& layer) const override;
       virtual int GetLayerIndex(int layerType) const override;
       virtual void RemoveLayer(int index) override;
       virtual int GetLayersCount() const override;
       virtual IViewLayer& GetLayer(int index) const override;
       virtual bool ConnectShape(IShape* shapePtr) override;
       virtual ISelectableLayer* GetFocusedLayerPtr() const override;
       virtual void OnLayerShapeFocused(IInteractiveShape* shapePtr, ISelectableLayer* layerPtr) override;
       virtual void OnLayerShapeDefocused(IInteractiveShape* shapePtr, ISelectableLayer* layerPtr) override;
       virtual void OnLayerInvalidated(const IViewLayer& layer, const i2d::CRect& prevArea, const i2d::CRect& newArea) override;
 
       // reimplemented (iview::ISelectable)
       virtual int GetSelectedShapesCount() const override;
       virtual void InsertSelectedShapes(SelectedShapes& result) const override;
       virtual void DeselectAllShapes() override;
       virtual int GetKeysState() const override;
       virtual int GetEditMode() const override;
       virtual int GetDisplayMode() const override;
       virtual void OnShapeFocused(IInteractiveShape* /*shapePtr*/) override {}
       virtual void OnShapeDefocused(IInteractiveShape* /*shapePtr*/) override {}
 
       // reimplemented (iview::ITouchable)
       virtual TouchState IsTouched(istd::CIndex2d position) const override;
       virtual QString GetShapeDescriptionAt(istd::CIndex2d position) const override;
       virtual QString GetToolTipAt(istd::CIndex2d) const override;
 
       // reimplemented (iview::IShapeView)
       virtual void SetTransform(const i2d::CAffine2d& transform) override;
       virtual void UpdateMousePointer() override;
 
       // reimplemented (iview::IMouseActionObserver)
       virtual bool OnMouseButton(istd::CIndex2d position, Qt::MouseButton buttonType, bool downFlag) override;
       virtual bool OnMouseMove(istd::CIndex2d position) override;
 
       // reimplemented (iview::IDisplay)
       virtual IDisplay* GetParentDisplayPtr() const override;
       virtual const iview::CScreenTransform& GetTransform() const override;
       virtual i2d::CRect GetBoundingBox() const override;
       virtual const IColorSchema& GetColorSchema() const override;
       virtual void OnAreaInvalidated(const i2d::CRect& prevArea, const i2d::CRect& newArea) override;
 
       // reimplemented (iview::IShapeObserver)
       virtual void OnChangeShape(IShape* shapePtr) override;
       virtual bool DisconnectShape(IShape* shapePtr) override;
       virtual void OnShapeSelected(IInteractiveShape& shape, bool state = true) override;
 
       // reimplemented (iview::IDraggable)
       virtual bool IsDraggable() const override;
       virtual void BeginDrag(const istd::CIndex2d& reference) override;
       virtual void SetDragPosition(const istd::CIndex2d& position) override;
       virtual void EndDrag() override;
 
       // abstract methods
       virtual const IColorSchema& GetDefaultColorSchema() const = 0;
 
protected:
       typedef QVector<IViewLayer*> Layers;
 
       virtual void DrawLayers(QPainter& drawContext, int firstLayer, int lastLayer);
       
       int GetLastBackgroundLayerIndex() const;
       void SetLastBackgroundLayerIndex(int index);
       
       virtual bool CanBeMoved() const;
 
       void DisconnectAllShapes();
       
       virtual void InvalidateBackground();
 
       virtual void InvalidateBoundingBox();
 
       bool EnsureBoundingBoxValid();
       
       virtual i2d::CRect CalcBoundingBox() const;
 
       virtual void OnBoundingBoxChanged();
 
       virtual MousePointerMode CalcMousePointer(istd::CIndex2d position) const;
 
       virtual bool IsBackgroundBufferValid() const;
 
       virtual void SetBackgroundBufferValid(bool state = true);
 
       const i2d::CRect& GetInvalidatedBox() const;
 
       void InvalidateBox(const i2d::CRect& rect);
 
       void ResetInvalidatedBox();
 
       void SetKeysState(int state);
 
       const Layers& GetLayers() const;
       Layers& GetLayers();
 
       // abstract methods
 
       virtual void SetMousePointer(MousePointerMode mode) = 0;
 
       virtual void UpdateRectArea(const i2d::CRect& rect) = 0;
 
protected:
       enum ViewMode
       {
              VM_NONE,
              VM_DRAG,
              VM_MOVE
       };
 
       bool m_isBackgroundBufferValid;
 
       istd::TSmartPtr<iview::CScreenTransform> m_transformPtr;
 
       ViewMode m_viewMode;
       int m_editMode;
       int m_displayMode;
       i2d::CVector2d m_moveReference;
 
       bool m_isMultiselectable;
       bool m_isViewDraggable;
       bool m_isDraggable;
 
       QVector<iview::IViewEventObserver*> m_viewListeners;
 
       ISelectableLayer* m_focusedLayerPtr;
       int m_backgroundLayerIndex;
       int m_activeLayerIndex;
       int m_inactiveLayerIndex;
 
       i2d::CRect m_invalidatedBox;
       i2d::CRectangle m_fitArea;
 
       int m_lastBackgroundLayerIndex;
 
       iview::IMouseActionObserver* m_mouseActionObserverPtr = nullptr;
 
       // default layers
       iview::CViewLayer m_backgroundLayer;
       iview::CViewLayer m_inactiveLayer;
       iview::CInteractiveViewLayer m_activeLayer;
 
       Layers m_layers;
 
       // help objects
       bool m_isLastMouseButtonDown;
       mutable int m_keysState;
       mutable istd::CIndex2d m_lastMousePosition;
       mutable bool m_isSelectEventActive;
 
       i2d::CRect m_boundingBox;
       bool m_isBoundingBoxValid;
 
       mutable bool m_blockBBoxEvent;
};
 
 
// inline methods
 
inline iview::ISelectableLayer* CViewBase::GetFocusedLayerPtr() const
{
       return m_focusedLayerPtr;
}
 
 
inline void CViewBase::SetExternalScreenTransform(const istd::TSmartPtr<iview::CScreenTransform>& screenTransformPtr)
{
       m_transformPtr = screenTransformPtr;
}
 
 
// reimplemented (iview::IShapeView)
 
inline const i2d::CRectangle& CViewBase::GetFitArea() const
{
       return m_fitArea;
}
 
 
inline void CViewBase::SetFitArea(const i2d::CRectangle& area)
{
       m_fitArea = area;
}
 
 
inline void CViewBase::SetViewDraggable(bool state)
{
       m_isViewDraggable = state;
}
 
 
inline void CViewBase::SetMultiselectable(bool state)
{
       m_isMultiselectable = state;
}
 
 
inline void CViewBase::SetDraggable(bool state)
{
       m_isDraggable = state;
}
 
 
inline bool CViewBase::IsViewDraggable() const
{
       return m_isViewDraggable;
}
 
 
inline bool CViewBase::IsMultiselectable() const
{
       return m_isMultiselectable;
}
 
 
inline int CViewBase::GetLayersCount() const
{
       return int(m_layers.size());
}
 
 
inline IViewLayer& CViewBase::GetLayer(int index) const
{
       if (GetLayersCount() <= 0){
              CViewBase* view = const_cast<CViewBase*> (this);
              view->InsertDefaultLayers();
       }
 
       Q_ASSERT((index >= 0) && (index < int(m_layers.size())));
 
       IViewLayer* layerPtr = m_layers[index];
       Q_ASSERT(layerPtr != NULL);
 
       return *layerPtr;
}
 
 
// reimplemented (iview::IDisplay)
 
inline IDisplay* CViewBase::GetParentDisplayPtr() const
{
       return NULL;
}
 
 
inline const iview::CScreenTransform& CViewBase::GetTransform() const
{
       return *m_transformPtr.GetPtr();
}
 
 
inline i2d::CRect CViewBase::GetBoundingBox() const
{
       const_cast<CViewBase*>(this)->EnsureBoundingBoxValid();
 
       return m_boundingBox;
}
 
 
inline const IColorSchema& CViewBase::GetColorSchema() const
{
       return GetDefaultColorSchema();
}
 
 
// reimplemented (iview::ISelectable)
 
inline int CViewBase::GetKeysState() const
{
       return m_keysState;
}
 
 
// reimplemented (iview::IDraggable)
 
inline bool CViewBase::IsDraggable() const
{
       return m_isDraggable;
}
 
 
// protected methods
 
inline int CViewBase::GetLastBackgroundLayerIndex() const
{
       return m_lastBackgroundLayerIndex;
}
 
 
inline void CViewBase::SetLastBackgroundLayerIndex(int index)
{
       m_lastBackgroundLayerIndex = index;
}
 
 
inline int CViewBase::GetBackgroundLayerIndex() const
{
       return m_backgroundLayerIndex;
}
 
 
inline int CViewBase::GetInactiveLayerIndex() const
{
       return m_inactiveLayerIndex;
}
 
 
inline int CViewBase::GetActiveLayerIndex() const
{
       return m_activeLayerIndex;
}
 
 
inline bool CViewBase::IsBackgroundBufferValid() const
{
       return m_isBackgroundBufferValid;
}
 
 
inline void CViewBase::SetBackgroundBufferValid(bool state)
{
       if (state != m_isBackgroundBufferValid){
              if (!state){
                     m_invalidatedBox = GetClientRect();
              }
              m_isBackgroundBufferValid = state;
       }
}
 
 
inline const i2d::CRect& CViewBase::GetInvalidatedBox() const
{
       return m_invalidatedBox;
}
 
 
inline void CViewBase::InvalidateBox(const i2d::CRect& rect)
{
       m_invalidatedBox.Union(rect);
}
 
 
inline void CViewBase::ResetInvalidatedBox()
{
       m_invalidatedBox.Reset();
}
 
 
inline void CViewBase::SetKeysState(int state)
{
       m_keysState = state;
}
 
 
inline const CViewBase::Layers& CViewBase::GetLayers() const
{
       return m_layers;
}
 
 
inline CViewBase::Layers& CViewBase::GetLayers()
{
       return m_layers;
}
 
 
} // namespace iview