FxViewDrawInfo.h

Go to the documentation of this file.

//
// (C) Copyright 2005-2020 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 "FxDebug.h"
#include "FxDatabase.h"
#include <Ge/GeExtents3d.h>
#include <Gi/GiClipBoundary.h>
#include <Gi/GiCommonDraw.h>
#include <Gs/Gs.h>
 
#include <DbObjectId.h>
#include <DbRasterVariables.h>
#include <StringArray.h>
#include <DbStubPtrArray.h>
 
class CFxView;
class CFxDatabase;
class CFxPicture;
 
const double kMAX_VALID_DEPTH_RANGE = 1.0e+250;
 
class DDKERNEL_API CFxViewDrawInfo
{
public:
    CFxViewDrawInfo();
 
    virtual ~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 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 );
    inline bool GetFILLMODE() const
    {
        return m_bFillMode;
    }
 
    inline bool GetQTEXTMODE() const
    {
        return m_bQTextMode;
    }
 
    inline bool GetXCLIPFRAME() const
    {
        return m_bXClipFrame;
    }
 
    inline bool GetDrawImages() const
    {
        return m_bDrawImages;
    }
 
    void SetDrawImages(bool bVal)
    {
        m_bDrawImages = bVal;
    }
 
    inline bool GetTEXTFILL() const
    {
        return m_bTextFill;
    }
 
    inline OdInt16 GetFxCadWindowId() const
    {
        return m_FxCadWindowId;
    }
 
    inline OdDbObjectId GetViewportId() const
    {
        return m_idViewport;
    }
 
    inline OdDbRasterVariables::FrameSettings GetIMAGEFRAME() const
    {
        return m_iImageFrame;
    }
 
    inline void SetIMAGEFRAME( OdDbRasterVariables::FrameSettings frameSettings )
    {
        m_iImageFrame = frameSettings;
    }
 
    inline bool IsPlotGeneration() const
    {
        ASSERT( m_bPlotGeneration ? !IsExtentsCalculationActive() : true );
        return m_bPlotGeneration;
    }
 
        inline bool UseGsModel() const
    {
        if ( !m_pFxDatabase )
            return( true );
        return m_bUseGsModel;
    }
                
    virtual void SetUseGsModel( bool bVal )
    {
        m_bUseGsModel = bVal;
    }
 
    void SetUseTransparency( bool value )
    {
        m_bUseTransparency = value;
    }
 
    inline bool UseTransparency() const
    {
        return m_bUseTransparency;
    }
    
    inline bool IsInitialUpdate() const
    {
        return m_bInitialUpdate;
    }
 
    inline bool IsDrawSkipped() const
    {
        return m_bDrawSkipped;
    }
 
    inline void SetDrawSkipped( bool bVal )
    {
        m_bDrawSkipped = bVal;
    }
 
        inline bool IsInsideSelect() const
    {
        return m_bIsInsideSelect;
    }
 
    void SetInsideSelect( bool bVal )
    {
        m_bIsInsideSelect = bVal;
    }
 
    inline OdUInt16 GetVIEWRES() const
    {
        return m_VIEWRES;
    }
 
    inline bool IsPerspective() const
    {
        return m_bPerspective;
    }
 
    inline double GetPixelWidth() const
    {
        return m_dPixelWidth;
    }
 
    inline double GetPixelHeight() const
    {
        return m_dPixelHeight;
    }
 
    inline double GetVisiblePixelWidth() const
    {
        return m_dVisiblePixelWidth;
    }
 
    inline double GetVisiblePixelHeight() const
    {
        return m_dVisiblePixelHeight;
    }
 
    inline double GetFrontClip() const
    {
        return m_dFrontClip;
    }
 
    inline double GetBackClip() const
    {
        return m_dBackClip;
    }
 
    inline void SetFrontClip( const double& z )
    {
        m_dFrontClip = z;
    }
 
    inline void SetBackClip( const double& z )
    {
        m_dBackClip = z;
    }
 
        inline bool IsFrontClipped() const
    {
        return m_bFrontClipped;
    }
 
        inline bool IsBackClipped() const
    {
        return m_bBackClipped;
    }
 
    inline double GetFocalLength() const
    {
        return m_dFocalLength;
    }
    
    inline const OdGeVector3d& GetViewDir() const
    {
        return m_ViewDir;
    }
 
    inline const OdGePoint3d& GetPosition() const
    {
        return m_Position;
    }
 
    inline const OdGeVector3d& GetUpVector() const
    {
        return m_UpVector;
    }
 
    inline const OdGePoint3d& GetTarget() const
    {
        return m_Target;
    }
 
    inline double GetFieldWidth() const
    {
        return m_FieldWidth;
    }
 
    inline double GetFieldHeight() const
    {
        return m_FieldHeight;
    }
 
    inline bool IsRapidMode() const
    {
        return m_bRapidMode;
    }
 
    virtual const OdGeExtents3d& GetInitialActiveAreaInViewCoordinates() const 
    {
        return m_InitialActiveAreaInViewCoordinates;
    }
 
    virtual void SetInitialActiveAreaInViewCoordinates( const OdGeExtents3d& rect ) 
    {
        ASSERT( rect.maxPoint().x > rect.minPoint().x );
        ASSERT( rect.maxPoint().y > rect.minPoint().y );
        m_InitialActiveAreaInViewCoordinates = rect;
    }
 
    virtual 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 )
    {
        m_RenderMode = mode;
    }
 
        inline bool IsDragging() const
    {
        return m_bDragging;
    }
                
    void SetIsDragging( bool bVal )
    {
        m_bDragging = bVal;
    }
 
    inline 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
    };
 
    inline DrawDecoration GetDrawDecoration() const
    {
        return m_eDrawDecoration;
    }
 
    inline void SetDrawDecoration( DrawDecoration eDD )
    {
        m_eDrawDecoration = eDD;
    }
 
    inline bool IsExtentsCalculationActive() const
    {
        return m_bExtentsCalculation;
    }
 
    void SetExtentsCalculationActive( bool bVal )
    {
        m_bExtentsCalculation = bVal;
    }
 
    inline OdInt32 GetDebugMode() const
    {
        return m_DebugMode;
    }
 
    inline 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;
    }
 
    inline bool UseLinetyper() const
    {
        return m_bUseLinetyper;
    }
    void SetUseLinetyper( bool bUse)
    {
        m_bUseLinetyper = bUse;
    }
 
    inline 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;
    }
 
    //it is not recommended to use this member
    inline const CFxView* GetFxView() const
    {
        return m_pFxView;
    }
 
    inline int GetPDFFRAME() const
    {
        return m_iPDFFrame;
    }
 
    inline 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;
    }
 
    inline const OdGsDCRectDouble& GetScreenRect() const
    {
        return m_dScreenRect;
    }
 
    inline const OdGsDCRectDouble& GetVisibleScreenRect() const
    {
        return m_visibleScreenRect;
    }
 
    inline const OdGsDCRectDouble& GetVisibleScreenRectInViewCoordinates() const
    {
        return m_visibleScreenRectInViewCoordinates;
    }
 
    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 );
    
        inline 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;
 
