{"type":"doc","content":[{"type":"heading","attrs":{"level":1},"content":[{"text":"Creating Custom Applications","type":"text"}]},{"type":"paragraph","content":[{"text":"Teigha provides the facilities for creating dynamically loaded custom modules and custom objects derived from Teigha classes.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Creating a Custom Module","type":"text"}]},{"type":"paragraph","content":[{"text":"To create a custom module, create a subclass of OdRxModule as in the following example:","type":"text"}]},{"type":"codeBlock","content":[{"text":"class CustomObjectsModule : public OdRxModule\n{\nprotected:\n void initApp()\n {\n // register the custom object types defined in this module\n ExCustObject::rxInit();\n ExCustEntity::rxInit();\n ExSphere::rxInit();\n\n // custom commands can be registered here\n }\n\n void uninitApp()\n {\n // unregister the custom object types defined in this module\n ExSphere::rxUninit();\n ExCustEntity::rxUninit();\n ExCustObject::rxUninit();\n\n // remove custom commands here\n }\n};\n\n// macro that defines the entry point for this library\nODRX_DEFINE_DYNAMIC_MODULE(CustomObjectsModule);\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"A custom module should contain exactly 1 subclass of OdRxModule, but can define any number of custom objects.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Naming Convention for Custom Modules","type":"text"}]},{"type":"paragraph","content":[{"text":"The naming rule for the shared library containing the subclass of OdRxModule is ","type":"text"},{"text":"< application name >.drx","type":"text","marks":[{"type":"em"}]},{"text":", where < module name > is the same module name that is used to define the custom object classes in this context.","type":"text"}]},{"type":"heading","attrs":{"level":1},"content":[{"text":"Creating Client Applications","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Smart Pointers","type":"text"}]},{"type":"paragraph","content":[{"text":"DWGdirect clients should use the supplied smart pointer classes when accessing database objects. In the above example, OdDbDatabasePtr is a smart pointer class that wraps a reference to an OdDbDatabase object. All database classes have corresponding smart pointer classes with the \"Ptr\" suffix attached. For example, a smart pointer to an OdDbCircle is an OdDbCirclePtr. When used properly, the DWGdirect smart pointer classes guarantee the proper management of heap objects both, in normal execution cases as well as in cases where exceptions transfer control out of the current scope.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Accessing Database Objects","type":"text"}]},{"type":"paragraph","content":[{"text":"This section describes how to retrieve various types of data from a database.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Accessing System Header Variables","type":"text"}]},{"type":"paragraph","content":[{"text":"You can access header variables directly from an instance of OdDbDatabase.","type":"text"}]},{"type":"paragraph","content":[{"text":"Example:","type":"text","marks":[{"type":"strong"}]}]},{"type":"codeBlock","content":[{"text":"pDb->setLTSCALE(1.2);\nstd::cout << \" LTSCALE: \" << pDb->getLTSCALE() << std::endl;\n","type":"text"}]},{"type":"paragraph","content":[{"text":"In the general case, all header variable access functions are in the form OdDbDatabase::getVARNAME() and OdDbDatabase::setVARNAME().","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Accessing Table Entries","type":"text"}]},{"type":"paragraph","content":[{"text":"To retrieve table data, open the table object and then use an iterator to step through the table entries. The following function iterates through the Layers table and prints the name of each layer, assuming pDb is a valid database and os is an output stream.","type":"text"}]},{"type":"codeBlock","content":[{"text":"\n\nvoid DbDumper::dumpLayers(OdDbDatabase* pDb, STD(ostream) & os)\n{\n // Layer table smart pointer, opened for read.\n OdDbLayerTablePtr pLayers = pDb->getLayerTableId().safeOpenObject();\n\n os << STD(endl) << pLayers->desc()->name() << STD(endl);\n\n // Get a new layer table iterator (as a smart pointer)\n OdDbSymbolTableIteratorPtr pIter = pLayers->newIterator();\n for (pIter->start(); !pIter->done(); pIter->step())\n {\n // Layer Record smart pointer, opened for read.\n OdDbLayerTableRecordPtr pLayer = \n pIter->getRecordId().safeOpenObject();\n\n // Read access to the layer record data:\n os << \" \" << pLayer->getName().c_str() << \" <\" << \n pLayer->desc()->name() << \">\";\n os << \", \" << (pLayer->isOff() ? \"Off\" : \"On\");\n os << \", \" << (pLayer->isLocked() ? \"Locked\" : \"Unlocked\");\n os << \", \" << (pLayer->isDependent() ? \n \"Dep. on XRef\" : \"Not dep. on XRef\");\n os << STD(endl);\n }\n} // end DbDumper::dumpLayers\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"In this example, the use of smart pointers eliminates the need to explicitly close or delete the pointers returned by the calls to OdDbObjectId::safeOpenObject(). Entries from other tables can be obtained in a similar manner.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Accessing Block Entities","type":"text"}]},{"type":"paragraph","content":[{"text":"Entities are owned by blocks (OdDbBlockTableRecord). Therefore, you must open the block first to access its entities. The following code iterates through all entities in all blocks of a drawing and calls the dumpEntity() function for each entity:","type":"text"}]},{"type":"codeBlock","content":[{"text":"\n\nvoid DbDumper::dumpBlocks(OdDbDatabase* pDb, STD(ostream) & os)\n{\n // Open the block table\n OdDbBlockTablePtr pBlocks = \n pDb->getBlockTableId().safeOpenObject();\n \n os << STD(endl) << \"Blocks: \" << STD(endl);\n // Get an iterator for the block table\n OdDbSymbolTableIteratorPtr pBlkIter = pBlocks->newIterator();\n \n // For each block in the block table\n for (pBlkIter->start(); ! pBlkIter->done(); pBlkIter->step())\n {\n // Open the block\n OdDbBlockTableRecordPtr pBlock = \n pBlkIter->getRecordId().safeOpenObject();\n \n os << \" \" << pBlock->getName().c_str() << STD(endl);\n\n // Get an entity iterator\n OdDbObjectIteratorPtr pEntIter = pBlock->newIterator();\n \n // For each entity in the block\n for (; !pEntIter->done(); pEntIter->step())\n {\n dumpEntity(pEntIter->objectId(), os);\n }\n }\n} // end DbDumper::dumpBlocks\n\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Accessing Objects in the Named Objects Dictionary","type":"text"}]},{"type":"paragraph","content":[{"text":"The starting point for accessing objects in a database is the main dictionary object. The following example prints the object hierarchy starting from the main dictionary and recurses into any found subdictionaries (it does not traverse the entire object hierarchy).","type":"text"}]},{"type":"codeBlock","content":[{"text":"\n\nvoid DbDumper::dumpObject(OdDbObjectId id, \n const OdString& itemName,\n STD(ostream) & os, \n const OdString& padding)\n{\n OdString pad(padding);\n // Open the object\n OdDbObjectPtr pObject = id.safeOpenObject();\n\n os << pad.c_str();\n if (!itemName.isEmpty())\n {\n os << itemName.c_str() << \", \";\n }\n\n // Print the object's class name.\n os << \"<\" << pObject->isA()->name() << \">\" << STD(endl);\n\n // Check for specific object types.\n if (pObject->isKindOf(OdDbDictionary::desc()))\n {\n OdDbDictionaryPtr pDic = pObject;\n\n // Get a dictionary iterator.\n OdDbDictionaryIteratorPtr pIter = pDic->newIterator();\n pad += \" \";\n for (; !pIter->done(); pIter->next())\n {\n // Dump each item in the dictionary.\n dumpObject(pIter->objectId(), pIter->name(), os, pad);\n }\n }\n else if (pObject->isKindOf(OdDbXrecord::desc()))\n {\n OdDbXrecordPtr pXRec = pObject;\n // Following is broken for objectID's\n dumpGroupCodes(pXRec->rbChain(), os, pad + \" \");\n }\n else if (pObject->isKindOf(OdDbDimAssoc::desc()))\n {\n dumpDimAssoc(pObject, os, pad);\n }\n} // end DbDumper::dumpObject\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"The above object dump can be initiated from the main dictionary:","type":"text"}]},{"type":"codeBlock","content":[{"text":"dumpObject(pDb->getNamedObjectsDictionaryId(), \n \"Named Objects Dictionary\", \n pDb, \n os, \n \" \");\n","type":"text"}]},{"type":"paragraph","content":[{"text":"To retrive items in a dictionary by item name, use the OdDbDictionary::getAt() function. The following code segment retrieves the entry called \"ACAD_LAYOUT\" from the specified dictionary, if it exists:","type":"text"}]},{"type":"codeBlock","content":[{"text":"OdDbDictionaryPtr pDic = \n pDb->getNamedObjectsDictionaryId().openObject(OdDb::kForRead);\nif (pDic)\n{\n OdDbDictionaryPtr pLayoutDic = \n pDic->getAt(\"ACAD_LAYOUT\", OdDb::kForRead);\n if (pLayoutDic)\n {\n // Do something with the layout dictionary\n }\n}\n","type":"text"}]},{"type":"paragraph","content":[{"text":"Note","type":"text","marks":[{"type":"strong"}]},{"text":": The layout dictionary ID can be accessed directly from a database by calling OdDbDatabase::getLayoutDictionaryId().","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Creating Objects","type":"text"}]},{"type":"paragraph","content":[{"text":"The base class for all objects that require runtime type identification is OdRxObject - the base class for all database objects and many other auxiliary classes that Teigha uses. You can create instances of OdRxObject by calling the static OdRxClass::createObject() function.","type":"text"}]},{"type":"paragraph","content":[{"text":"Example:","type":"text","marks":[{"type":"strong"}]}]},{"type":"paragraph","content":[{"text":"The following code segment creates a dictionary object:","type":"text"}]},{"type":"codeBlock","content":[{"text":"OdDbDictionaryPtr pDic;\npDic = OdDbDictionary::createObject();\n","type":"text"}]},{"type":"paragraph","content":[{"text":"An object created using this method does not belong to a database when it is first created. The client must explicitly add it to a database. The following code segment creates a new dictionary, an xrecord, and adds the new objects the main dictionary. As the following example demonstrates, an OdDbObjectID is assigned to an object when the object is added to a database and this OdDbObjectID is normally returned by the function that added the object (OdDbDictionary::setAt in this case).","type":"text"}]},{"type":"codeBlock","content":[{"text":"\nvoid DbFiller::addCustomObjects(OdDbDatabase* pDb)\n{\n //Open the main dictionary\n OdDbDictionaryPtr pMain = \n pDb->getNamedObjectsDictionaryId().safeOpenObject(OdDb::kForWrite);\n\n // Create the new dictionary.\n OdDbDictionaryPtr pOdtDic = OdDbDictionary::createObject();\n \n // Add new dictionary to the main dictionary.\n OdDbObjectId dicId = pMain->setAt(\"DWGDIRECT_OBJECTS\", pOdtDic);\n \n // Create a new xrecord object.\n OdDbXrecordPtr pXRec = OdDbXrecord::createObject();\n\n // Add the xrecord the owning dictionary.\n OdDbObjectId xrId = pOdtDic->setAt(\"PROPERTIES_1\", pXRec);\n \n OdResBufPtr pRb, temp;\n temp = pRb = OdResBuf::newRb(1000);\n temp->setString(\"Sample XRecord Data\");\n \n temp = appendXDataPair(temp, 40);\n temp->setDouble(3.14159);\n \n temp = appendXDataPair(temp, 70);\n temp->setInt16(312);\n \n pXRec->setFromRbChain(pRb);\n} //end DbFiller::addCustomObjects\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"To add an object to a database, perform the following steps:","type":"text"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Open the parent object for writing. The parent is the object that will own the newly created object within the database hierarchy.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Create the new object.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Set the minimal number of properties required to add the object to the database:","type":"text"},{"type":"hardBreak"},{"text":"Table entries","type":"text","marks":[{"type":"strong"}]},{"text":" must have a name before adding them to the database.","type":"text"},{"type":"hardBreak"},{"text":"Entities","type":"text","marks":[{"type":"strong"}]},{"text":" can be added to a database without setting any properties.","type":"text"},{"type":"hardBreak"},{"text":"Objects","type":"text","marks":[{"type":"strong"}]},{"text":" can be added to a database without setting any properties.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Add the new object to its parent, getting back the new Object ID for this object. Adding the object to a database does not change its open status. The object remains open for writing after it was added to a database.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Set the remaining properties for the new object.","type":"text"},{"type":"hardBreak"},{"text":"Note","type":"text","marks":[{"type":"strong"}]},{"text":": Some properties can only be set on a database resident object. As a general rule, it is easier to set all remaining properties (other than those specified above) after the object was added to the database.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Close the object and its parent. This happens implicitly when the smart pointers used to open and create the objects are destroyed. Alternatively, you can explicitly destroy them by calling the OdSmartPtr::release() method on the appropriate smart pointer objects.","type":"text"}]}]}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Creating New Table Objects","type":"text"}]},{"type":"paragraph","content":[{"text":"To add table objects to a database, do the following:","type":"text"}]},{"type":"orderedList","attrs":{"order":1},"content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Open the table to which the new object will be added, in OdDb::kForWrite mode.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Create the new table entry.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Set the name of the entry, and any other desired properties.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Add the new entry to the open table object.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Close the table entry and table objects (this is done automatically when the smart pointers holding references to these objects go out of scope).","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"Example:","type":"text"}]},{"type":"paragraph","content":[{"text":"The following function adds a new layer to a database:","type":"text"}]},{"type":"codeBlock","content":[{"text":"\nOdDbObjectId DbFiller::addLayer(OdDbDatabase* pDb, const OdString& layerName)\n{\n // Add a new layer to the drawing\n OdDbLayerTablePtr pLayers;\n OdDbLayerTableRecordPtr pLayer;\n OdDbObjectId id;\n\n pLayers = pDb->getLayerTableId().safeOpenObject(OdDb::kForWrite);\n pLayer = OdDbLayerTableRecord::createObject();\n\n // Name must be set before a table object is added to a table.\n pLayer->setName(layerName);\n\n // Add the object to the table.\n id = pLayers->add(pLayer);\n\n return id;\n} // end DbFiller::addLayer\n\n","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Creating New Entities","type":"text"}]},{"type":"paragraph","content":[{"text":"Entities are owned by OdDbBlockTableRecord objects. To create an entity and add it to a block, do the following:","type":"text"}]},{"type":"bulletList","content":[{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Open the OdDbBlockTableRecord to which you want to add the new entity in OdDb::kForWrite mode.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Create the new entity.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Add the new entity to the open OdDbBlockTableRecord object.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"If necessary, set the properties for the newly created entity.","type":"text"}]}]},{"type":"listItem","content":[{"type":"paragraph","content":[{"text":"Close the OdDbBlockTableRecord object and the new entity. This is automatically done when the smart pointers holding references to these objects go out of scope.","type":"text"}]}]}]},{"type":"paragraph","content":[{"text":"The following example adds an OdDbBlockReference entity to a specified block:","type":"text"}]},{"type":"codeBlock","content":[{"text":"\nOdDbObjectId DbFiller::addInsert(\n OdDbDatabase* pDb, // owning database\n OdDbBlockTableRecord* pBlock, // block to which insert will be added\n const OdDbObjectId& blockId, // ID of block to be inserted\n double xscale, // X scale for insertion\n double yscale) // X scale for insertion\n{\n OdDbObjectId brefId;\n \n // Create the new insert entity.\n OdDbBlockReferencePtr pBlkRef = OdDbBlockReference::createObject();\n // Add the entity to the parent block.\n brefId = pBlock->appendOdDbEntity(pBlkRef);\n\n // Set the remaining entity properties.\n pBlkRef->setBlockTableRecord(blockId);\n pBlkRef->setScaleFactors(OdGeScale3d(xscale, yscale, 1.0));\n pBlkRef->setPosition(OdGePoint3d(6, 6, 0));\n return brefId;\n} // end DbFiller::addInsert\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"Other entities, such as circles and lines can be added in a similar manner.","type":"text"}]},{"type":"heading","attrs":{"level":2},"content":[{"text":"Advanced Data Extraction","type":"text"}]},{"type":"paragraph","content":[{"text":"This section describes advanced functionality and techniques for extracting data from a DWG/DXF file using Teigha.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Dispatching on Entity Type","type":"text"}]},{"type":"paragraph","content":[{"text":"Applications that process entity data from a database require functionalities to identify each entity by its type and perform type-specific processing on the entity. Teigha uses a mechanism called ","type":"text"},{"text":"protocol extension","type":"text","marks":[{"type":"strong"}]},{"text":" to provide this functionality. Protocol extension allows a client application to create a new class and associate a class instance with a particular class of database objects. The new class instance may be retrieved from a generalization of the class with which it was registered, providing an effective means of dispatching by type.","type":"text"}]},{"type":"paragraph","content":[{"text":"As an example, consider the protocol extension classes defined in ExProtocolExtension.h and ExProtocolExtension.cpp. The purpose of these classes is to dump the contents of the entities in a database, based on entity type. The implementation can be split into the following steps.","type":"text"}]},{"type":"heading","attrs":{"level":4},"content":[{"text":"Create the Parent Dispatching Class","type":"text"}]},{"type":"paragraph","content":[{"text":"The following class is the parent class for our entity dumpers:","type":"text"}]},{"type":"codeBlock","content":[{"text":"\nclass OdDbEntity_Dumper : public OdRxObject\n{\npublic:\n ODRX_DECLARE_MEMBERS(OdDbEntity_Dumper);\n\n virtual void dump(OdDbEntity* pEnt, STD(ostream) &os) const;\n}; // end class OdDbEntity_Dumper\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"This class MUST be derived from OdRxObject.","type":"text"}]},{"type":"heading","attrs":{"level":4},"content":[{"text":"Create One or More Child Dispatching Classes","type":"text"}]},{"type":"paragraph","content":[{"text":"The following code defines a class for dumping OdDb2dPolyline entities. It overrides the OdDbEntity_Dumper::dump() function to dump the data specific to this entity.","type":"text"}]},{"type":"codeBlock","content":[{"text":"\nclass OdDb2dPolyline_Dumper : public OdDbEntity_Dumper\n{\npublic:\n\n void dump(OdDbEntity* pEnt, STD(ostream) & os) const\n {\n dumpCommonData(pEnt, os);\n\n OdDb2dPolylinePtr pPoly = pEnt;\n OdDbObjectIteratorPtr pIter = pPoly->vertexIterator();\n for (; !pIter->done(); pIter->step())\n {\n OdDb2dVertexPtr pVertex = pIter->entity();\n if (pVertex.get())\n {\n os << \" \" << pVertex->isA()->name() << STD(endl);\n }\n }\n }\n}; // end class OdDb2dPolyline_Dumper\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"These classes MUST be derived from the parent dispatching class, in this case OdDbEntity_Dumper.","type":"text"}]},{"type":"heading","attrs":{"level":4},"content":[{"text":"Register the Custom Dispatching Classes","type":"text"}]},{"type":"paragraph","content":[{"text":"The following function registers custom dumper classes for a number of entity types:","type":"text"}]},{"type":"codeBlock","content":[{"text":"\nvoid ExProtocolExtension::initialize()\n{\n // Register OdDbEntity_Dumper with DWGdirect\n OdDbEntity_Dumper::rxInit();\n m_pDumpers = new Dumpers;\n m_pDumpers->addXs();\n \n}// end ExProtocolExtension::initialize()\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"The Dumpers::addXs() function does the following:","type":"text"}]},{"type":"codeBlock","content":[{"text":"\n void addXs()\n {\n OdDbEntity::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_entityDumper);\n OdDbRegion::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_regionDumper);\n OdDbPolyline::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_polylineDumper);\n OdDb2dPolyline::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_2dPolylineDumper);\n OdDb3dPolyline::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_3dPolylineDumper);\n OdDbPolyFaceMesh::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_polyFaceMeshDumper);\n OdDbPolygonMesh::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_polygonMesh);\n OdDbBlockReference::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_blockReference);\n OdDbMInsertBlock::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_mInsertBlock);\n OdDbSpline::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_splineDumper);\n OdDbEllipse::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_ellipseDumper);\n OdDbSolid::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_solidDumper);\n OdDbTrace::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_traceDumper);\n OdDb3dSolid::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_3DSolidDumper);\n OdDbProxyEntity::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_proxyEntityDumper);\n OdDbHatch::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_hatchDumper);\n OdDbCircle::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_circleDumper);\n OdDbMText::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_mTextDumper);\n OdDbText::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_textDumper);\n OdDbMline::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_mlineDumper);\n OdDbRasterImage::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_imageDumper);\n OdDbArcAlignedText::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_arcAlignedTextDumper);\n OdDbOle2Frame::desc()->addX(\n OdDbEntity_Dumper::desc(), &m_ole2FrameDumper);\n } // end addXs\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"All dumpers are registered for the OdDbEntity_Dumper class, so that the dumpers associated with a particular instance of OdDbEntity can be retrieved in a consistent manner by retrieving the dumper registered with OdDbEntity_Dumper.","type":"text"}]},{"type":"heading","attrs":{"level":4},"content":[{"text":"Retrieve and Call the Registered Dispatching Class","type":"text"}]},{"type":"paragraph","content":[{"text":"The following function retrieves the custom dispatching class associated with a particular OdDbEntity instance and calls the virtual dump() method to display the contents of this entity.","type":"text"}]},{"type":"codeBlock","content":[{"text":"\nvoid DbDumper::dumpEntity(OdDbObjectId id, STD(ostream) & os)\n{\n // Open the entity\n OdDbEntityPtr pEnt = id.safeOpenObject();\n\n // Retrieve the registered protocol extension object registered \n // for this object type.\n OdSmartPtr pEntDumper = pEnt;\n\n pEntDumper->dump(pEnt, os);\n \n dumpGroupCodes(pEnt->xData(), os, \" \"); \n\n if (!pEnt->extensionDictionary().isNull())\n {\n dumpObject(pEnt->extensionDictionary(), \n \"ACAD_XDICTIONARY\", os, \" \");\n }\n} // end DbDumper::dumpEntity\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"The custom dispatching object registered for this object type is retrieved by a simple assignment.","type":"text"}]},{"type":"heading","attrs":{"level":3},"content":[{"text":"Extracting Geometry from Unsupported Entity Types","type":"text"}]},{"type":"paragraph","content":[{"text":"The OdDbEntity class defines a virtual OdDbEntity::worldDraw() function, which is used for vectorization. Each class derived from OdDbEntity overrides this function in order to perform custom vectorization. This function provides a convenient method for extracting the geometric representation of an entity in a generic manner.","type":"text"}]},{"type":"paragraph","content":[{"text":"For example, a client application can extract the vector data associated with an unsupported OdDbEntity descendant by deriving a new class from OdGiWorldGeometry (see the OdGiWorldGeometryDumper class from OdReadEx as an example) and then passing an instance of this class to OdDbEntity::worldDraw() to receive the vector geometry and attributes from the entity. For the complete implemention of this class, see GiWorldDrawDumper.h and GiWorldDrawDumper.cpp within the OdReadEx sample folder.","type":"text"}]},{"type":"paragraph","content":[{"text":"The following code is a protocol extension class for OdDbEntity that uses the sample OdGiWorldGeometryDumper class to print the vector information contained in an OdEntity:","type":"text"}]},{"type":"codeBlock","content":[{"text":"\nvoid OdDbEntity_Dumper::dump(OdDbEntity* pEnt, STD(ostream) & os) const\n{\n dumpCommonData(pEnt, os);\n \n os << \" \" << \"Entity graphics data:\" << STD(endl);\n \n // Dump the graphics data of \"unknown\" entity\n // graphics for proxy entity are retrieved by the same way\n OdGiContextDumper ctx(pEnt->database());\n OdGiWorldDrawDumper wd(os);\n wd.setContext(&ctx);\n pEnt->worldDraw(&wd);\n} // end OdDbEntity_Dumper::dump\n\n","type":"text"}]},{"type":"paragraph","content":[{"text":"This method can be used to extract the geometry data from any OdDbEntity type.","type":"text"}]}],"version":1}