FxBIM.h

Go to the documentation of this file.

//
// (C) Copyright 2020-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 "FxBIMDefs.h"
 
#if defined( QT_VERSION )
#include <QtCore/QString>
#endif
 
#include <OdaCommon.h>
#include <OdaDefs.h>
#include <DbDatabase.h>
#include <DbBlockReference.h>
 
#include "FxBIMEntityReference.h"
 
#include <memory>
#include <map>
#include <vector>
 
class CFxVariant;
class CFxString;
 
enum class Error
{
    eOk = 0,
    eFail,
    eAbort,
    eInvalidParameter,
    eNullFamSymbol,
    eGeomIsNotNode,
    eGeomIsNotGElement,
    eNotImplemented,
    eDegenerateTopology,
    eDegenerateGeometry,
    eNullBmDatabase,
    eNullBmObject,
    eNullBmObjectId,
    eNullDbObjectId,
    eNotFound,
    eNotThatKindOfClass,
    eWrongIFCFormat,
    eWrongRVTFormat,
    eCVTInvalidParameter,
    eCVTInvalidConversionType,
    eCVTInvalidSource,
    eCVTInvalidDestinationFolder,
    eCVTInvalidDestinationExists,
    eCVTViewUnset,
    eCVTUnsupportedPlatform,
    eWrongTRBGeometryDefinition,
    eUnsupportedTRBGeometryDefinition,
    eCancelCommmand
};
 
namespace FxBIM
{
    FXBIM_COMMON_CODE_API OdString ToString( const Error& e );
}
 
namespace FxBIM
{
    constexpr auto kBIMModuleName = __OD_T( "FxBIM" ); // `OD_T` involves a C-style cast (potentially `reinterpret_cast`),
                                                       // so it cannot be used in constant expressions.
 
    enum Version
    {
        k2019 = 1,
        k2020 = 2,
        k2021 = 3,
        k2022 = 4,
        k2023 = 5,
        k2024 = 5,
        k2025 = 6,
        kSP0 = 0,
        kSP1 = 1,
        kSP2 = 2,
        kSP3 = 3,
    };
 
    //TODO: verify what version it should be
    constexpr OdInt16 kCurrenVersionMajor = k2025;
    constexpr OdInt16 kCurrenVersionMinor = kSP2;
    constexpr OdInt16 kCurrenVersionRevision = 0; //Versions for all entities
 
    FXBIM_API OdInt64 bimVersion( OdInt16 major, OdInt16 minor, OdInt16 revision );
    FXBIM_API std::tuple<OdInt16, OdInt16, OdInt16> bimVersion( OdInt64 fileVersion );
    FXBIM_API OdInt64 currentVersion();
}
 
#if defined( QT_VERSION )
FXBIM_COMMON_CODE_API OdString convert( const QString& qstr );
FXBIM_COMMON_CODE_API QString convert( const OdString& odstr );
#endif
 
class CFxBIMObject;
typedef std::shared_ptr< CFxBIMObject > CFxBIMObjectPtr;
 
class FXBIM_API CFxBIMObject : public std::enable_shared_from_this< CFxBIMObject >
{
protected:
    CFxBIMObject();
    virtual ~CFxBIMObject();
};
 
#include <DbObjectId.h>
 
namespace FxBIM
{
    template <typename T>
    std::shared_ptr<T> cast( CFxBIMObjectPtr pBase )
    {
        std::shared_ptr<T> p = std::dynamic_pointer_cast< T, CFxBIMObject >( pBase );
        return( p );
    }
 
    template <typename T>
    OdSmartPtr<T> cast( OdDbObjectId id, OdDb::OpenMode mode = OdDb::kForRead, bool openErased = false )
    {
        OdSmartPtr<T> p = T::cast( id.openObject( mode, openErased ) );
        return( p );
    }
}
 