protected:
    double                  m_dPixelWidth;
    double                  m_dPixelHeight;
 
    double                  m_dVisiblePixelWidth;
    double                  m_dVisiblePixelHeight;
 
    ODCOLORREF              m_Palette[256];
 
    OdGeVector3d            m_ViewDir;
 
    OdGePoint3d             m_Position;
 
    OdGeVector3d            m_UpVector;
 
    OdGePoint3d             m_Target;
 
    double                  m_FieldWidth;
 
    double                  m_FieldHeight;
 
    double                  m_dLensLength;
 
    OdGsView::RenderMode    m_RenderMode;
 
        bool                                    m_bIsInsideSelect;
 
    int                     m_iPDFFrame;
 
    OdUInt16                m_VIEWRES;
 
    bool                    m_bPerspective;
 
        bool                                    m_bInitialUpdate;
 
    bool                    m_bPlotGeneration;
 
    bool                    m_bFillMode;
 
    bool                    m_bTextFill;
 
    bool                    m_bQTextMode;
 
    bool                    m_bXClipFrame;
 
    bool                    m_bDrawImages;
 
    OdInt16                 m_FxCadWindowId;
 
    OdDbObjectId            m_idViewport;
 
        bool                                    m_bDrawSkipped;
 
    OdGeExtents3d           m_InitialActiveAreaInViewCoordinates;
 
    double                  m_dFrontClip;
 
    double                  m_dBackClip;
 
    bool                    m_bFrontClipped;
 
    bool                    m_bBackClipped;
 
    double                  m_dFocalLength;
 
    bool                    m_bRapidMode;
 
    OdDbRasterVariables::FrameSettings                     m_iImageFrame;
 
        bool                    m_bUseGsModel;
 
    bool                    m_bFadeMode;
 
    bool                    m_bDragging;
 
    bool                    m_bExtentsCalculation;
 
    DrawDecoration          m_eDrawDecoration;
 
    OdInt32                 m_DebugMode;
 
    CFxDatabase*            m_pFxDatabase;
 
    OdDbObjectIdArray       m_FrozenLayerList;
    OdStringArray           m_FrozenLayerListNames;
    bool                    m_bInitalizeLayerList;
 
    bool                    m_bUseLinetyper;
 
    bool                    m_bUseLineWeights;
 
    //it is not recommended to use this member
    const CFxView*          m_pFxView;
 
    OdGeMatrix3d            m_EyeToOutput;
 
    OdGsDCRectDouble        m_dScreenRect;
 
    OdGsDCRectDouble        m_visibleScreenRect;
 
    OdGsDCRectDouble        m_visibleScreenRectInViewCoordinates;
 
    bool                    m_bHardwareTransformationsAllowed;
 
    bool                    m_bUseTransparency;
 
    bool                    m_bIsModel;
 
    OdDbObjectId            m_LayoutId;
 
    double                  m_dLineweightToDcScaleOverride;
 
    const OdGiClipBoundary* m_pClipBoundary;
};
 
#include "FxPragmaPop.h"