FxViewDrawInfo.h

Go to the documentation of this file.

//
// (C) Copyright 2005-2025 by Graebert GmbH.
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted, 
// provided that the above copyright notice appears in all copies and 
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting 
// documentation.
//
// GRAEBERT PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS. 
// GRAEBERT SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE.  GRAEBERT GMBH 
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
 
#pragma once
 
#include "FxPragmaPush.h"
 
#include "DDKERNEL.h"
 
#include "FxView.h"
 
#include <Ge/GeExtents3d.h>
#include <Gi/GiClipBoundary.h>
#include <Gi/GiCommonDraw.h>
//doesn't have copy constructor and assignment operator
//#include <Gi/GiVisualStyleData.h>
#include <Gi/GiVisualStyle.h>
#include <Gs/Gs.h>
 
#include <DbObjectId.h>
#include <DbRasterVariables.h>
#include <DbStubPtrArray.h>
#include <StringArray.h>
 

 
class CFxDatabase;
 
const double kMAX_VALID_DEPTH_RANGE = 1.0e+250;
 
class DDKERNEL_API CFxViewDrawInfo final
{
public:
    CFxViewDrawInfo();
 
    ~CFxViewDrawInfo(void);
 
    void InitializeView(
        const OdGePoint3d& position,
        const OdGePoint3d& target,
        const OdGeVector3d& upVector,
        double fieldWidth,
        double fieldHeight,
        OdGsView::Projection projectionType = OdGsView::kParallel);
 
    void InitializeViewByExtents( const OdGeExtents3d& extents );
    void InitializeViewByExtentsAndDirection( const OdGeExtents3d& extents, const OdGeVector3d& viewDirection );
 
    void InitializeOutputSize( double width, double height );
 
    void InitializePalette( const ODCOLORREF* pPalette );
 
    void InitializeDatabase( const CFxDatabase* pDatabase );
 
    bool InitializeFromFxView( const CFxView* pFxView );

    bool InitializeFromDbViewport( OdDbObjectId idViewport, int width, int height, bool isPlotGeneration );
 
    bool GetFILLMODE() const
    {
        return m_bFillMode;
    }
 
    bool GetQTEXTMODE() const
    {
        return m_bQTextMode;
    }
 
    bool GetXCLIPFRAME() const
    {
        return m_bXClipFrame;
    }
 
    bool GetDrawImages() const
    {
        return m_bDrawImages;
    }
 
    void SetDrawImages(bool bVal)
    {
        m_bDrawImages = bVal;
    }
 
    bool GetTEXTFILL() const
    {
        return m_bTextFill;
    }
 
    OdInt16 GetFxCadWindowId() const
    {
        return m_FxCadWindowId;
    }
 
    OdDbObjectId GetViewportId() const
    {
        return m_idViewport;
    }
 
    OdDbRasterVariables::FrameSettings GetIMAGEFRAME() const
    {
        return m_iImageFrame;
    }
 
    void SetIMAGEFRAME( OdDbRasterVariables::FrameSettings frameSettings )
    {
        m_iImageFrame = frameSettings;
    }
 
    bool IsPlotGeneration() const;
 
    bool UseGsModel() const
    {
        if ( !m_pFxDatabase )
            return( true );
        return m_bUseGsModel;
    }
 
    void SetUseGsModel( bool bVal )
    {
        m_bUseGsModel = bVal;
    }
 
    void SetUseTransparency( bool value )
    {
        m_bUseTransparency = value;
    }
 
    bool UseTransparency() const
    {
        return m_bUseTransparency;
    }
 
    bool UseLineSmoothing() const
    {
        return m_bUseLineSmoothing;
    }
    
    bool IsInitialUpdate() const
    {
        return m_bInitialUpdate;
    }
 
    bool IsDrawSkipped() const
    {
        return m_bDrawSkipped;
    }
 
    void SetDrawSkipped( bool bVal )
    {
        m_bDrawSkipped = bVal;
    }
 
    bool IsInsideSelect() const
    {
        return m_bIsInsideSelect;
    }
 
    void SetInsideSelect( bool bVal )
    {
        m_bIsInsideSelect = bVal;
    }
 
    OdUInt16 GetVIEWRES() const
    {
        return m_VIEWRES;
    }
 