class CFxBIMIterator;
typedef std::shared_ptr< CFxBIMIterator > CFxBIMIteratorPtr;
class CFxBIMIteratorRA;
typedef std::shared_ptr< CFxBIMIteratorRA > CFxBIMIteratorRAPtr;
class CFxBIMDbIterator;
typedef std::shared_ptr< CFxBIMDbIterator > CFxBIMDbIteratorPtr;
class CFxBIMDbIteratorRA;
typedef std::shared_ptr< CFxBIMDbIteratorRA > CFxBIMDbIteratorRAPtr;
 
#include <functional>
 
class FXBIM_API CFxBIMIterator
{
public:
    virtual ~CFxBIMIterator() {};
    virtual void SetPredicate( std::function< bool( CFxBIMObjectPtr ) > p ) = 0;
    virtual void Start() = 0;
    virtual bool Done() = 0;
    virtual void Next() = 0;
 
    virtual CFxBIMObjectPtr Object() = 0;
};
 
class FXBIM_API CFxBIMIteratorRA
{
public:
    virtual ~CFxBIMIteratorRA() {};
    virtual size_t Count() = 0;
    virtual CFxBIMObjectPtr Object( size_t index ) = 0;
};
 
#include <DbObjectId.h>
 
class FXBIM_API CFxBIMDbIterator
{
public:
    virtual ~CFxBIMDbIterator() {};
    virtual void SetPredicate( std::function< bool( OdDbObjectId ) > p ) = 0;
    virtual void Start() = 0;
    virtual bool Done() = 0;
    virtual void Next() = 0;
 
    virtual OdDbObjectId Object() = 0;
};
 
class FXBIM_API CFxBIMDbIteratorRA
{
public:
    virtual ~CFxBIMDbIteratorRA() {};
    virtual size_t Count() = 0;
    virtual OdDbObjectId Object( size_t index ) = 0;
};
 
enum class BimStandards
{
    eUnset = -2,
    eUnknown = -1,
    eISO = 0,
    eANSI = 1,
};
 
enum class BimUnitsLength
{
    eUndefined = 0,
    eFeet = 1,
    eInch = 2,
    eM = 3,
    eDM = 4,
    eCM = 5,
    eMM = 6,
};
 
enum class BimUnitsStyle
{
    eAuto        = 0, // Will choose the style according the BIMUNITSLENGTH
    eSuperscript = 1, // Force m^2, ft^2 style
    ePrefix      = 2, // Force sq m, sq ft syle
};
 
enum class BimLabelUnitsPolicy
{
    eAuto   = 0,
    eAlways = 1,
    eNever  = 2,
};
 
enum class BimUnitsArea
{
    eUndefined = 0,
    eSqFeet = 1,
    eSqInches = 2,
    eSqMeters = 3,
    eSqDM = 4,
    eSqCM = 5,
    eSqMM = 6
};
 
enum class BimUnitsVolume
{
    //TODO: Update the list
    eUndefined = 0,
    eCubicFeet = 1,
    eCubicInches = 2,
    eCubicMeters = 3,
    eCubicDecimeters = 4,
    eCubicCentimeters = 5,
    eCubicMilimeters = 6,
};
 
enum class EBIMView
{
    e3DView = 0,
    e2DView = 1,
};
 
enum class eBIMOuterWallsPlacement
{
    kMostOuter,
    kAligned
};
 
enum class eBIMSplitDrawingMode
{
    FIRST,
 
    kCustom = FIRST,
    kCenter,
    kFit,
    
    LAST,
};
 
enum class BimLevelSymbolType
{
    eNone = 0,
    eCircle,
    eTriangle,
    eHalfTriangle,
 
    eLast
};
 
enum class BimAutoLabelType
{
    ePlans = 1,
    eSections = 2,
    eElevations = 4,
};
 
namespace FxBIM
{
    FXBIM_COMMON_CODE_API OdString ToString( const BimLevelSymbolType eLevelSymbolType, const bool bForUser = false );
}
 
namespace FxBIM
{
    class FXBIM_API Standard
    {
    public:
        explicit Standard( const OdString& name );
 
        const OdString& Name() const;
        const BimStandards& Type() const;
 
        bool operator< ( const Standard& other ) const;
 
        static OdString ToString( BimStandards standard );
        static BimStandards FromString( const OdString& standard );
 
