RxObject.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, 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 Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 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 _ODRXOBJECT_INCLUDED_
#define _ODRXOBJECT_INCLUDED_ /* { Secret } *// 
 
#include "TD_PackPush.h"
#include "RootExport.h"
#include "OdHeap.h"
#include "OdArrayPreDef.h"
#include "OdString.h"
#include "BaseObjectPtr.h"
 
class OdRxClass;
class OdRxModule;
 
typedef void (*AppNameChangeFuncPtr)(const OdRxClass* classObj, OdString& newAppName, int saveVer);
 
enum OdRxObjMod { kOdRxObjAttach };
 
#define ODRX_DECLARE_MEMBERS_GENERIC(ClassType, ClassName)\
public:                                                                                              \
                                                                                                     \
                      \
  static OdSmartPtr<ClassName> cast(const OdRxObject* pObj)                                          \
  {                                                                                                  \
    if (pObj)                                                                                        \
      return OdSmartPtr<ClassName>(((ClassName*)pObj->queryX(ClassName::desc())), kOdRxObjAttach);   \
    return (ClassName*)0;                                                                            \
  }                                                                                                  \
                                                                                                     \
  static ClassType* g_pDesc;                                                                         \
                                                                                                     \
  \
  \
  \
  static ClassType* desc();                                                                   \
                                                                                                     \
  \
  \
  \
  virtual ClassType* isA() const;                                                                    \
                                                                                                     \
                 \
                 \
  virtual OdRxObject* queryX(const OdRxClass* protocolClass) const;                                  \
                                                                                                     \
                 \
                 \
  static OdRxObjectPtr pseudoConstructor();                                                          \
                                                                                                     \
                 \
                 \
   static OdSmartPtr<ClassName> createObject()                                                       \
  { if (!desc()) throw OdError(eNotInitializedYet); return desc()->create(); }                       \
                                                                                                     \
                 \
  static void rxInit();                                                                              \
  static void rxInit(AppNameChangeFuncPtr appNameChangeFunc);                                        \
                                                                                                     \
/* Unregisters ClassName with the ODA Platform.                          **/                 \
  static void rxUninit()
 
 
#define ODRX_DECLARE_MEMBERS(ClassName)\
    ODRX_DECLARE_MEMBERS_GENERIC(OdRxClass, ClassName)
  
#define EMPTY_CONSTR(ClassName)(ClassName*)0
 
#define NEWOBJ_CONSTR(ClassName) OdSmartPtr<ClassName>(new ClassName, kOdRxObjAttach)
 
#define ODRX_DEFINE_RTTI_MEMBERS_GENERIC(ClassType, ClassName, ParentClass) \
                                                                                                     \
  ClassType* ClassName::g_pDesc = 0;                                        \
  ClassType* ClassName::desc() { return g_pDesc; }                          \
  ClassType* ClassName::isA() const { return g_pDesc; }                     \
                                                                                                     \
  OdRxObject* ClassName::queryX(const OdRxClass* pClass) const {            \
    return ::odQueryXImpl<ClassName, ParentClass>(this, pClass);            \
  }
 
#define ODRX_DEFINE_RTTI_MEMBERS(ClassName, ParentClass) \
  ODRX_DEFINE_RTTI_MEMBERS_GENERIC(OdRxClass, ClassName, ParentClass)
 
#define ODRX_DEFINE_INIT_MEMBERS_GENERIC(ClassName, CREATE_CLASS_INSTANCE, CREATE_CLASS_INSTANCE2)   \
                                                                                                     \