    bool IsPerspective() const
    {
        return m_bPerspective;
    }
 
    double GetPixelWidth() const
    {
        return m_dPixelWidth;
    }
 
    double GetPixelHeight() const
    {
        return m_dPixelHeight;
    }
 
    double GetVisiblePixelWidth() const
    {
        return m_dVisiblePixelWidth;
    }
 
    double GetVisiblePixelHeight() const
    {
        return m_dVisiblePixelHeight;
    }
 
    double GetFrontClip() const
    {
        return m_dFrontClip;
    }
 
    double GetBackClip() const
    {
        return m_dBackClip;
    }
 
    void SetFrontClip( const double& z )
    {
        m_dFrontClip = z;
    }
 
    void SetBackClip( const double& z )
    {
        m_dBackClip = z;
    }
 
    bool IsFrontClipped() const
    {
        return m_bFrontClipped;
    }
 
    bool IsBackClipped() const
    {
        return m_bBackClipped;
    }
 
    double GetFocalLength() const
    {
        return m_dFocalLength;
    }
 
    const OdGeVector3d& GetViewDir() const
    {
        return m_ViewDir;
    }
 
    const OdGePoint3d& GetPosition() const
    {
        return m_Position;
    }
 
    const OdGeVector3d& GetUpVector() const
    {
        return m_UpVector;
    }
 
    const OdGePoint3d& GetTarget() const
    {
        return m_Target;
    }
 
    double GetFieldWidth() const
    {
        return m_FieldWidth;
    }
 
    double GetFieldHeight() const
    {
        return m_FieldHeight;
    }
 
    bool IsRapidMode() const
    {
        return m_bRapidMode;
    }
 
    const OdGeExtents3d& GetInitialActiveAreaInViewCoordinates() const 
    {
        return m_InitialActiveAreaInViewCoordinates;
    }
 
    //Sets the initial active area to take place in all the possible space.
    //Basically from -inf to +inf.
    void ResetInitialActiveAreaInViewCoordinates();
    void SetInitialActiveAreaInViewCoordinates( const OdGeExtents3d& rect );
 
    void SetInitialActiveAreaByViewport( const CFxView* );
 
    void SetInitialActiveAreaByWCSContour( const CFxView* pFxView, const OdGePoint3d* pointsWCS, int nPoints );
    void SetInitialActiveAreaByEYEContour( const CFxView* pFxView, const OdGePoint2d* pointsEYE, int nPoints );
 
    ODCOLORREF GetBackground() const
    {
        const ODCOLORREF* pPalette = GetPalette();
        ODCOLORREF odColor = pPalette[0];
        return odColor;
    }
 
    ODCOLORREF GetForeground() const
    {
        const ODCOLORREF* pPalette = GetPalette();
        ODCOLORREF odColor = pPalette[7];
        return odColor;
    }
 
    const ODCOLORREF* GetPalette() const
    {
        return (const ODCOLORREF*)(&m_Palette);
    }
 
    ODCOLORREF GetColor( OdUInt16 colorIndex ) const
    {
        return GetPalette()[colorIndex];
    }
 
    OdGsView::RenderMode GetRenderMode() const
    {
        return m_RenderMode;
    }
 
    void SetRenderMode( OdGsView::RenderMode mode );
 
    bool IsDragging() const
    {
        return m_bDragging;
    }
 
    void SetIsDragging( bool bVal )
    {
        m_bDragging = bVal;
    }
 
    bool IsFadeMode() const
    {
        return m_bFadeMode;
    }
 
    void SetFadeMode( bool bVal )
    {
        m_bFadeMode = bVal;
    }
 
    enum DrawDecoration
    {
        kNone               = 0,
        kHidden             = 1,
        kHighlight          = 2,  // use dashed lines
        kNegativeHighlight  = 4,  // use dashed lines and background color
        kTrackHighlight     = 8,  // use thick hatched lines
        kDrawAttDefs        = 16, // draw attdefs
        kDisableDepth       = 32, // disable depth
        kRenderMode2D       = 64, // forces 2d render mode to be used
        kFaded              = 128, // use faded lines
        kXeDangling         = 256, // dangling dimension highlight
        kXeDragHighlight    = 512  // entities being dragged
    };
 
