CCalibratedViewBase.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
 
 
// Qt includes
#include <QtGui/QPainter>
 
// ACF includes
#include <istd/TOptDelPtr.h>
#include <i2d/CRect.h>
#include <i2d/ICalibration2d.h>
#include <iview/IVisualCalibrationInfo.h>
#include <iview/IToolsLayerInfo.h>
#include <iview/CViewBase.h>
#include <iview/CDrawBuffer.h>
#include <iview/CColorSchema.h>
#include <iview/CToolsViewLayer.h>
 
 
namespace iview
{
 
 
class CCalibratedViewBase:
                     public CViewBase,
                     virtual public i2d::ICalibrationProvider,
                     virtual public IVisualCalibrationInfo,
                     virtual public IToolsLayerInfo
{
public:
       typedef CViewBase BaseClass;
 
       CCalibratedViewBase();
 
       void SetDisplayCalibration(const i2d::ICalibration2d* calibrationPtr);
 
       virtual void SetGridVisible(bool state = true);
 
       virtual void ConnectCalibrationShape(iview::IShape* shapePtr);
 
       virtual void SetDistanceMeasureToolActive(bool state = true);
 
       virtual void SetPointMeasureToolActive(bool state = true);
 
 
       virtual void ConnectToolShape(iview::IShape* shapePtr);
 
       void SetMinGridDistance(double gridDistance);
 
       void SetGridInMm(bool state = true);
 
       const iview::IViewLayer& GetCalibrationLayer() const;
 
       const iview::IViewLayer& GetToolsLayer() const;
 
       void SetDefaultColorSchema(const IColorSchema* colorSchemaPtr, bool releaseFlag = false);
 
       bool IsBackgroundBufferActive() const;
       void SetBackgroundBufferActive(bool state = true);
       bool IsDoubleBufferActive() const;
       void SetDoubleBufferActive(bool state = true);
 
       const iview::CDrawBuffer& GetBackgroundBuffer() const;
       iview::CDrawBuffer& GetBackgroundBuffer();
       const iview::CDrawBuffer& GetDoubleBuffer() const;
       iview::CDrawBuffer& GetDoubleBuffer();
 
       virtual void OnResize();
       
       void CheckResize();
 
       // reimplemented (iview::CViewBase)
       virtual const iview::IColorSchema& GetDefaultColorSchema() const override;
       virtual void UpdateAllShapes(const istd::IChangeable::ChangeSet& changeSet) override;
       virtual void InsertDefaultLayers() override;
 
       // reimplemented (iview::IShapeView)
       virtual int InsertLayer(iview::IViewLayer* layerPtr, int index = -1, int layerType = IViewLayer::LT_NONE) override;
       virtual void RemoveLayer(int index) override;
 
       // reimplemented (iview::IVisualCalibrationInfo)
       virtual bool IsGridVisible() const override;
       virtual double GetMinGridDistance() const override;
       virtual bool IsGridInMm() const override;
 
       // reimplemented (iview::IToolsLayerInfo)
       virtual bool IsDistanceMeasureToolActive() const override;
       virtual bool IsPointMeasureToolActive() const override;
 
       // reimplemented (i2d::ICalibrationProvider)
       virtual const i2d::ICalibration2d* GetCalibration() const override;
 
       using BaseClass::InvalidateBackground;
 
protected:
       virtual void DrawBuffers(QPaintDevice& nativeContext, const i2d::CRect& clipRect);
       virtual void DrawToContext(QPaintDevice& nativeContext, QPainter& context, const i2d::CRect& invalidatedBox);
 
private:
       mutable istd::TOptDelPtr<const IColorSchema> m_defaultColorSchemaPtr;
 
       iview::CDrawBuffer m_backgroundBuffer;
       iview::CDrawBuffer m_doubleBuffer;
 
       bool m_isBackgroundBufferActive;
       bool m_isDoubleBufferActive;
 
       i2d::CRect m_lastClientArea;
 
       const i2d::ICalibration2d* m_calibrationPtr = nullptr;
       bool m_isGridVisible;
       bool m_isGridInMm;
       double m_minGridDistance;
       bool m_isDistanceMeasureToolActive;
       bool m_isPointMeasureToolActive;
 
       int m_calibrationLayerIndex;
       int m_toolsLayerIndex;
 
       // default layers
       iview::CViewLayer m_calibrationLayer;
       iview::CToolsViewLayer m_toolsLayer;
};
 
 
// inline methods
 
inline void CCalibratedViewBase::SetGridVisible(bool state)
{
       if (m_isGridVisible != state){
              m_isGridVisible = state;
              InvalidateBackground();
       }
}
 
 
inline void CCalibratedViewBase::SetMinGridDistance(double gridDistance)
{
       if (m_minGridDistance != gridDistance){
              m_minGridDistance = gridDistance;
              if (m_isGridVisible){
                     SetBackgroundBufferValid(false);
              }
       }
}
 
 
inline void CCalibratedViewBase::SetGridInMm(bool state)
{
       if (m_isGridInMm != state){
              m_isGridInMm = state;
              SetBackgroundBufferValid(false);
       }
}
 
 
inline const iview::IViewLayer& CCalibratedViewBase::GetCalibrationLayer() const
{
       return m_calibrationLayer;
}
 
 
inline const iview::IViewLayer& CCalibratedViewBase::GetToolsLayer() const
{
       return m_toolsLayer;
}
 
 
inline bool CCalibratedViewBase::IsGridVisible() const
{
       return m_isGridVisible;
}
 
 
inline double CCalibratedViewBase::GetMinGridDistance() const
{
       return m_minGridDistance;
}
 
 
inline bool CCalibratedViewBase::IsGridInMm() const
{
       return m_isGridInMm;
}
 
 
inline bool CCalibratedViewBase::IsDistanceMeasureToolActive() const
{
       return m_isDistanceMeasureToolActive;
}
 
 
inline void CCalibratedViewBase::SetDistanceMeasureToolActive(bool state)
{
       if (state){
              m_isPointMeasureToolActive = false;
       }
 
       if (m_isDistanceMeasureToolActive != state){
              m_isDistanceMeasureToolActive = state;
 
              InvalidateBackground();
       }
}
 
 
inline bool CCalibratedViewBase::IsPointMeasureToolActive() const
{
       return m_isPointMeasureToolActive;
}
 
 
inline void CCalibratedViewBase::SetPointMeasureToolActive(bool state)
{
       if (state){
              m_isDistanceMeasureToolActive = false;
       }
 
       if (m_isPointMeasureToolActive != state){
              m_isPointMeasureToolActive = state;
 
              InvalidateBackground();
       }
}
 
 
// reimplemented (i2d::ICalibrationProvider)
 
inline const i2d::ICalibration2d* CCalibratedViewBase::GetCalibration() const
{
       return m_calibrationPtr;
}
 
 
} // namespace iview