    protected:
        OdString m_Name;
        BimStandards m_Type = BimStandards::eUnset;
    };
 
    FXBIM_API OdString BIMSTANDARD( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMSTANDARD( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API double BIMHPSCALE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMHPSCALE( OdDbDatabase* pDb, const double& value );
 
    FXBIM_COMMON_CODE_API int BIMUNITSLENGTH( const OdDbDatabase* pDb );
    FXBIM_COMMON_CODE_API void SetBIMUNITSLENGTH( OdDbDatabase* pDb, const int& value );
 
    FXBIM_API int BIMUNITSSTYLE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMUNITSSTYLE( OdDbDatabase* pDb, const int& value );
 
    FXBIM_API OdString BIMVPSCALE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMVPSCALE( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCURRENTDIMSTYLE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCURRENTDIMSTYLE( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMPROJECTPATH( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMPROJECTPATH( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTSFILE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTSFILE( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTBLOCKPLAN( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTBLOCKPLAN( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTBLOCKSECTION( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTBLOCKSECTION( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTBLOCKSECTIONALT( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTBLOCKSECTIONALT( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMCALLOUTBLOCKELEVATION( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTBLOCKELEVATION( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMVIEWTITLEBLOCK( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMVIEWTITLEBLOCK( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMAUTOFILTER( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMAUTOFILTER( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API OdString BIMAUTOTEMPLATE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMAUTOTEMPLATE( OdDbDatabase* pDb, const OdString& value );
 
    FXBIM_API bool BIMAUTOPUBLISH( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMAUTOPUBLISH( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API bool BIMOUTERWALLSCOLLECTINTERNAL( OdDbDatabase* pDb );
    FXBIM_API void SetBIMOUTERWALLSCOLLECTINTERNAL( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API int BIMOUTERWALLSPLACEMENT( OdDbDatabase* pDb );
    FXBIM_API void SetBIMOUTERWALLSPLACEMENT( OdDbDatabase* pDb, int value );
 
    FXBIM_API bool BIMOUTERWALLSJOINDIMENSIONS( OdDbDatabase* pDb );
    FXBIM_API void SetBIMOUTERWALLSJOINDIMENSIONS( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API bool BIMOUTERWALLSISABSOLUTEDISTANCE( OdDbDatabase* pDb );
    FXBIM_API void SetBIMOUTERWALLSISABSOLUTEDISTANCE( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API double BIMOUTERWALLSABSOLUTEDISTANCE( OdDbDatabase* pDb );
    FXBIM_API void SetBIMOUTERWALLSABSOLUTEDISTANCE( OdDbDatabase* pDb, const double& value );
 
    FXBIM_API int BIMOUTERWALLSCHAINDISTANCES( OdDbDatabase* pDb );
    FXBIM_API void SetBIMOUTERWALLSCHAINDISTANCES( OdDbDatabase* pDb, const int& value );
 
    FXBIM_API bool BIMADDDEFAULTLEVELS( OdDbDatabase* pDb );
    FXBIM_API void SetBIMADDDEFAULTLEVELS( OdDbDatabase* pDb, const bool& value );
}
 
namespace FxBIM
{
    FXBIM_API bool BIMCALLOUTSONOFF( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCALLOUTSONOFF( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API bool BIMCLIPPINGBOXONOFF( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMCLIPPINGBOXONOFF( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API bool VIEWPORTRESIZEONRELOAD( const OdDbDatabase* pDb );
    FXBIM_API void SetVIEWPORTRESIZEONRELOAD( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API int BIMROOMSECTIONCROSS( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMROOMSECTIONCROSS( OdDbDatabase* pDb, const int& value );
 
    FXBIM_API double BIMBREAKLINESIZE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMBREAKLINESIZE( OdDbDatabase* pDb, const double& value );
 
    FXBIM_API double BIMBREAKLINEOFFSET( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMBREAKLINEOFFSET( OdDbDatabase* pDb, const double& value );
 
    FXBIM_API double BIMBREAKLINEDISTANCE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMBREAKLINEDISTANCE( OdDbDatabase* pDb, const double& value );
 
    FXBIM_API bool BIMSHOWVPEDITWARNING( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMSHOWVPEDITWARNING( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API int BIMSPLITDRAWINGMODE( const OdDbDatabase* db );
    FXBIM_API void SetBIMSPLITDRAWINGMODE( OdDbDatabase* db, const int& value );
 
    FXBIM_API int BIMLEVELSYMBOLTYPE( const OdDbDatabase* db );
    FXBIM_API void SetBIMLEVELSYMBOLTYPE( OdDbDatabase* db, const int& value );
 
    FXBIM_API bool BIMSHOWCREATEPLANWARNING( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMSHOWCREATEPLANWARNING( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API bool BIMAUTOPROCESSESMODE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMAUTOPROCESSESMODE( OdDbDatabase* pDb, const bool& value );
 
    FXBIM_API int BIMAUTOLABELTYPE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMAUTOLABELTYPE( OdDbDatabase* pDb, const int& value );
}
 
namespace FxBIM
{
    enum class EFileType
    {
        eModelDrawing       = 0x0, //Files in 'models' directory
        eFlatshotDrawing    = 0x1  //Files in 'drawings' directory
    };
 
    FXBIM_API Error resolvePath( const OdDbDatabase* pDb, OdString& path, EFileType eFileType );
}
 
namespace FxBIM
{
    FXBIM_API OdString GetAbsoluteFilePath( const OdString& sPath, OdDbDatabase* pCurrentDb );
#if defined( QT_VERSION )
    FXBIM_API QString GetAbsoluteFilePath( const QString& sPath, OdDbDatabase* pCurrentDb );
#endif
}
 
#if !defined( FX_BIM_CONVERTERS )
namespace FxBIM
{
    FXBIM_API Error getRotation( OdDbBlockReferencePtr pBlkRef, double& angle );
    FXBIM_API Error setRotation( OdDbBlockReferencePtr pBlkRef, double angle );
    FXBIM_API Error setMirrorState( OdDbBlockReferencePtr pBlkRef, bool isMirrored );
#if !defined( FX_BIM_CONVERTERS )
    FXBIM_API Error setBlockProperty( OdDbBlockReferencePtr pBlkRef, const CFxString& sName, const CFxVariant& oValue );
    FXBIM_API Error getBlockProperty( const OdDbBlockReferencePtr pBlkRef, const CFxString& sName, CFxVariant& oValue );
#endif
 
    /*
     * Given a database, it tried to find the scale applied to the import. It then return a scale that 
     * can be used for call-outs and labels to have a nice representation
     */
    FXBIM_API double getImportScaleLabel( OdDbDatabasePtr database );
}
 
#endif // !defined( FX_BIM_CONVERTERS )
 
class CFxDocument;
typedef OdSmartPtr< CFxDocument > CFxDocumentPtr;
 
class CFxBIMStorage;
 
class FXBIM_API CFxBIMReactor : virtual public CFxBIMObject
{
public:
    virtual ~CFxBIMReactor() {};
 
    virtual void StorageCreated( CFxBIMStorage* p ) {};
    virtual void StorageLoaded( CFxBIMStorage* p ) {};
};
 
namespace FxBIM 
{
    FXBIM_API Error AddReactor( CFxBIMObjectPtr p );
    FXBIM_API Error RemoveReactor( CFxBIMObjectPtr p );
 
    FXBIM_API OdDbObjectId GetDetailDashedLineType( OdDbDatabasePtr pDb );
    FXBIM_API OdDbObjectId GetGridLineDashedLineType( OdDbDatabasePtr pDb );
 
    struct CFxSectionWallJoinImpl
    {
        virtual void JoinWalls( CFxDocumentPtr pFxDoc ) = 0;
    };
 
    using CFxSectionWallJoinImplPtr = std::shared_ptr< CFxSectionWallJoinImpl >;
 
    FXBIM_API void SetWallJoiner( CFxSectionWallJoinImplPtr pWallJoiner );
    FXBIM_API CFxSectionWallJoinImplPtr GetWallJoiner();
} // namespace FxBIM