///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance").
|
// All rights reserved.
|
//
|
// This software and its documentation and related materials are owned by
|
// the Alliance. The software may only be incorporated into application
|
// programs owned by members of the Alliance, subject to a signed
|
// Membership Agreement and Supplemental Software License Agreement with the
|
// Alliance. The structure and organization of this software are the valuable
|
// trade secrets of the Alliance and its suppliers. The software is also
|
// protected by copyright law and international treaty provisions. Application
|
// programs incorporating this software must include the following statement
|
// with their copyright notices:
|
//
|
// This application incorporates Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance.
|
// All rights reserved.
|
//
|
// By use of this software, its documentation or related materials, you
|
// acknowledge and accept the above terms.
|
///////////////////////////////////////////////////////////////////////////////
|
|
#ifndef __OD_GS_FILER_H__
|
#define __OD_GS_FILER_H__
|
|
#include "TD_PackPush.h"
|
|
#include "OdStreamBuf.h"
|
#include "Gs/GsExport.h"
|
#include "OdBinaryData.h"
|
#include "OdVector.h"
|
#include "IntArray.h"
|
#include "UInt8Array.h"
|
#include "UInt32Array.h"
|
#include "UInt16Array.h"
|
#include "GsMarkerArray.h"
|
#include "DbStubPtrArray.h"
|
#include "Ge/GePoint2d.h"
|
#include "UInt64Array.h"
|
|
class OdGePoint2d;
|
class OdGeVector2d;
|
class OdGePoint3d;
|
class OdGeVector3d;
|
class OdGeMatrix3d;
|
class OdGeExtents3d;
|
|
class OdDbStub;
|
typedef OdRxObject OdDbBaseDatabase;
|
|
class OdGsView;
|
class OdGsCache;
|
|
class OdGsDCRect;
|
class OdGsDCRectDouble;
|
typedef OdArray<float, OdMemoryAllocator<float> > OdFloatArray;
|
typedef OdArray<OdGePoint2d, OdMemoryAllocator<OdGePoint2d> > OdGePoint2dArray;
|
|
/** <group OdGs_Classes>
|
*/
|
class GS_TOOLKIT_EXPORT OdGsFiler : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdGsFiler);
|
|
OdGsFiler() { }
|
virtual ~OdGsFiler() { }
|
public:
|
enum Section
|
{
|
kEOFSection = -1, // EOF
|
// V1 sections
|
kHeaderSection = 0, // File header
|
kDatabaseLinkSection, // Database linkage section
|
kGsModuleSection, // Gs Module section
|
kDeviceSection, // Gs Device section
|
kClientDeviceSection, // Client Gs Device section
|
kViewSection, // Gs View section
|
kClientViewSection, // Client Gs View section
|
kModelSection, // Gs Model section
|
kClientModelSection, // Client Gs Model section
|
kNodeSection, // Gs Node section
|
kClientNodeSection, // Client Gs Node section
|
kMetafileSection, // Gs Metafile section
|
kClientMetafileSection, // Client Gs Metafile section
|
kClientMaterialSection, // Client Gs Material section
|
kBlockRefImplSection, // Block reference cache implementation section
|
kLinkedDeviceSection, // Linked Gs Device section
|
kRenditionSection, // Client visual rendition section
|
// V2 sections
|
kRuntimeChangesSection // Runtime Gs modifications section
|
};
|
enum Version
|
{
|
kV1 = 100,
|
kV2 = 200,
|
kVLast = kV2
|
};
|
struct SubstitutionActuator
|
{
|
typedef void (*SetPtrFunc)(void *pPlace, const void *pValue);
|
SubstitutionActuator() { }
|
virtual ~SubstitutionActuator() { }
|
virtual void applySubstitution(void *pPlace, const void *pValue, SetPtrFunc pSetFunc) { pSetFunc(pPlace, pValue); }
|
};
|
struct Substitutor
|
{
|
// Register known substitution
|
virtual void registerSubstitution(const void *pValue, const void *pSubstitution, OdUInt32 size = sizeof(OdIntPtr), bool bRegister = true, bool bImmediate = false) = 0;
|
// Register substitution request
|
virtual void requestSubstitution(void *pPlace, const void *pValue, OdUInt32 size = sizeof(OdIntPtr), bool bRegister = true, bool bImmediate = true) = 0;
|
// Register substitution request for smart pointer
|
virtual void requestSubstitution(OdBaseObjectPtr *pPlace, const void *pValue, bool bRegister = true, bool bImmediate = true) = 0;
|
// Register substitution with non-default behavior
|
virtual void requestSubstitution(void *pPlace, OdGsFiler::SubstitutionActuator *pActuator, const void *pValue, OdUInt32 size = sizeof(OdIntPtr), bool bRegister = true, bool bImmediate = true) = 0;
|
// Clear substitutions
|
virtual void clearSubstitutions(const void *pValue = NULL, OdUInt32 size = 0) = 0;
|
// Run substitutions
|
virtual void runSubstitutions(const void *pValue = NULL, OdUInt32 size = 0, bool bClear = true) = 0;
|
};
|
public:
|
// Attach stream and initiate read/write process
|
virtual bool setStream(OdStreamBuf *pStream, bool bWrite = false) = 0;
|
virtual OdStreamBufPtr getStream() const = 0;
|
|
// Setup working database
|
virtual void setDatabase(const OdDbBaseDatabase *pDb) = 0;
|
virtual OdDbBaseDatabase *getDatabase() const = 0;
|
|
// File version control
|
virtual void setVersion(OdUInt32 nVersion) = 0;
|
virtual OdUInt32 version() const = 0;
|
|
// Database hash control
|
virtual void wrDbHash(const OdDbBaseDatabase *pDb) = 0;
|
virtual bool checkDbHash(const OdDbBaseDatabase *pDb) = 0;
|
|
// Setup sections for writing
|
virtual void setWriteSections(OdUInt64 nSections) = 0;
|
virtual void setWriteSection(Section section, bool bSet) = 0;
|
virtual bool isWriteSection(Section section) const = 0;
|
|
// Setup sections for reading
|
virtual void setReadSections(OdUInt64 nSections) = 0;
|
virtual void setReadSection(Section section, bool bSet) = 0;
|
virtual bool isReadSection(Section section) const = 0;
|
|
// Section writing
|
virtual void wrSectionBegin(Section section) = 0;
|
virtual void wrSectionEnd(Section section) = 0;
|
virtual void wrEOFSection() = 0;
|
|
// Section reading
|
virtual Section rdSection() const = 0;
|
virtual Section curSection() const = 0;
|
virtual void skipSection() const = 0;
|
virtual void rdBackSection() const = 0;
|
virtual bool checkEOF() const = 0;
|
|
// Substitutions processing
|
virtual Substitutor *subst() const = 0;
|
virtual void makeSubstitutions(bool bClear = true) const = 0;
|
virtual OdRxObjectPtr getSubstitutor() const = 0;
|
virtual void setSubstitutor(OdRxObject *pSubst) = 0;
|
|
// Arbitrary data
|
virtual void setArbitraryData(const OdChar *pName, OdRxObject *pObject) = 0;
|
virtual OdRxObjectPtr getArbitraryData(const OdChar *pName) const = 0;
|
virtual bool hasArbitraryData(const OdChar *pName) const = 0;
|
virtual void clearArbitraryData() = 0;
|
|
// Pointers registration
|
virtual void registerPtr(const void *pPtr) = 0;
|
virtual void unregisterPtr(const void *pPtr) = 0;
|
virtual bool isPtrRegistered(const void *pPtr) const = 0;
|
virtual void clearRegisteredPtrs() = 0;
|
|
// Process handles
|
virtual void wrHandle(OdDbStub *pHandle) = 0;
|
virtual OdDbStub *rdHandle() const = 0;
|
|
// Process classes
|
virtual void wrClass(OdRxObject *pObj) = 0;
|
virtual OdRxObjectPtr rdClass() const = 0;
|
|
// Process raw data
|
virtual void wrRawData(const void *pData, OdUInt32 nDataSize) = 0;
|
virtual void rdRawData(void *pData, OdUInt32 nDataSize) const = 0;
|
|
// Process data primitives
|
virtual void wrBool(bool bVal);
|
virtual bool rdBool() const;
|
|
virtual void wrInt(int val);
|
virtual int rdInt() const;
|
|
virtual void wrUInt(unsigned int val);
|
virtual unsigned int rdUInt() const;
|
|
virtual void wrChar(char val);
|
virtual char rdChar() const;
|
|
virtual void wrUInt8(OdUInt8 val);
|
virtual OdUInt8 rdUInt8() const;
|
|
virtual void wrInt16(OdInt16 val);
|
virtual OdInt16 rdInt16() const;
|
|
virtual void wrUInt16(OdUInt16 val);
|
virtual OdUInt16 rdUInt16() const;
|
|
virtual void wrInt32(OdInt32 val);
|
virtual OdInt32 rdInt32() const;
|
|
virtual void wrUInt32(OdUInt32 val);
|
virtual OdUInt32 rdUInt32() const;
|
|
virtual void wrInt64(OdInt64 val);
|
virtual OdInt64 rdInt64() const;
|
|
virtual void wrUInt64(OdUInt64 val);
|
virtual OdUInt64 rdUInt64() const;
|
|
virtual void wrIntPtr(OdIntPtr val);
|
virtual OdIntPtr rdIntPtr() const;
|
|
void wrPtr(const void *pPtr) { wrIntPtr((OdIntPtr)pPtr); }
|
void *rdPtr() const { return (void*)rdIntPtr(); }
|
|
virtual void wrCOLORREF(ODCOLORREF val);
|
virtual ODCOLORREF rdCOLORREF() const;
|
|
virtual void wrFloat(float val);
|
virtual float rdFloat() const;
|
|
virtual void wrDouble(double val);
|
virtual double rdDouble() const;
|
|
virtual void wrPoint2d(const OdGePoint2d &pt);
|
virtual void rdPoint2d(OdGePoint2d &pt) const;
|
|
virtual void wrVector2d(const OdGeVector2d &vec);
|
virtual void rdVector2d(OdGeVector2d &vec) const;
|
|
virtual void wrPoint3d(const OdGePoint3d &pt);
|
virtual void rdPoint3d(OdGePoint3d &pt) const;
|
|
virtual void wrVector3d(const OdGeVector3d &vec);
|
virtual void rdVector3d(OdGeVector3d &vec) const;
|
|
virtual void wrMatrix3d(const OdGeMatrix3d &mat);
|
virtual void rdMatrix3d(OdGeMatrix3d &mat) const;
|
|
virtual void wrExtents3d(const OdGeExtents3d &ext);
|
virtual void rdExtents3d(OdGeExtents3d &ext) const;
|
|
virtual void wrAnsiString(const OdAnsiString &str);
|
virtual void rdAnsiString(OdAnsiString &str) const;
|
OdAnsiString rdAnsiStringRet() const { OdAnsiString str; rdAnsiString(str); return str; }
|
|
virtual void wrString(const OdString &str);
|
virtual void rdString(OdString &str) const;
|
OdString rdStringRet() const { OdString str; rdString(str); return str; }
|
|
virtual void wrUInt8Array (const OdUInt8Array& arr);
|
virtual void wrUInt16Array(const OdUInt16Array& arr);
|
virtual void wrUInt16Array(OdUInt32 count, const OdUInt16* arr);
|
virtual void wrUInt32Array(const OdUInt32Array& arr);
|
virtual void wrUInt32Array(const OdUInt32Vector& arr);
|
virtual void wrUInt64Array(const OdUInt64Array& arr);
|
virtual void wrUInt64Array(const OdUInt64Vector& vec);
|
virtual void wrUInt64Array(OdUInt32 count, const OdUInt64* arr);
|
virtual void wrIntArray (const OdIntArray& arr);
|
virtual void wrFloatArray (const OdFloatArray& arr);
|
virtual void wrFloatArray (OdUInt32 count, const float* arr);
|
virtual void wrPoint2dArray (const OdGePoint2dArray& arr);
|
virtual void wrPoint3dArray (const OdGePoint3dArray& arr);
|
virtual void wrDbStubPtrArray(const OdDbStubPtrArray& arr);
|
virtual void wrGsDCRect (const OdGsDCRect& rc);
|
virtual void wrGsDCRectDouble(const OdGsDCRectDouble& rcd);
|
|
virtual void rdUInt8Array (OdUInt8Array& arr);
|
virtual void rdUInt16Array(OdUInt16Array& arr);
|
virtual void rdUInt16Array(OdUInt32 count, OdUInt16* arr);
|
virtual void rdUInt32Array(OdUInt32Array& arr);
|
virtual void rdUInt32Array(OdUInt32Vector& arr);
|
virtual void rdUInt64Array(OdUInt64Array& arr);
|
virtual void rdUInt64Array(OdUInt64Vector& vec);
|
virtual void rdUInt64Array(OdUInt32 count, OdUInt64* arr);
|
virtual void rdIntArray (OdIntArray& arr);
|
virtual void rdFloatArray (OdFloatArray& arr);
|
virtual void rdFloatArray (OdUInt32 count, float* arr);
|
virtual void rdPoint2dArray (OdGePoint2dArray& arr);
|
virtual void rdPoint3dArray (OdGePoint3dArray& arr);
|
virtual void rdDbStubPtrArray(OdDbStubPtrArray& arr);
|
virtual void rdGsDCRect (OdGsDCRect& dcrc);
|
virtual void rdGsDCRectDouble(OdGsDCRectDouble& dcrcd);
|
|
// Create filer object
|
static OdSmartPtr<OdGsFiler> createObject(OdStreamBuf *pStream, bool bForWrite, const OdDbBaseDatabase *pDb, OdUInt32 nVersion = kVLast);
|
};
|
|
typedef OdSmartPtr<OdGsFiler> OdGsFilerPtr;
|
|
#define OdGsFiler_wrArray(filer, arry, wrFunc) \
|
{ \
|
filer.wrUInt32(arry.size()); \
|
for (OdUInt32 nVal = 0; nVal < arry.size(); nVal++) \
|
filer.wrFunc(arry.getPtr()[nVal]); \
|
}
|
#define OdGsFilerPtr_wrArray(pFiler, arry, wrFunc) \
|
OdGsFiler_wrArray((*pFiler), arry, wrFunc)
|
|
#define OdGsFiler_wrArrayRaw(filer, arry, typSz) \
|
{ \
|
filer.wrUInt32(arry.size()); \
|
if (!arry.isEmpty()) \
|
filer.wrRawData(arry.getPtr(), arry.size() * typSz); \
|
}
|
#define OdGsFilerPtr_wrArrayRaw(pFiler, arry, typSz) \
|
OdGsFiler_wrArrayRaw((*pFiler), arry, typSz)
|
|
#define OdGsFiler_rdArray(filer, arry, rdFunc) \
|
{ \
|
arry.clear(); \
|
OdUInt32 nElems = filer.rdUInt32(); \
|
arry.setPhysicalLength(nElems); \
|
for (OdUInt32 nElem = 0; nElem < nElems; nElem++) \
|
arry.push_back(filer.rdFunc()); \
|
}
|
#define OdGsFilerPtr_rdArray(pFiler, arry, rdFunc) \
|
OdGsFiler_rdArray((*pFiler), arry, rdFunc)
|
|
#define OdGsFiler_rdArrayArg(filer, arry, rdFunc) \
|
{ \
|
OdUInt32 nElems = filer.rdUInt32(); \
|
arry.resize(nElems); \
|
for (OdUInt32 nElem = 0; nElem < nElems; nElem++) \
|
filer.rdFunc(arry[nElem]); \
|
}
|
#define OdGsFilerPtr_rdArrayArg(pFiler, arry, rdFunc) \
|
OdGsFiler_rdArrayArg((*pFiler), arry, rdFunc)
|
|
#define OdGsFiler_rdArrayRaw(filer, arry, typSz) \
|
{ \
|
OdUInt32 nElems = filer.rdUInt32(); \
|
arry.resize(nElems); \
|
if (nElems) \
|
filer.rdRawData(arry.asArrayPtr(), nElems * typSz); \
|
}
|
#define OdGsFilerPtr_rdArrayRaw(pFiler, arry, typSz) \
|
OdGsFiler_rdArrayRaw((*pFiler), arry, typSz)
|
|
/** <group OdGs_Classes>
|
*/
|
class GS_TOOLKIT_EXPORT OdGsFilerCreatorPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdGsFilerCreatorPE);
|
public:
|
virtual OdGsFilerPtr createGsFiler(OdStreamBuf *pStream, bool bForWrite, const OdDbBaseDatabase *pDb) = 0;
|
};
|
|
typedef OdSmartPtr<OdGsFilerCreatorPE> OdGsFilerCreatorPEPtr;
|
|
/** <group OdGs_Classes>
|
*/
|
class GS_TOOLKIT_EXPORT OdGsFilerDbHashPE : public OdRxObject
|
{
|
public:
|
ODRX_DECLARE_MEMBERS(OdGsFilerDbHashPE);
|
public:
|
virtual OdBinaryData computeDbHash(const OdDbBaseDatabase *pDb) = 0;
|
};
|
|
typedef OdSmartPtr<OdGsFilerDbHashPE> OdGsFilerDbHashPEPtr;
|
|
#include "TD_PackPop.h"
|
|
#endif // __OD_GS_FILER_H__
|