/* Registers this class with Teigha.                                         */                      \
void ClassName::rxInit()                                                                             \
{                                                                                                    \
  if (!ClassName::g_pDesc) {                                                                         \
    ClassName::g_pDesc = CREATE_CLASS_INSTANCE;                                                      \
  } else {                                                                                           \
    ODA_ASSERT(("Class ["#ClassName"] is already initialized.",0));                                  \
    throw OdError(eExtendedError);                                                                   \
  }                                                                                                  \
}                                                                                                    \
void ClassName::rxInit(AppNameChangeFuncPtr pAppNameChangeCallback)                                  \
{                                                                                                    \
  if (!ClassName::g_pDesc) {                                                                         \
    ClassName::g_pDesc = CREATE_CLASS_INSTANCE2;                                                     \
  } else {                                                                                           \
    ODA_ASSERT(("Class ["#ClassName"] is already initialized.",0));                                  \
    throw OdError(eExtendedError);                                                                   \
  }                                                                                                  \
}                                                                                                    \
                                                                                                     \
/* Unregisters this class with Teigha.                                       */                      \
void ClassName::rxUninit()                                                                           \
{                                                                                                    \
  if (ClassName::g_pDesc) {                                                                          \
    ::deleteOdRxClass(ClassName::g_pDesc);                                                           \
    ClassName::g_pDesc = 0;                                                                          \
  } else {                                                                                           \
    ODA_ASSERT(("Class ["#ClassName"] is not initialized yet.",0));                                  \
    throw OdError(eNotInitializedYet);                                                               \
  }                                                                                                  \
}
 
#define ODRX_DEFINE_INIT_MEMBERS(ClassName, ParentClass, pseudoConsFn, DwgVer,                \
                                 MaintVer, nProxyFlags, szDWGClassName,                       \
                                 szDxfName, szAppName, nCustomFlags, pMemberCreate, pUserData)\
  ODRX_DEFINE_INIT_MEMBERS_GENERIC(                                                           \
      ClassName,                                                                              \
      (::newOdRxClass(szDWGClassName, ParentClass::desc(), pseudoConsFn, DwgVer,              \
        MaintVer, nProxyFlags, szDxfName, szAppName, NULL, nCustomFlags, pMemberCreate, pUserData)),                    \
      (::newOdRxClass(szDWGClassName, ParentClass::desc(), pseudoConsFn, DwgVer,              \
        MaintVer, nProxyFlags, szDxfName, szAppName, pAppNameChangeCallback, nCustomFlags, pMemberCreate, pUserData)))
 
 
#define ODRX_DEFINE_PSEUDOCONSTRUCTOR(ClassName,DOCREATE)                                            \
                                                                                                     \
OdRxObjectPtr ClassName::pseudoConstructor() { return OdRxObjectPtr(DOCREATE(ClassName)); }
 
#define ODRX_DEFINE_MEMBERS2(ClassName,ParentClass,pseudoConsFn,DwgVer,MaintVer,nProxyFlags,szDWGClassName,szDxfName,szAppName,nCustomFlags) \
                                                                                                     \
ODRX_DEFINE_RTTI_MEMBERS(ClassName,ParentClass)                                                      \
                                                                                                     \
ODRX_DEFINE_INIT_MEMBERS(ClassName,ParentClass,pseudoConsFn,                                         \
    DwgVer,MaintVer,nProxyFlags,szDWGClassName,szDxfName,szAppName,nCustomFlags,0,0)
    
#define ODRX_DEFINE_MEMBERS(ClassName,ParentClass,DOCREATE,DwgVer,MaintVer,nProxyFlags,szDWGClassName,szDxfName,szAppName)\
                                                                                                     \
ODRX_DEFINE_MEMBERS2(ClassName,ParentClass,ClassName::pseudoConstructor,                             \
  DwgVer,MaintVer,nProxyFlags,szDWGClassName,szDxfName,szAppName,0)                                  \
                                                                                                     \
ODRX_DEFINE_PSEUDOCONSTRUCTOR(ClassName,DOCREATE)
 
#define ODRX_DEFINE_MEMBERS_EX(ClassName,ParentClass,DOCREATE,DwgVer,MaintVer,nProxyFlags,szDWGClassName,szDxfName,szAppName,nCustomFlags)\
                                                                                                     \
ODRX_DEFINE_MEMBERS2(ClassName,ParentClass,ClassName::pseudoConstructor,                             \
  DwgVer,MaintVer,nProxyFlags,szDWGClassName,szDxfName,szAppName,nCustomFlags)                       \
                                                                                                     \
ODRX_DEFINE_PSEUDOCONSTRUCTOR(ClassName,DOCREATE)
 
 
#define ODRX_NO_CONS_DEFINE_MEMBERS_ALTNAME(ClassName,ParentClass,szClassName)                       \
                                                                                                     \
ODRX_DEFINE_MEMBERS2(ClassName,ParentClass,0,0,0,0,szClassName,OdString::kEmpty,OdString::kEmpty,0)                          \
                                                                                                     \
ODRX_DEFINE_PSEUDOCONSTRUCTOR(ClassName,EMPTY_CONSTR)
 
 
 
#define ODRX_NO_CONS_DEFINE_MEMBERS(ClassName,ParentClass)                                           \
                                                                                                     \
ODRX_NO_CONS_DEFINE_MEMBERS_ALTNAME(ClassName,ParentClass,OD_T(#ClassName))
 
 
 
#define ODRX_CONS_DEFINE_MEMBERS_ALTNAME(ClassName,ParentClass,szClassName,DOCREATE)                 \
                                                                                                     \
ODRX_DEFINE_MEMBERS2(ClassName,ParentClass,ClassName::pseudoConstructor,0,0,0,szClassName,OdString::kEmpty,OdString::kEmpty,0) \
                                                                                                     \
ODRX_DEFINE_PSEUDOCONSTRUCTOR(ClassName,DOCREATE)
 
 
 
#define ODRX_CONS_DEFINE_MEMBERS(ClassName,ParentClass,DOCREATE)                                     \
                                                                                                     \
ODRX_CONS_DEFINE_MEMBERS_ALTNAME(ClassName,ParentClass,OD_T(#ClassName),DOCREATE)
 
 
 
#define ODRX_DXF_DEFINE_MEMBERS(ClassName,ParentClass,DOCREATE,DwgVer,MaintVer, nProxyFlags,DxfName,AppName)    \
                                                                                                                \
ODRX_DEFINE_MEMBERS(ClassName,ParentClass,DOCREATE,                                                             \
    DwgVer,MaintVer,nProxyFlags,OD_T(#ClassName),OD_T(#DxfName),OD_T(#AppName))
 
 
 
#define ODRX_DXF_CONS_DEFINE_MEMBERS(ClassName,ParentClass,DwgVer,MaintVer,nProxyFlags,DxfName,AppName)    \
                                                                                                           \
ODRX_DEFINE_MEMBERS2(ClassName,ParentClass,ClassName::pseudoConstructor,                                   \
    DwgVer,MaintVer,nProxyFlags,OD_T(#ClassName),OD_T(#DxfName),OD_T(#AppName),0)                          \
                                                                                                           \
ODRX_DEFINE_PSEUDOCONSTRUCTOR(ClassName,NEWOBJ_CONSTR)
 
 
namespace OdRx
{
  enum Ordering
  {
    kLessThan     =-1, // This object < Specified Object
    kEqual        = 0, // This object == Specified Object
    kGreaterThan  = 1, // This object > Specified Object
    kNotOrderable = 2  // These objects cannot be ordered.
  };
 
  enum MTSupport
  {
    kMTRender         = 0x01, // worldDraw() or viewportDraw() calls from different threads are allowed
                              // for highest level (MS or PS), elsewhere they should always happen
                              // in one dedicated thread.
    kMTRenderInBlock  = 0x02, // Calls to worldDraw() or viewportDraw() methods from different threads are allowed
                              // if the drawable is located inside a block (compound object).
    kMTRenderNested   = 0x04, // worldDraw() or viewportDraw() from different threads are allowed for
                              // nested drawables of this compound object.
    kMTRenderReserved = 0x08, // Reserved for future use.
    kMTRenderMask     = 0x0f, // Combination of all MTRender-dependent flags.
    kMTLoading        = 0x80, // Multithread loading is supported for this object.
    kHistoryAware     = 0x100 // The information written by the object to the undo filer can be saved in the history file (is valid between sessions)
  };
}
 
class OdRxObjectPtr : public OdBaseObjectPtr
{
  inline void internalAddRef();
 
  void assign(
    const OdRxObject* pObject)
  {
    if (m_pObject != pObject)  // To prevent reference counter dec/inc which
    {                       // may cause object destruction or subClose
      release();
      m_pObject = (OdRxObject*)pObject;
      internalAddRef();
    }
  }
 
public:
 
  OdRxObjectPtr() : OdBaseObjectPtr() { }
  OdRxObjectPtr(
    const OdRxObject* pSource, 
    OdRxObjMod)
    : OdBaseObjectPtr(pSource)
  {
  }
 
  OdRxObjectPtr(
    const OdRxObject* pSource)
    : OdBaseObjectPtr(pSource)
  {
    internalAddRef();
  }
 
  OdRxObjectPtr(
    const OdRxObjectPtr& pSource)
    : OdBaseObjectPtr(pSource.get())
  {
    internalAddRef();
  }
 
  OdRxObjectPtr(
    const OdBaseObjectPtr& pSource)
    : OdBaseObjectPtr(pSource.get())
  {
    internalAddRef();
  }
 
  void attach(
    const OdRxObject* pObject) { release(); m_pObject = (OdRxObject*)pObject; }
 
  ~OdRxObjectPtr()
 { 
     release(); 
 }
 
  inline void release();
 
  OdRxObject* detach()
  {
    OdRxObject* res = m_pObject;
    m_pObject = 0;
    return res;
  }
 
  OdRxObjectPtr& operator = (
    const OdRxObjectPtr& source)
  { assign(source); return *this; }
 
  OdRxObjectPtr& operator = (
    const OdRxObject* source)
  { assign(source); return *this; }
 
  OdRxObjectPtr& operator = (
    const OdBaseObjectPtr& source)
  { assign(source.get()); return *this; }
 
  OdRxObject* get() { return m_pObject; }
  const OdRxObject* get() const { return m_pObject; }
 
  OdRxObject* operator ->() { return m_pObject; }
  const OdRxObject* operator ->() const { return m_pObject; }
 
#ifdef ODA_GCC_2_95
  operator OdRxObject*() const { return m_pObject; }
#else
  operator OdRxObject*() { return m_pObject; }
 
  operator const OdRxObject*() const { return m_pObject; }
#endif
 
  bool operator==(
    const OdRxObject* pObject) const { return (m_pObject==pObject); }
 
  bool operator!=(
    const OdRxObject* pObject) const { return (m_pObject!=pObject); }
};
 
 
class ODRX_ABSTRACT FIRSTDLL_EXPORT OdRxObject
{
 
  OdRxObject(const OdRxObject&);
 
  OdRxObject& operator = (const OdRxObject&);
//FELIX_CHANGE_BEGIN
/*
protected:
*/
public:
//FELIX_CHANGE_END
  ODRX_HEAP_OPERATORS();
 
public:
  OdRxObject() { }
 
  virtual ~OdRxObject();
 
  virtual OdRxObject* queryX(
    const OdRxClass* pClass) const;
 
  virtual OdRxObject* x(
    const OdRxClass* pClass) const;
 
  static OdRxObjectPtr cast(
    const OdRxObject* pointer)
  {
    OdRxObjectPtr pRes;
    if (pointer)
      pRes.attach(pointer->queryX(desc()));
    return pRes;
  }
 
  static OdRxClass* desc();
 
 
  virtual OdRxClass* isA() const;
 
  virtual void addRef() = 0;
 
  virtual void release() = 0;
 
  virtual long numRefs() const;
 
  bool isKindOf(const OdRxClass* pClass) const;
 
  virtual OdRxObjectPtr clone() const;
  
  virtual void copyFrom(
    const OdRxObject* pSource);
 
  virtual OdRx::Ordering comparedTo(
    const OdRxObject* pOther) const;
 
  virtual bool isEqualTo(
    const OdRxObject* pOther) const;
};
 
 
 
void OdRxObjectPtr::internalAddRef()
{
  if(m_pObject) { m_pObject->addRef(); }
}
void OdRxObjectPtr::release()
{
  if (m_pObject)
  {
    m_pObject->release();
    m_pObject = NULL;
  }
}
 
#include "SmartPtr.h"
 
 
enum OverrulingType
  {
    kDrawableOverrule = 0,
    kObjectOverrule,
    kPropertiesOverrule,
    kGeometryOverrule,
    kHighlightOverrule,
    kSubentityOverrule,
    kGripOverrule,
    kTransformOverrule,
    kOsnapOverrule,
    kVisibilityOverrule,
    kTotalOverrules
  };
 
class OdRxOverruleIterator;
class OdRxMemberCollection;
class OdRxAttributeCollection;
class OdRxMemberCollectionBuilder;
typedef void(*OdRxMemberCollectionConstructorPtr)(OdRxMemberCollectionBuilder&, void*);
 
typedef OdRxObjectPtr (*OdPseudoConstructorType)();
class OdRxClassImpl;
 
class FIRSTDLL_EXPORT OdRxClass : public OdRxObject
{
  friend class OdRxClassImpl;
protected:
  OdRxClassImpl* m_pImpl;
  OdRxClass(OdRxClassImpl*);
public:
  ODRX_DECLARE_MEMBERS(OdRxClass);
  OdRxClass();
  ~OdRxClass();
 
  OdRxObjectPtr addX(
    OdRxClass* pProtocolClass, 
    OdRxObject* pProtocolObject);
 
  OdRxObjectPtr getX(
    const OdRxClass* pProtocolClass);
 
  OdRxObjectPtr delX(
    OdRxClass* pProtocolClass);
  
  virtual OdRxObjectPtr create() const;
 
  const OdString appName() const;
 
  AppNameChangeFuncPtr appNameCallbackPtr() const;
 
  const OdString dxfName() const;
 
  const OdString name() const;
 
  OdDb::DwgVersion getClassVersion(
    OdDb::MaintReleaseVer* pMaintReleaseVer = 0) const;
 
  OdUInt32 proxyFlags() const;
  
  virtual bool isDerivedFrom(
    const OdRxClass* pClass) const;
 
  OdRxClass* myParent() const;
 
  OdRxModule* module() const;
 
  OdPseudoConstructorType constructor();
 
  void setConstructor(
    OdPseudoConstructorType psuedoConstr);
 
  OdUInt32 customFlags() const;
 
  OdRxMemberCollection* members() const;
  const OdRxAttributeCollection& attributes() const;
  OdRxAttributeCollection& attributes();
};
 
typedef OdSmartPtr<OdRxClass> OdRxClassPtr;
 
inline bool OdRxObject::isKindOf(const OdRxClass* pClass) const {  
  //FELIX_CHANGE_BEGIN isKindOf() not working with reactors wich has multiple inheritance of parent
  //return isA()->isDerivedFrom(pClass);
  if ( isA() && isA()->isDerivedFrom( pClass ) )
  {
    return true;
  }
 
  OdRxObjectPtr pRes;
  pRes.attach( queryX( pClass ) );
  return ( !pRes.isNull() );
  //FELIX_CHANGE_END
}
 
template <class Class, class Parent>
OdRxObject* odQueryXImpl(const Class* pThis, const OdRxClass* pClass)
{
  OdRxObject* pObj = 0;
  if (!pClass) // requested class is not registred
    return pObj;
  if(pClass == Class::desc())
  {
    pObj = (OdRxObject*)pThis;
    pObj->addRef();
  }
  else
  {
    pObj = Class::desc()->getX(pClass).detach();
    if(!pObj)
      pObj = pThis->Parent::queryX(pClass);
  }
  return pObj;
}
 
FIRSTDLL_EXPORT OdRxObjectPtr odrxCreateObject(
    const OdString& sClassName);
 
FIRSTDLL_EXPORT OdRxClass* newOdRxClass(
    const OdString& sClassName,
    OdRxClass* pBaseClass,
    OdPseudoConstructorType pConstr = 0,
    int DwgVer = 0,
    int MaintVer = 0,
    int nProxyFlags = 0,
    const OdString& sDxfName = OdString::kEmpty,
    const OdString& sAppName = OdString::kEmpty,
    AppNameChangeFuncPtr fNameChangeFunc = NULL,
    int nCustomFlags = 0,
    OdRxMemberCollectionConstructorPtr memberConstruct = 0,
    void* userData = 0
  );
 
FIRSTDLL_EXPORT void deleteOdRxClass(
  OdRxClass* pClass);
 
typedef OdArray<OdRxObjectPtr> OdRxObjectPtrArray;
 
typedef void (*ODRXOBJECT_CALLBACK)(const OdRxObject*);
FIRSTDLL_EXPORT void odrxRegisterDestructorCallback(const ODRXOBJECT_CALLBACK callbackFunc);
FIRSTDLL_EXPORT void odrxUnregisterDestructorCallback();
 
#include "TD_PackPop.h"
 
#endif //_ODRXOBJECT_INCLUDED_