    DrawDecoration GetDrawDecoration() const
    {
        return m_eDrawDecoration;
    }
 
    void SetDrawDecoration( DrawDecoration eDD )
    {
        m_eDrawDecoration = eDD;
    }
 
    bool IsExtentsCalculationActive() const
    {
        return m_bExtentsCalculation;
    }
 
    void SetExtentsCalculationActive( bool bVal )
    {
        m_bExtentsCalculation = bVal;
    }
 
    OdInt32 GetDebugMode() const
    {
        return m_DebugMode;
    }
 
    const CFxDatabase* GetFxDatabase() const
    {
        return m_pFxDatabase;
    }
 
    OdDbStubPtrArray GetFrozenLayerStubs() const;
 
    const OdStringArray& GetFrozenLayerListNames() const;
 
    const OdDbObjectIdArray& GetFrozenLayerList() const
    {
        return m_FrozenLayerList;
    }
 
    void SetFrozenLayerList( const OdDbObjectIdArray& ids )
    {
        m_FrozenLayerList = ids;
    }
 
    bool UseLinetyper() const
    {
        return m_bUseLinetyper;
    }
 
    void SetUseLinetyper( bool bUse)
    {
        m_bUseLinetyper = bUse;
    }
 
    bool UseLineWeights() const
    {
        return m_bUseLineWeights;
    }
 
    void SetUseLineWeights( bool bUse)
    {
        m_bUseLineWeights = bUse;
    }
 
    double GetLineweightToDcScaleOverride() const
    {
        return m_dLineweightToDcScaleOverride;
    }
 
    void SetLineweightToDCScaleOverride(double dLineweightToDCScale = 0)
    {
        m_dLineweightToDcScaleOverride = dLineweightToDCScale;
    }
 
    bool IsOrbitMode() const
    {
        return m_bOrbitMode;
    }
 
    void SetOrbitMode( bool bVal )
    {
        m_bOrbitMode = bVal;
    }
 
    //it is not recommended to use this member
    const CFxView* GetFxView() const
    {
        return m_pFxView;
    }
 
    int GetPDFFRAME() const
    {
        return m_iPDFFrame;
    }
 
    double GetLensLength() const
    {
        return m_dLensLength;
    }
 
    void SetLensLength(double dLensLength)
    {
        m_dLensLength = dLensLength;
    }
 
    const OdGeMatrix3d& GetEyeToOutput() const
    {
        return m_EyeToOutput;
    }
 
    void SetEyeToOutput( const OdGeMatrix3d& rMatrix )
    {
        m_EyeToOutput = rMatrix;
    }
 
    const OdGsDCRectDouble& GetScreenRect() const
    {
        return m_dScreenRect;
    }
 
    const OdGsDCRectDouble& GetVisibleScreenRect() const
    {
        return m_visibleScreenRect;
    }
 
    const OdGsDCRectDouble& GetVisibleScreenRectInViewCoordinates() const
    {
        return m_visibleScreenRectInViewCoordinates;
    }
 
    ViewportKey GetVpNum() const;
 
    static int GetCadWindowId( OdDbObjectId idViewport );
 
    static OdGeMatrix3d GetWorldToEyeMatrix( const CFxViewDrawInfo* pInfo );
 
    static OdGeMatrix3d GetAdjustedProjectionMatrix( const CFxViewDrawInfo* pInfo, double dNearEye, double dFarEye );
 
    static OdGeMatrix3d GetAdjustedViewportMatrix( const CFxViewDrawInfo* pInfo );
    static OdGeMatrix3d GetViewportMatrix( const CFxViewDrawInfo* pInfo );
 
    void SetScalePixelSize( double scale );
 
    bool HardwareTransformationsAllowed() const
    {
        return m_bHardwareTransformationsAllowed;
    }
 
    void AllowHardwareTransformations( bool bVal );
 
    const OdDbObjectId& GetLayoutId( bool &isModel ) const;
 
    bool IsScalingLineweights() const;
 
    void SetClipBoundary( const OdGiClipBoundary * pClipBoundary );
 
    const OdGiClipBoundary * GetClipBoundary() const;
 
    const OdGiVisualStyle& GetVisualStyle() const;
 
protected:
    void InitializeFxDatabase( CFxDatabase* pFxDatabase );
 
