FxBIM.h

Go to the documentation of this file.

//
// (C) Copyright 2020-2022 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
 
#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
 
#include <QtCore/QString>
 
#include <OdaCommon.h>
#include <OdaDefs.h>
#include <DbDatabase.h>
 
#include <sdk/FxBIMEntityReference.h>
 
#if defined (Q_OS_LINUX)
#include <memory>
#endif
 
#if !defined( FX_STATIC_BUILD )
#include "../../Kernel/DDKERNEL/FxThreadUtils.h"
#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;
 
class CFxBIMIPC;
 
struct FXBIM_API Conversion
{
    enum Type
    {
        eNone,
        eConvertFromRevit,
        eConvertFromIfc,
        eConvertToIfc,
    } _c;
 
    using fn_start_t = std::function< void( const OdString& viewName, OdInt64 idView ) >;
    using fn_ready_t = std::function< void( const OdString& dwgPath, const OdString& originalPath, const OdString& viewName, OdInt64 idView, int flags ) >;
    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& err ) >;
 
    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,
    };
    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 );
 
    std::shared_ptr< CFxBIMIPC > _ipc;
};
 
namespace FxBIM
{
    const OdString kBIMModuleName = OD_T( "FxBIM" );
 
    enum Version
    {
        k2019 = 1,
        k2020 = 2,
        k2021 = 3,
        kSP0 = 0,
        kSP1 = 1,
        kSP2 = 2,
        kSP3 = 3,
    };
 
    constexpr OdInt16 kCurrenVersionMajor = k2021;
    constexpr OdInt16 kCurrenVersionMinor = kSP0;
    constexpr OdInt16 kCurrenVersionRevision = 5;
 
    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, 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,
};
 
namespace FxBIM
{
    class FXBIM_API Standard
    {
    public:
        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 );
 
    namespace Units
    {
        FXBIM_API double Scale( BimUnitsLength dst, BimUnitsLength 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 );
 
    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 );
}
 
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 );
}
 
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 );
    FXBIM_API QString GetAbsoluteFilePath( const QString& sPath, OdDbDatabase* pCurrentDb );
}
 
#if !defined( FX_STATIC_BUILD )
namespace FxBIMThreadUtils
{
    void FXBIM_API WaitFinishLoading( const QString& strTag );
 
    class FXBIM_API CFxBIMTaskLoadDbRef : public FxThreadUtils::Task
    {
        CFxBIMDatabaseReferencePtr m_ptrDb;
        QString m_strTag;
 
        CFxBIMTaskLoadDbRef( CFxBIMDatabaseReferencePtr& ptrDb, const QString& strTag );
 
    public:
        ~CFxBIMTaskLoadDbRef() override;
 
        void Process() override;
        void OnFinished() override;
 
        static void clearFinishedTasks();
        static void abortUnfinishedTasks();
        static void pushTask( const OdDbObjectId& idObj, const QString& strTag );
        static QString GetLoadingTag( int count );
        static bool IsLoadingFinishedForTag( const QString& strTag );
    };
 
    class FXBIM_API CFxBIMTaskUnloadDb : public FxThreadUtils::Task
    {
        OdDbDatabasePtr m_ptrDb;
 
    public:
        CFxBIMTaskUnloadDb( OdDbDatabasePtr& ptrDb );
        ~CFxBIMTaskUnloadDb() override;
 
        void Process() override;
        void OnFinished() override;
 
        static void clearFinishedTasks();
        static void abortUnfinishedTasks();
    };
}
#endif