///////////////////////////////////////////////////////////////////////////////
|
// 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 __TF_OBJECT_H__
|
#define __TF_OBJECT_H__
|
|
#include "TD_PackPush.h"
|
|
#include "RxObject.h"
|
#include "RxIterator.h"
|
#include "TfVariant.h"
|
#include "TfResult.h"
|
#include "TfObjectReactor.h"
|
#include "DbStubPtrArray.h"
|
#include "Gi/GiDrawable.h"
|
|
#define ODTF_CREATE_ATTRIBUTE(Name, value) \
|
reuslt.push_back(::newOdTfAttribute(OD_T(#Name), pObject, value));
|
|
#define ODTF_DEFINE_ATTRIBUTES_CONSTRUCTOR(Name, ATTRIBUTES_LIST) \
|
static OdArray<OdTfAttribute*> Name##AttributesConstructor( \
|
OdRxObject* pObject) { \
|
OdArray<OdTfAttribute*> result; \
|
ATTRIBUTES_LIST(ODTF_CREATE_ATTRIBUTE) \
|
return result; \
|
}
|
|
#define ODTF_CREATE_PROPERTY_NO_ATTRS(PropertyName, type, gettterFn, setterFn, \
|
defaultItemFn) \
|
result.push_back(::newOdTfProperty( \
|
OD_T(#PropertyName), pClass, static_cast<OdTfVariant::Type>(type), NULL, \
|
defaultItemFn, gettterFn, setterFn));
|
|
#define ODTF_DEFINE_PROPERTIES_CONSTRUCTOR(ClassName, PROPERTIES_LIST) \
|
static OdArray<OdTfProperty*> ClassName##propertiesConstructor( \
|
OdTfClass* pClass) { \
|
OdArray<OdTfProperty*> result; \
|
PROPERTIES_LIST(ODTF_CREATE_PROPERTY_NO_ATTRS); \
|
return result; \
|
}
|
|
#define ODTF_DECLARE_MEMBERS(ClassName)\
|
ODRX_DECLARE_MEMBERS_GENERIC(OdTfClass, ClassName)
|
|
#define ODTF_DEFINE_RTTI_MEMBERS(ClassName, ParentClass) \
|
ODRX_DEFINE_RTTI_MEMBERS_GENERIC(OdTfClass, ClassName, ParentClass)
|
|
#define ODTF_DEFINE_INIT_MEMBERS(ClassName, ParentClass, attrsConsFn, \
|
propsConsFn, pseudoConsFn, szClassName) \
|
ODRX_DEFINE_INIT_MEMBERS_GENERIC( \
|
ClassName, (::newOdTfClass(szClassName, ParentClass::desc(), \
|
attrsConsFn, propsConsFn, pseudoConsFn)), \
|
(::newOdTfClass(szClassName, ParentClass::desc(), attrsConsFn, \
|
propsConsFn, pseudoConsFn)))
|
|
#define ODTF_DEFINE_MEMBERS2(ClassName, ParentClass, attrsConsFn, propsConsFn, \
|
pseudoConsFn, szClassName) \
|
\
|
ODTF_DEFINE_RTTI_MEMBERS(ClassName, ParentClass) \
|
ODTF_DEFINE_INIT_MEMBERS(ClassName, ParentClass, attrsConsFn, propsConsFn, \
|
pseudoConsFn, szClassName)
|
|
#define ODTF_NO_CONS_NO_ATTRS_NO_PROPS_DEFINE_MEMBERS(ClassName, ParentClass) \
|
\
|
ODTF_DEFINE_MEMBERS2(ClassName, ParentClass, NULL, NULL, NULL, \
|
OD_T(#ClassName)) \
|
\
|
ODRX_DEFINE_PSEUDOCONSTRUCTOR(ClassName, EMPTY_CONSTR)
|
|
#define ODTF_CONS_NO_ATTRS_PROPS_DEFINE_MEMBERS(ClassName, ParentClass, \
|
PROPERTIES_LIST, DOCREATE) \
|
ODTF_DEFINE_PROPERTIES_CONSTRUCTOR(ClassName, PROPERTIES_LIST) \
|
ODTF_DEFINE_MEMBERS2(ClassName, ParentClass, NULL, \
|
ClassName##propertiesConstructor, \
|
ClassName::pseudoConstructor, OD_T(#ClassName)) \
|
\
|
ODRX_DEFINE_PSEUDOCONSTRUCTOR(ClassName, DOCREATE)
|
|
class OdTfClass;
|
class OdTfProperty;
|
class OdTfAttribute;
|
|
class ODRX_ABSTRACT TFCORE_EXPORT OdTfAttributesContainer : public OdRxObject {
|
ODRX_DECLARE_MEMBERS(OdTfAttributesContainer);
|
public:
|
virtual OdRxObject* owner() const = 0;
|
virtual const OdTfAttribute* find(const OdString& name) const = 0;
|
};
|
typedef OdSmartPtr<OdTfAttributesContainer> OdTfAttributesContainerPtr;
|
|
|
class ODRX_ABSTRACT TFCORE_EXPORT OdTfPropertiesContainer : public OdRxObject {
|
ODRX_DECLARE_MEMBERS(OdTfPropertiesContainer);
|
public:
|
typedef OdInt32 size_type;
|
|
virtual OdTfClass* owner() const = 0;
|
virtual size_type size() const = 0;
|
virtual bool contains(const OdTfProperty* pProp) const = 0;
|
virtual const OdTfProperty* find(size_type index) const = 0;
|
virtual const OdTfProperty* find(const OdString& name) const = 0;
|
virtual const OdTfProperty* find(const OdString& name,
|
const OdTfVariant::Type type) const = 0;
|
virtual size_type index(const OdTfProperty* pProp) const = 0;
|
virtual bool unique(const OdString& name) const = 0;
|
virtual bool unique(const OdString& name,
|
const OdTfVariant::Type type) const = 0;
|
virtual OdRxIteratorPtr iterator() const = 0;
|
};
|
typedef OdSmartPtr<OdTfPropertiesContainer> OdTfPropertiesContainerPtr;
|
|
/** \details
|
Library: Od_Tf
|
<group OdTf_Classes>
|
*/
|
class ODRX_ABSTRACT TFCORE_EXPORT OdTfClass : public OdRxClass {
|
ODRX_DECLARE_MEMBERS(OdTfClass);
|
public:
|
virtual const OdTfAttributesContainerPtr attributes() const = 0;
|
virtual const OdTfPropertiesContainerPtr properties() const = 0;
|
virtual const OdTfPropertiesContainerPtr allProperties() const = 0;
|
virtual OdTfClass* tfParent() const = 0;
|
};
|
typedef OdSmartPtr<OdTfClass> OdTfClassPtr;
|
|
/** \details
|
Library: Od_Tf
|
<group OdTf_Classes>
|
*/
|
class ODRX_ABSTRACT TFCORE_EXPORT OdTfProperty : public OdRxObject {
|
ODRX_DECLARE_MEMBERS(OdTfProperty);
|
public:
|
virtual OdTfClass* owner() const = 0;
|
virtual OdTfVariant::Type type() const = 0;
|
virtual OdString name() const = 0;
|
virtual OdTfAttributesContainerPtr attributes() const = 0;
|
/*
|
Returns default value, that should be used for this property instead of
|
OdTfVariant::kEmpty.
|
For single property it returns value, that should be used in place of whole
|
property.
|
For array property it returns value, to replace empty items.
|
*/
|
virtual OdTfVariant defaultItemValue() const = 0;
|
virtual OdTf::ErrorStatus getValue(const OdTfObject* pObject,
|
OdTfVariant& value) const = 0;
|
virtual OdTf::ErrorStatus setValue(OdTfObject* pObject,
|
const OdTfVariant& value) const = 0;
|
};
|
typedef OdSmartPtr<OdTfProperty> OdTfPropertyPtr;
|
|
/** \details
|
Library: Od_Tf
|
<group OdTf_Classes>
|
*/
|
class ODRX_ABSTRACT TFCORE_EXPORT OdTfAttribute : public OdRxObject {
|
ODRX_DECLARE_MEMBERS(OdTfAttribute);
|
public:
|
virtual OdRxObject* owner() const = 0;
|
virtual OdString name() const = 0;
|
virtual OdTfVariant value() const = 0;
|
};
|
typedef OdSmartPtr<OdTfAttribute> OdTfAttributePtr;
|
|
|
/** \details
|
Library: Od_Tf
|
<group OdTf_Classes>
|
*/
|
class TFCORE_EXPORT OdTfObject : public OdGiDrawable {
|
ODTF_DECLARE_MEMBERS(OdTfObject);
|
|
public:
|
typedef OdTfPropertiesContainer::size_type PropertyIndexType;
|
typedef OdTfVariantArray::size_type ItemIndexType;
|
|
/** \details
|
Gets the object's owner
|
*/
|
virtual const OdTfObject* getOwner() const = 0;
|
|
virtual OdTf::ErrorStatus getProperty(
|
const OdTfProperty* pPI, OdTfVariant& value,
|
const ItemIndexType arrayIndex = -1) const = 0;
|
|
virtual OdTf::ErrorStatus setProperty(
|
const OdTfProperty* pPI, const OdTfVariant& value,
|
const ItemIndexType arrayIndex = -1) = 0;
|
|
/** \details
|
Gets the specified property value.
|
|
\param name [in] Property name.
|
\param value [out] Property value.
|
\param arrayIndex [in] if a property is of an array type, get the value at
|
the given index.
|
*/
|
virtual OdTf::ErrorStatus getProperty(
|
const OdString& name, OdTfVariant& value,
|
const ItemIndexType arrayIndex = -1,
|
const OdTfClass* pClass = NULL) const = 0;
|
/** \details
|
Sets the specified property value.
|
|
\param name [in] Property name.
|
\param value [in] New property value.
|
\param arrayIndex [in] if a property is of an array type, set the value at
|
the given index
|
*/
|
virtual OdTf::ErrorStatus setProperty(const OdString& name,
|
const OdTfVariant& value,
|
const ItemIndexType arrayIndex = -1,
|
const OdTfClass* pClass = NULL) = 0;
|
/** \details
|
Gets the specified property value.
|
|
\param propertyIndex [in] Index of a property in a class field array.
|
\param value [out] Property value.
|
\param arrayIndex [in] if a property is of an array type, get the value at
|
the given index.
|
*/
|
virtual OdTf::ErrorStatus getProperty(
|
const PropertyIndexType propertyIndex, OdTfVariant& value,
|
const ItemIndexType arrayIndex = -1) const = 0;
|
/** \details
|
Sets the specified property value.
|
|
\param propertyIndex [in] Index of a property in a class field array.
|
\param value [in] New property value.
|
\param arrayIndex [in] if a property is of an array type, set the value at
|
the given index
|
*/
|
virtual OdTf::ErrorStatus setProperty(
|
const PropertyIndexType propertyIndex, const OdTfVariant& value,
|
const ItemIndexType arrayIndex = -1) = 0;
|
|
/** \details
|
Adds the specified transient reactor to this element's reactor list.
|
|
\param pReactor [in] Pointer to the transient reactor object.
|
|
\remarks
|
An element must be open either OdBm::kForRead or OdBm::kForWrite in order to
|
add a transient reactor.
|
*/
|
virtual void addReactor(OdTfObjectReactor* pReactor) = 0;
|
|
/** \details
|
Removes the specified transient reactor from this element's reactor list.
|
|
\param pReactor [in] Pointer to the transient reactor object.
|
|
\remarks
|
An element must be open either OdBm::kForRead or OdBm::kForWrite in order to
|
remove a transient reactor.
|
*/
|
virtual void removeReactor(OdTfObjectReactor* pReactor) = 0;
|
|
/** \details
|
Adds the specified persistent reactor to this element's reactor list.
|
|
\param elmId [in] Element ID of the persistent reactor.
|
|
\remarks
|
An element must be open OdBm::kForWrite in order to add a persistent
|
reactor.
|
|
If the persistent reactor does not have an owner,
|
it isn't saved with the drawing.
|
*/
|
virtual void addPersistentReactor(OdTfPersistentReactor*) = 0;
|
|
/** \details
|
Removes the specified persistent reactor from this element's reactor list.
|
|
\param elmId [in] Element ID of the persistent reactor.
|
|
\remarks
|
An element must be open OdBm::kForWrite in order to remove one of its
|
persistent reactors.
|
*/
|
virtual void removePersistentReactor(OdTfPersistentReactor*) = 0;
|
|
/** \details
|
This method returns true if elmId is the Element ID of a reactor attached to
|
this element. Otherwise, it returns false.
|
|
\param elmId [in] Element ID of the persistent reactor.
|
*/
|
virtual bool hasPersistentReactor(OdTfPersistentReactor*) const = 0;
|
|
/** \details
|
Returns this element's persistent reactors.
|
|
\param elmIds [out] Receives Element IDs of this element's persistent
|
reactors.
|
*/
|
virtual void getPersistentReactors(OdTfPersistentReactorArray& elmIds) = 0;
|
|
/** \details
|
Returns this element's transient reactors.
|
|
\param reactors [out] Receives this element's transient reactors.
|
*/
|
virtual void getTransientReactors(OdTfObjectReactorArray& reactors) = 0;
|
};
|
typedef OdSmartPtr<OdTfObject> OdTfObjectPtr;
|
|
typedef OdArray<OdTfProperty*>(*OdTfPropertiesConstructorType)(OdTfClass*);
|
typedef OdArray<OdTfAttribute*>(*OdTfAttributesConstructorType)(OdRxObject*);
|
typedef OdTf::ErrorStatus (*OdTfPropertyGetterType)(const OdTfObject*,
|
OdTfVariant&);
|
typedef OdTf::ErrorStatus (*OdTfPropertySetterType)(OdTfObject*,
|
const OdTfVariant&);
|
typedef OdTfVariant (*OdTfVariantConstructorType)();
|
|
TFCORE_EXPORT OdTfClass* newOdTfClass(
|
const OdString& name, OdRxClass* pBaseClass,
|
OdTfAttributesConstructorType pAttrsConstr,
|
OdTfPropertiesConstructorType pPropsConstr, OdPseudoConstructorType pConstr,
|
bool bRegister = true);
|
|
TFCORE_EXPORT OdTfClass* createOdTfClass();
|
|
TFCORE_EXPORT OdTfClass* initOdTfClass(
|
OdTfClass* pClass, const OdString& name, OdRxClass* pBaseClass,
|
const OdArray<OdTfAttribute*>& attributes,
|
const OdArray<OdTfProperty*>& properties, OdPseudoConstructorType pConstr,
|
bool bRegister = true);
|
|
TFCORE_EXPORT OdTfProperty* newOdTfProperty(
|
const OdString& name, OdTfClass* pOwner, OdTfVariant::Type type,
|
OdTfAttributesConstructorType pAttrsConstr,
|
OdTfVariantConstructorType pDefaultValueConstructor,
|
OdTfPropertyGetterType pGetter, OdTfPropertySetterType pSetter);
|
|
TFCORE_EXPORT OdTfProperty* createOdTfProperty();
|
|
TFCORE_EXPORT OdTfProperty* initOdTfProperty(
|
OdTfProperty* pProp, const OdString& name, OdTfClass* pOwner,
|
OdTfVariant::Type type, const OdArray<OdTfAttribute*>& attributes,
|
OdTfVariantConstructorType pDefaultValueConstructor,
|
OdTfPropertyGetterType pGetter, OdTfPropertySetterType pSetter);
|
|
TFCORE_EXPORT OdTfAttribute* newOdTfAttribute(const OdString& name,
|
OdRxObject* pOwner,
|
const OdTfVariant& value);
|
|
#endif // __TF_OBJECT_H__
|