    double                  m_dPixelWidth{ 1.0 };
    double                  m_dPixelHeight{ 1.0 };
 
    double                  m_dVisiblePixelWidth{ 1.0 };
    double                  m_dVisiblePixelHeight{ 1.0 };
 
    ODCOLORREF              m_Palette[ 256 ] = { 0 };
 
    OdGeVector3d            m_ViewDir{ 0, 0, 1 };
 
    OdGePoint3d             m_Position{ 0, 0, 1 };
 
    OdGeVector3d            m_UpVector{ 0, 1, 0 };
 
    OdGePoint3d             m_Target{ 0, 0, 0 };
 
    double                  m_FieldWidth{ 1.0 };
 
    double                  m_FieldHeight{ 1.0 };
 
    double                  m_dLensLength{ 50.0 };
 
    OdGsView::RenderMode    m_RenderMode{ OdGsView::k2DOptimized };
 
    bool                    m_bIsInsideSelect{ false };
 
    int                     m_iPDFFrame{ 1 };
 
    OdUInt16                m_VIEWRES{ 10000 };
 
    bool                    m_bPerspective{ false };
 
    bool                    m_bInitialUpdate{ false };
 
    bool                    m_bPlotGeneration{ false };
 
    bool                    m_bFillMode{ true };
 
    bool                    m_bTextFill{ true };
 
    bool                    m_bQTextMode{ false };
 
    bool                    m_bXClipFrame{ false };
 
    bool                    m_bDrawImages{ true };
 
    OdInt16                 m_FxCadWindowId{ 0 };
 
    ViewportKey             m_vpNum{ NullViewportKey };
 
    OdDbObjectId            m_idViewport;
 
    bool                    m_bDrawSkipped{ false };
 
    OdGeExtents3d           m_InitialActiveAreaInViewCoordinates;
 
    double                  m_dFrontClip{ 0.0 };
 
    double                  m_dBackClip{ 0.0 };
 
    bool                    m_bFrontClipped{ false };
 
    bool                    m_bBackClipped{ false };
 
    double                  m_dFocalLength{ 0.0 };
 
    bool                    m_bRapidMode{ false };
 
    OdDbRasterVariables::FrameSettings m_iImageFrame{ OdDbRasterVariables::kImageFrameInvalid };
 
    bool                    m_bUseGsModel{ false };
 
    bool                    m_bFadeMode{ false };
 
    bool                    m_bDragging{ false };
 
    bool                    m_bExtentsCalculation{ false };
 
    DrawDecoration          m_eDrawDecoration{ kNone };
 
    OdInt32                 m_DebugMode{ 0 };
 
    CFxDatabase*            m_pFxDatabase{ nullptr };
 
    OdDbObjectIdArray       m_FrozenLayerList;
    OdStringArray           m_FrozenLayerListNames;
    bool                    m_bInitalizeLayerList{ false };
 
    bool                    m_bUseLinetyper{ true };
 
    bool                    m_bUseLineWeights{ true };
 
    bool                    m_bOrbitMode{ false };
 
    //it is not recommended to use this member
    const CFxView*          m_pFxView{ nullptr };
 
    OdGeMatrix3d            m_EyeToOutput{ OdGeMatrix3d::kIdentity };
 
    OdGsDCRectDouble        m_dScreenRect{ 0.0, 0.0, 0.0, 0.0 };
 
    OdGsDCRectDouble        m_visibleScreenRect{ 0.0, 0.0, 0.0, 0.0 };
 
    OdGsDCRectDouble        m_visibleScreenRectInViewCoordinates{ 0.0, 0.0, 0.0, 0.0 };
 
    bool                    m_bHardwareTransformationsAllowed{ false };
 
    bool                    m_bUseTransparency{ false };
    bool                    m_bUseLineSmoothing{ false };
 
    bool                    m_bIsModel{ true };
 
    OdDbObjectId            m_LayoutId;
 
    double                  m_dLineweightToDcScaleOverride{ 0 };
 
    const OdGiClipBoundary* m_pClipBoundary{ nullptr };
 
    //doesn't have copy constructor and assignment operator
    //OdGiVisualStyleDataContainer m_visualStyle;
    OdGiVisualStylePtr m_pVisualStyle;
};
 
#include "FxPragmaPop.h"