FxBIM.h

Go to the documentation of this file.

#pragma once
 
#ifndef _MSC_VER
    #define FXBIM_API
#else
    #if defined( FX_STATIC_BUILD )
        #define FXBIM_API
    #else
        #ifdef FXBIM_EXPORTS
            #define FXBIM_API __declspec(dllexport)
        #else
            #define FXBIM_API __declspec(dllimport)
        #endif
    #endif
#endif
 
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
};
 
enum class FileType
{
    eUnknown = 0,
    eRevit = 1,
    eIFC = 2,
};
 
class OdString;
class OdDbHostAppProgressMeter;
 
#include <functional>
#include <RxObject.h>
 
class CFxBIMDatabaseReference;
typedef OdSmartPtr< CFxBIMDatabaseReference > CFxBIMDatabaseReferencePtr;
 
struct FXBIM_API Conversion
{
    enum Type
    {
        eNone,
        eConvertFromRevit,
        eConvertFromIcf,
        eConvertToIcf,
    } _c;
 
    using fn_start_t = std::function< void( const OdString& viewName, OdInt64 idView ) >;
    using fn_ready_t = std::function< void( CFxBIMDatabaseReferencePtr, OdInt64 idView ) >;
    using fn_finish_t = std::function< void( int exitCode, int exitStatus ) >;
    using fn_abort_t = std::function< bool() >;
    using fn_error_t = std::function< void( const OdString& error ) >;
 
    struct Data
    {
        fn_start_t _fnStart = nullptr;
        fn_ready_t _fnReady = nullptr;
        fn_finish_t _fnFinish = nullptr;
        fn_abort_t _fnAbort = nullptr;
        fn_error_t _fnError = nullptr;
        OdDbHostAppProgressMeter* _pProgress = 0;
    } _d;
 
    enum Flags
    {
        eFNone,
        eFMultipleViews = 0x1,
    };
    int _flags = eFNone;
 
    Conversion();
    explicit Conversion( FileType type, Data data, int flags );
 
    static Conversion::Type FromString( const OdString& arg );
    static OdString ToString( const Conversion& c );
};
 
namespace FxBIM
{
    static OdString kBIMModuleName = OD_T( "FxBIM" );
 
    enum Version
    {
        k2019 = 1,
        k2020 = 2,
        k2021 = 3,
        kSP0 = 0,
        kSP1 = 1,
        kSP2 = 2,
        kSP3 = 3,
    };
 
    static OdInt16 kCurrenVersionMajor = k2020;
    static OdInt16 kCurrenVersionMinor = kSP3;
    static OdInt16 kCurrenVersionRevision = 1;
 
    FXBIM_API OdInt64 bimVersion( OdInt16 major, OdInt16 minor, OdInt16 revision );
    FXBIM_API OdInt64 currentVersion();
}
 
FXBIM_API OdString convert( const QString& qstr );
FXBIM_API QString convert( const OdString& odstr );
 
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 )
    {
        OdSmartPtr<T> p = T::cast( id.openObject( mode ) );
        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 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 size_t Count() = 0;
    virtual CFxBIMObjectPtr Object( size_t index ) = 0;
};
 
#include <DbObjectId.h>
 
class FXBIM_API CFxBIMDbIterator
{
public:
    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 size_t Count() = 0;
    virtual OdDbObjectId Object( size_t index ) = 0;
};
 
namespace FxBIM
{
    FXBIM_API double BIMHPSCALE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMHPSCALE( OdDbDatabase* pDb, const double& value );
 
    namespace Units
    {
        enum
        {
            eLengthUndefined = 0,
            eLengthFeet = 1,
            eLengthInch = 2,
            eLengthM = 3,
            eLengthDM = 4,
            eLengthCM = 5,
            eLengthMM = 6,
        };
 
        FXBIM_API double Scale( int dst, int src );
    };
 
    FXBIM_API int BIMUNITSLENGTH( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMUNITSLENGTH( OdDbDatabase* pDb, const int& value );
 
    FXBIM_API OdString BIMVPSCALE( const OdDbDatabase* pDb );
    FXBIM_API void SetBIMVPSCALE( OdDbDatabase* pDb, const OdString& value );
};