AcDbEntity类
具有一个图形表示的所有数据库对象的基类。
继承自
AcDbObject
包含文件
dbmain.h
参见
AcRxObject
成员
|
AcDbEntity::~AcDbEntity
函数 inline virtual ~AcDbEntity(); 析构器。 |
|
AcDbEntity::AcDbEntity
函数 AcDbEntity(); 默认建构器。此建构器被保护以强制将此类作为基类使用。此建构器初始化color为257，linetype和layer的objectIds为AcDbObjectId::kNull，且实体为可见的。 如果在实体增加至数据库中时，color、layer和linetype没有被设置，则实体使用数据库默认的color、LayerTableRecord对象ID和LinetypeTableRecord对象ID。 |
|
AcDbEntity::explode 函数 virtual
Acad::ErrorStatus explode( AcDbVoidPtrArray& entitySet)
const;
函数用途 此函数主要用于被AutoCAD调用实现包含此实体的一个分解操作的部分。然而，此函数可被ObjectARX应用程序使用以取得非数据库驻留的实体对象的指针的数组，这些实体对作为它的分解后的部分。 当调用此函数时，entitySet数组不需要为空。此函数将它创建的作为分解结果的实体的指针增加至这个数组中。 如果此函数成功将返回Acad::eOk。其他的返回值可能根据执行的方式而定。 在派生类中的执行 此函数应动态地创建（使用C++的new操作符）适当的作为分解结果取代原实体的实体对象。这些实体的指针则增加至entitySet数组中。一旦这些指针被增加，函数将返回一个Acad::eOk的状态。 注意：此函数不能将新实体增加至数据库中，也不能删除实体的部分。这些步骤将由AutoCAD（或调用此函数的其他应用程序考虑。 这也表示在一个应用程序调用一个对象的分解方法时，调用的应用程序要负责处理结果实体（即，增加它们至数据库或在不需要时删除它们）和删除原始实体（如果合适）。 默认的执行 立即返回Adesk::eNotApplicable。 自定义实体 当使用一个自定义实体时，必须定义一个分解方法使AutoCAD命令BHATCH和EXPLODE工作。分解方法应打散实体至更简单的实体。如果这些实体不是本地实体，则这个方法将返回eExplodeAgain，这将导致BHATCH在返回的实体上递归地调用分解方法，直至实体被分为本地实体。 |
||||||||||
|
AcDbEntity::moveGripPointsAt
函数 virtual
Acad::ErrorStatus moveGripPointsAt( const
AcDbIntArray& indices, const
AcGeVector3d& offset);
函数用途 此函数在实体的夹点编辑中被AutoCAD调用。然而，ObjectARX应用程序也可能调用此函数。 在调用此函数之间应先调用实体的getGripPoints()方法，以取得有效的夹点和它们进入的顺序（用于确定在indices数组中传递的索引值）。 偏移矢量表示应用至indices指定的夹点的变换的方向和大小。 最终，此函数将以适当的方法修改实体，从而使indices中的索引值标识的夹点以offset矢量表示方向和大小移动。 如果此函数成功将返回Acad::eOk。其他的返回值根据执行的方式而定。 在派生类中的执行 此函数必须修改实体，从而使indices数组标识的夹点变换至offset矢量（WCS坐标中）表示的方向和大小。这对实体其余部分的影响将根据实体而定，但此函数的其他影响也必须被考虑，因为这个函数将执行夹点编辑导致的所有实体修改。 如果此函数在一个派生类中执行，则getGripPoints()方法也必须被执行，因为indices数组中的索引值表示夹点的基于0的索引，这些索引被增加至传递给getGripPoints()方法的数组中。因此indices数组中的0值对应getGripPoints()方法增加至传递给它的数组的第一点，indices数组中的1值对应getGripPoints()方法增加的第二点，依此类推。因此，例如，如果用户“夹住”getGripPoints()方法增加的第一点和第三点，则indices数组将有两个元素。第一个为0，第二个为2。 因为此函数依赖于getGripPoints()方法增加的点，所有此函数知道getGripPoints()方法报告的点和报告的顺序（即，它们增加至传递给getGripPoints()方法的数组的顺序）。 如果执行成功则返回Acad::eOk。错误条件下的返回值根据执行器而定。 默认执行 使用将整个实体变换offset的一个变换矩阵调用实体的AcDbEntity::transformBy()方法。返回transformBy()方法返回的状态值。 |
||||||||||
|
AcDbEntity::moveStretchPointsAt
函数 virtual
Acad::ErrorStatus moveStretchPointsAt( const
AcDbIntArray& indices, const
AcGeVector3d& offset);
函数用途 此函数在有选中实体的拉伸命令执行时被AutoCAD调用。然而，ObjectARX应用程序也可能调用此函数。 在调用此函数之间应先调用实体的getStretchPoints()方法，以取得有效的拉伸点和它们进入的顺序（用于确定在indices数组中传递的索引值）。 偏移矢量表示应用至indices指定的拉伸点的变换的方向和大小。 最终，此函数将以适当的方法修改实体，从而使indices中的索引值标识的拉伸点以offset矢量表示方向和大小移动。 如果此函数成功将返回Acad::eOk。其他的返回值根据执行的方式而定。 在派生类中的执行 此函数必须修改实体，从而使indices数组标识的拉伸点变换至offset矢量（WCS坐标中）表示的方向和大小。这对实体其余部分的影响将根据实体而定，但此函数的其他影响也必须被考虑，因为这个函数将执行拉伸点操作导致的所有实体修改。 如果此函数在一个派生类中执行，则getStretchPoints()方法也必须被执行，因为indices数组中的索引值表示夹点的基于0的索引，这些索引被增加至传递给getStretchPoints()方法的数组中。因此indices数组中的0值对应getStretchPoints()方法增加至传递给它的数组的第一点，indices数组中的1值对应getStretchPoints()方法增加的第二点，依此类推。因此，例如，如果getGripPoints()方法增加的第一点和第三点被拉伸操作“拉伸”，则indices数组将有两个元素。第一个为0，第二个为2。 因为此函数依赖于getStretchPoints()方法增加的点，所有此函数知道getStretchPoints()方法报告的点和报告的顺序（即，它们增加至传递给getStretchPoints()方法的数组的顺序）。 如果执行成功则返回Acad::eOk。错误条件下的返回值根据执行器而定。 默认执行 使用将整个实体变换offset的一个变换矩阵调用实体的AcDbEntity::transformBy()方法。返回transformBy()方法返回的状态值。 |
||||||||||
|
AcDbEntity::setColor 函数 virtual
Acad::ErrorStatus setColor( const AcCmColor&
color, Adesk::Boolean
doSubents = true);
函数用途 此方法设置实体的颜色为包含在color中的索引。如果实体拥有子实体且doSubents
== Adesk::kTrue，则颜色变化也将应用至子实体上。 注意：kTrue有效的内建的实体只有：AcDb2dPolyline,
AcDb3dPolyline, AcDbPolyFaceMesh,和AcDbPolygonMesh。 注意：此方法提供方法允许未来的AutoCAD版本扩允当前支持的256种颜色。setColorIndex()方法提供了此函数当前具有的相同的功能，但更易使用且更有效，因为它直接使用AutoCAD颜色索引。 如果成功返回Acad::eOk。如果不成功，将产生一个普通的AutoCAD错误，因为此函数在AutoCAD内部发生错误时一定失效。 在派生类中的执行 如果此函数被重载且希望设置实体的颜色，则必须传递color和doSubents参数调用AcDbEntity::setColorIndex()或传递从color取得的AutoCAD颜色索引和doSubents值调用AcDbEntity::setColor()。 此函数也可以直接处理任何子实体并将Adesk::kFalse的doSubents值传递给AcDbEntity::setColor()或AcDbEntity::setColorIndex()。 如果颜色设置操作成功，则此函数返回Acad::eOk。错误的返回值根据执行器而定。 |
||||||||||
|
AcDbEntity::setColorIndex
函数 virtual
Acad::ErrorStatus setColorIndex( Adesk::UInt16 color, Adesk::Boolean
doSubents = true);
函数用途 此方法设置实体的颜色为包含在color中的索引。如果实体拥有子实体且doSubents
== Adesk::kTrue，则颜色变化也将应用至子实体上。 注意：kTrue有效的内建的实体只有：AcDb2dPolyline,
AcDb3dPolyline, AcDbPolyFaceMesh,和AcDbPolygonMesh。 颜色值必须在0至256之间。0和256为特殊值。 0表示实体使用显示它的块参照的颜色。如果实体不通过一个块参照显示（例如，它直接被模型空间的块表参照拥有）且它的颜色为0，则它将以颜色7显示。 256表示实体使用它参照的层表记录中指定的颜色。 如果成功返回Acad::eOk。如果颜色值超出许可范围则返回Acad::eInvalidIndex。 在派生类中的执行 如果此函数被重载且希望设置实体的颜色，则必须传递color和doSubents参数调用AcDbEntity::setColorIndex()或传递从color取得的AutoCAD颜色索引和doSubents值调用AcDbEntity::setColor()。 此函数也可以直接处理任何子实体并将Adesk::kFalse的doSubents值传递给AcDbEntity::setColor()或AcDbEntity::setColorIndex()。 如果颜色设置操作成功，则此函数返回Acad::eOk。错误的返回值根据执行器而定。 |
||||||||||
|
AcDbEntity::setDatabaseDefaults
函数 void setDatabaseDefaults( AcDbDatabase* pDb);
此函数设置实体的以下属性： ·
颜色 ·
层 ·
线型 ·
线型比例 ·
可见性 ·
绘图样式名 ·
线宽 为pDb表示的数据库的默认值。如果pDb == NULL，则使用AutoCAD编辑器中当前的数据库。 void setDatabaseDefaults(); 此函数设置实体的以下属性： ·
颜色 ·
层 ·
线型 ·
线型比例 ·
可见性 ·
绘图样式名 ·
线宽 为实体当前驻留的数据库的默认值，或者，如果实体不是一个数据库的部分，则使用AutoCAD编辑器中的当前数据库。 |
||||||||||
|
AcDbEntity::setLayer 函数 virtual
Acad::ErrorStatus setLayer( AcDbObjectId newVal, Adesk::Boolean
doSubents = true);
This method sets the
entity to reference the AcDbLayerTableRecord that has the object
ID newVal. If the entity owns subentities and doSubents == Adesk::kTrue, then
the layer change will be applied to the subentities as well. Note The only built-in
entities for which kTrue has an effect are: AcDb2dPolyline, AcDb3dPolyline,
AcDbPolyFaceMesh, and AcDbPolygonMesh. If the 函数 is successful, then Acad::eOk is returned. If the object with
object ID newVal is not an AcDbLayerTableRecord, then Acad::eWrongObjectType
will be returned. An attempt is made to
open (for read) the object identified by newVal in order to determine if it
is indeed an AcDbLayerTableRecord. If the open attempt fails, then the error
status returned by the failed open attempt will be returned by this 函数 (see the acdbOpenObject() method documentation for
possible return values). 函数 implementation in derived classes If this 函数 is overridden and wishes to set the layer of
the entity, then it must call AcDbEntity::setLayer() passing on the layer and
doSubents arguments or call the other AcDbEntity::setLayer() passing in the
doSubents value and a string which is the layer's name. It is also possible
for this 函数's
implementation to deal directly with any subentities and pass a doSubents
value of Adesk::kFalse to AcDbEntity::setLayer() If this 函数 is successful, it should return Acad::eOk. Any
other error return values are up to the implementor, but if it calls either
of the AcDbEntity::setLayer() methods and that call returns an error, then
it's recommended that the ErrorStatus value returned be returned by this 函数 as well. virtual
Acad::ErrorStatus setLayer( const char* newVal, Adesk::Boolean
doSubents = true);
This method sets
entity to reference the AcDbLayerTableRecord identified by the name specified
in newVal. If the entity owns subentities and doSubents == Adesk::kTrue, then
the layer change will be applied to the subentities as well. Note The only built-in
entities for which kTrue has an effect are: AcDb2dPolyline, AcDb3dPolyline,
AcDbPolyFaceMesh, and AcDbPolygonMesh. The database
containing the entity is searched for the AcDbLayerTableRecord object with
the name pointed to by newVal. If the entity is not currently in a database,
then the database currently in the AutoCAD editor is searched. If a matching
LayerTableRecord is found then the entity will be set to reference it and
Acad::eOk will be returned. If no LayerTableRecord
object is found with the name pointed to by newVal, then Acad::eKeyNotFound
will be returned. If the
LayerTableRecord object found has been erased, then Acad::eDeletedEntry will
be returned. If the entity is not
within a database and there is no database in the AutoCAD editor, then
Acad::eNoDatabase will be returned. 函数 implementation in derived classes If this 函数 is overridden and wishes to set the layer of
the entity, then it must call AcDbEntity::setLayer() passing on the layer and
doSubents arguments or call the other AcDbEntity::setLayer() passing in the
doSubents value and the objectId of the AcDbLayerTableRecord to reference. It is also possible
for this 函数's
implementation to deal directly with any subentities and pass a doSubents
value of Adesk::kFalse to AcDbEntity::setLayer(). If this 函数 is successful, it should return Acad::eOk. Any
other error return values are up to the implementor, but if it calls either
of the AcDbEntity::setLayer() methods and that call returns an error, then
it's recommended that the ErrorStatus value returned be returned by this 函数 as well. |
||||||||||
|
AcDbEntity::setLinetype
函数 virtual Acad::ErrorStatus setLinetype( const char* newVal, Adesk::Boolean
doSubents = true);
函数 usage This method sets the
entity to reference the AcDbLinetypeTableRecord with the name
specified in newVal. If the entity owns subentities and doSubents ==
Adesk::kTrue, then the linetype change will be applied to the subentities as
well. Note The only built-in
entities for which kTrue has an effect are: AcDb2dPolyline, AcDb3dPolyline,
AcDbPolyFaceMesh, and AcDbPolygonMesh. The database
containing the entity is searched for the AcDbLinetypeTableRecord object with
the name pointed to by newVal. If the entity is not currently in a database,
then the database currently in the AutoCAD editor is searched. If a matching
LinetypeTableRecord is found then the entity will be set to reference it and
Acad::eOk will be returned. If no
LinetypeTableRecord object is found with the name pointed to by newVal, then
Acad::eKeyNotFound will be returned. If the
LinetypeTableRecord object found has been erased, then Acad::eDeletedEntry
will be returned. If the entity is not within
a database and there is no database in the AutoCAD editor, then
Acad::eNoDatabase will be returned. 函数 implementation in derived classes If this 函数 is overridden and wishes to set the
LinetypeTableRecord referenced by the entity, then it must call AcDbEntity::setLinetype(char*,
Adesk::Boolean) passing on the newVal and doSubents arguments or call
AcDbEntity::setLinetype(AcDbObjectId, Adesk::Boolean) passing in the
doSubents argument and the object ID of the LinetypeTableRecord that has the
name pointed to by newVal. It is also possible
for this 函数's
implementation to deal directly with any subentities and pass a doSubents
value of Adesk::kFalse to AcDbEntity::setLinetype(). If this 函数 is successful, it should return Acad::eOk. Any
other error return values are up to the implementor, but if it calls either
of the AcDbEntity::setLinetype() methods and that call returns an error, then
it's recommended that the ErrorStatus value returned be returned by this 函数 as well. virtual
Acad::ErrorStatus setLinetype( AcDbObjectId newVal, Adesk::Boolean
doSubents = true);
函数 usage This method sets the
linetype value for an entity by the AcDbObjectId specified in
"newVal", which must be a symbol table record specifying the
linetype. If the entity owns subentities and doSubents == Adesk::kTrue, then the
linetype change will be applied to the subentities as well. Note The only built-in
entities for which kTrue has an effect are: AcDb2dPolyline, AcDb3dPolyline,
AcDbPolyFaceMesh, and AcDbPolygonMesh. If the 函数 is successful, then Acad::eOk is returned. If the object with
object ID newVal is not an AcDbLinetypeTableRecord, then
Acad::eWrongObjectType will be returned. An attempt is made to
open (for read) the object identified by newVal in order to determine if it
is indeed an AcDbLinetypeTableRecord. If the open attempt fails, then the
error status returned by the failed open attempt will be returned by this 函数 (see the acdbOpenObject() method documentation for
possible return values). 函数 implementation in derived classes If this 函数 is overridden and wishes to set the
LinetypeTableRecord referenced by the entity, then it must call
AcDbEntity::setLinetype(AcDbObject, Adesk::Boolean) passing on the newVal and
doSubents arguments or call AcDbEntity::setLinetype(char*, Adesk::Boolean)
passing in the doSubents argument and a pointer to a string that's the name
of the LinetypeTableRecord with the object ID newVal. It is also possible
for this 函数's
implementation to deal directly with any subentities and pass a doSubents
value of Adesk::kFalse to AcDbEntity::setLinetype(). If this 函数 is successful, it should return Acad::eOk. Any
other error return values are up to the implementor, but if it calls either
of the AcDbEntity::setLinetype() methods and that call returns an error, then
it's recommended that the ErrorStatus value returned be returned by this 函数 as well. |
||||||||||
|
AcDbEntity::setLinetypeScale
函数 virtual
Acad::ErrorStatus setLinetypeScale( double newval, Adesk::Boolean
doSubents = true);
This method sets the entity
to use newval as its linetype scale factor. newVal must be nonnegative. If
the entity owns subentities and doSubents == Adesk::kTrue, then the linetype
scale change will be applied to the subentities as well. Note The only built-in
entities for which kTrue has an effect are: AcDb2dPolyline, AcDb3dPolyline,
AcDbPolyFaceMesh, and AcDbPolygonMesh. Returns Acad::eOk if
successful. If newVal is negative then Acad::eNegativeValueNotAllowed is
returned. 函数 implementation in derived classes If this 函数 is overridden and wishes to set the Linetype
scale of the entity, then it must call AcDbEntity::setLinetypeScale() passing
on the newVal and doSubents arguments. It is also possible
for this 函数's
implementation to deal directly with any subentities and pass a doSubents
value of Adesk::kFalse to AcDbEntity::setLinetypeScale(). If this 函数 is successful, it should return Acad::eOk. Any
other error return values are up to the implementor, but if it calls the
AcDbEntity::setLinetypeScale() method and that call returns an error, then
it's recommended that the ErrorStatus value returned be returned by this 函数 as well. |
||||||||||
|
AcDbEntity::setLineWeight
函数 virtual
Acad::ErrorStatus setLineWeight( AcDb::LineWeight
newVal, Adesk::Boolean
doSubents = true);
This method sets the
entity to use lineweight. If the entity owns subentities and doSubents == Adesk::kTrue,
then the line weight change will be applied to the subentities as well. Returns Acad::eOk if
successful. 函数 implementation in derived classes If this 函数 is overridden and wishes to set the line weight
of the entity, then it must call AcDbEntity::setLineWeight() passing on the
lineweight and doSubents arguments. It is also possible
for this 函数's
implementation to deal directly with any subentities and pass a doSubents
value of Adesk::kFalse to AcDbEntity:: setLineWeight(). If the line weight setting
operation is successful, then this 函数 should return Acad::eOk. If lineweight is not an acceptable value, then
this 函数 should return
Acad::eInvalidInput. Any other error return values are up to the implementor. |
||||||||||
|
AcDbEntity::setPlotStyleName
函数 virtual
Acad::ErrorStatus setPlotStyleName( const char* newName, Adesk::Boolean
doSubents = true);
This 函数 searches the PlotStyleName dictionary
for an entry with the name that matches newName and if found, sets the entity
to use that plotStyleName entry. Because a lookup in the PlotStyleName
dictionary is required, the entity must be database-resident for this method
to succeed. The names ByLayer and ByBlock are allowed as well as user-defined
names. Returns Acad::eOk if
successful. If the entity is not database-resident, then Acad::eNoDatabase
will be returned. If there is no entry in the PlotStyleName dictionary for
newName, then Acad::eKeyNotFound will be returned. The plotStyleName
value is used for DXF group code 390. virtual
Acad::ErrorStatus setPlotStyleName( AcDb::PlotStyleNameType
unnamed, AcDbObjectId newId =
AcDbObjectId::kNull, Adesk::Boolean doSubents
= true);
未说明 |
||||||||||
|
AcDbEntity::setPropertiesFrom
函数 Acad::ErrorStatus setPropertiesFrom( const AcDbEntity*
pEntity, Adesk::Boolean
doSubents = true);
This method copies the ·
Color ·
Layer ·
Linetype ·
Linetype scale ·
Visibility values from the entity
pointed to by pEntity into this entity. If the entity owns subentities and
doSubents == Adesk::kTrue, then the property changes will be applied to the
subentities as well. Returns Acad::eOk if
successful. |
||||||||||
|
AcDbEntity::setVisibility
函数 virtual Acad::ErrorStatus setVisibility( AcDb::Visibility
newVal, Adesk::Boolean
doSubents = true);
This method sets the
visibility of an entity to the value specified by newVal. If the entity owns subentities
and doSubents == Adesk::kTrue, then the visibility change will be applied to
the subentities as well. Note The only built-in
entities for which kTrue has an effect are: AcDb2dPolyline, AcDb3dPolyline,
AcDbPolyFaceMesh, and AcDbPolygonMesh. Returns Acad::eOk if
successful. 函数 implementation in
derived classes If this 函数 is
overridden and wishes to set the visibility of the entity, then it must call
AcDbEntity::setVisibility() passing on the newVal and doSubents arguments. It is also possible
for this 函数's implementation to deal directly with any
subentities and pass a doSubents value of Adesk::kFalse to
AcDbEntity::setVisibility(). If the color setting
operation is successful, then this 函数 should return
Acad::eOk. If color is not an acceptable value, then this 函数 should
return Acad::eInvalidIndex. Any other error return values are up to the
implementor. |
||||||||||
|
AcDbEntity::subSetDatabaseDefaults
函数 virtual void subSetDatabaseDefaults( AcDbDatabase* pDb);
函数 usage This 函数 is not
intended to be called by ObjectARX applications. It is designed to be called
by the AcDbEntity::setDatabaseDefaults() method in order to provide a
"hook" into the setDatabaseDefaults process. 函数 implementation in
derived classes This 函数 is called
from within setDatabaseDefaults() after the property values have been set within
the entity. As such, it provides a hook into the setDatabaseDefaults
operation at a time when you can see what the new values are, change them if
desired, and make other changes as well. The entity is open for
write, and there are no restrictions on what you can do within this 函数 other than
those normally imposed on any object open for write. Default implementation Immediately return
without performing any action. |
||||||||||
|
AcDbEntity::transformBy
函数 virtual
Acad::ErrorStatus transformBy( const AcGeMatrix3d&
xform);
函数 usage This 函数 provides a
means by which AutoCAD and ObjectARX applications can ask the entity to apply
a transformation matrix (xform) to itself. Each entity class must
implement this 函数, so restrictions on what types of
transformations are supported are up to the implementor of the entity class.
The AutoCAD built-in entity classes for entity types that existed before R13
(that is, all the classes listed in the header file dbents.h such as AcDbCircle, AcDbLine, AcDbArc, AcDb2dPolyline, etc.) require that the
transformation matrix represent a uniformly scaling orthogonal transformation
(if it is not, then Acad::eCannotScaleNonUniformly will be returned). Other
AutoCAD built-in classes have no restrictions. Returns Acad::eOk if
successful. Return values for errors are implementation-dependent. 函数 implementation in
derived classes This 函数 must apply
the transformation matrix xform to the entity and change the entity's state
to reflect the transformation. It is completely up to the implementor as to
how to apply the transformation. It is also up to the implementor to decide
what, if any, restrictions will be placed on the type of transformations
supported. If any restrictions are desired, then it's up to the
implementation of this 函数 to enforce them. If your derived class
implements transformBy() without calling the base class, you must call AcDbObject:: xDataTransformBy() or your
Xdata will not be transformed. If this 函数
successfully transforms the entity, then it should return Acad::eOk. Return values for
error conditions are completely up to the implementor of this 函数. However,
if the error is caused by a non-uniformly scaling or non-orthogonal matrix,
then to be consistent with other entities that have this restriction, it is
recommended that Acad::eCannotScaleNonUniformly be returned. Note If this method is
not overridden, then AutoCAD commands such as MOVE, ROTATE, SCALE, etc. will
have no effect on entities of this class. Default implementation Calls assertWriteEnabled(Adesk::kFalse,
Adesk::kFalse) and then returns Acad::eNotApplicable. |
|
|
AcDbEntity::cloneMeForDragging
函数 virtual Adesk::Boolean cloneMeForDragging(); This 函数 indicates
to AutoCAD whether a clone should be created for use in a dragging operation.
AutoCAD has always created a clone in the past, but due to entities with
large amounts of data (for example, polylines) it is sometimes desirable to
have AutoCAD perform dragging with the original entity. Default
implementation: Returns Adesk::kTrue indicating that a clone will be created
for the dragging operation. |
||||||||||
|
|
AcDbEntity::draw 函数 Acad::ErrorStatus draw(); This 函数 queues up
the entity's graphics and flushes the graphics queue, forcing the entity and
anything else in the queue to be drawn or re-drawn on-screen. Returns Acad::eOk if
successful. If the entity is not
in a database, then Acad::eNotInDatabase will be returned. If the entity is in a
database other than the one currently loaded into the AutoCAD editor, then
Acad::eNotCurrentDatabase will be returned. |
||||||||||
|
|
AcDbEntity::highlight 函数 virtual
Acad::ErrorStatus highlight( const AcDbFullSubentPath&
subId = kNullSubent, const Adesk::Boolean
highlightAll = false) const;
函数 usage This 函数 uses the AcDbFullSubentPath
id to determine which subentity in the entity is desired. It then highlights
that subentity on screen. If no AcDbFullSubentPath argument is provided, then
the entire entity will be highlighted. Typically, the
AcDbFullSubentPath object passed in via subId is obtained from the entity's AcDbEntity::getSubentPathsAtGsMarker()
method. This guarantees that it is fully and properly filled in. This 函数 uses the
entity's getGsMarkersAtSubentPath() method to get the GS markers associated
with subId. If that 函数 does not return Acad::eOk, then this 函数 will fail
and return whatever ErrorStatus was returned by getGsMarkersAtSubentPath(). If this 函数 succeeds,
then it returns Acad::eOk. The highlight and
unhighlight methods must be called in pairs. If highlight is called for this
entity, a call to unhighlight for this entity must follow. If an
AcDbFullSubentPath objectID is provided for highlight, that same
AcDbFullSubentPath object is required for unhighlight. Warning If the entity
on which this method is called has its graphics queued for regeneration (that
is, changes have been made to the entity but have not yet been reflected on
screen), then this method will not cause a highlight to occur. Also, calling
this method on an entity that's open for write and whose graphics are queued
for regeneration may terminate AutoCAD. To avoid this
limitation, before calling highlight(), you should flush the entity's
graphics by either calling the entity's draw() method, or calling the AcTransactionManager::flushGraphics() 函数. 函数 implementation in
derived classes The
AcDbEntity::highlight() implementation does all the work necessary to
highlight any subentities that correspond to the subId FullSubentPath. So,
there is no need to override this method unless you wish to do some pre-or
post-processing, or you wish to disable the ability to highlight subentities. If this method is
overridden and it is supposed to highlight subentities, then the
AcDbEntity::highlight() method will need to be invoked at some point within
this 函数 in order to do the actual highlighting. Within the
AcDbEntity::highlight() method, the getGsMarkersAtSubentPath() method of this
entity is called to translate the FullSubentPath into the corresponding GS markers.
So, if this 函数 is to succeed, the getGsMarkersAtSubentPath()
method needs to be implemented as well. For more information
on the subId AcDbFullSubentPath argument, see the documentation on the AcDbEntity::getGsMarkersAtSubentPath() or
AcDbEntity::getSubentPathsAtGsMarker()
methods.
|
||||||||||
|
|
AcDbEntity::recordGraphicsModified
函数 void recordGraphicsModified( Adesk::Boolean
autoUndo = true);
This method sets the entity's
state to indicate whether or not the entity should be updated on screen when
it is closed. If the entity is set not to update, then any changes made will
appear the next time the entity is regenerated. If setModified ==
Adesk::kFalse and the entity is currently set to update its graphics on close
(which is its default state), then this 函数 sets the entity so
that it will not update on screen when it is closed and objectModified
notification is sent to all entity type reactors attached to the entity. If
setModified == Adesk::kFalse and the entity is already set not to update its
graphics on close, then this 函数 simply returns. If setModified ==
Adesk::kTrue, then the entity is set to update on screen when it is closed. |
||||||||||
|
|
AcDbEntity::saveAs 函数 virtual void saveAs( AcGiWorldDraw* mode, AcDb::SaveType st);
函数 usage This 函数 is used by
AutoCAD to generate the graphic primitives whenever the SAVEASR12 command is
executed in AutoCAD or a DWG save is occurring that requires proxy graphics
to be saved for the entity. Overriding this 函数 allows control of the
graphics that will be stored in these two cases. It is possible for an
ObjectARX application to call this 函数, but it will need to
provide a fully functional AcGiWorldDraw object and the AcGiWorldGeometry and AcGiSubEntityTraits objects for which it
provides references. The only way to do this is to derive custom classes from
these three AcGi classes. The acgisamp.cpp sample program supplied with the
ObjectARX SDK demonstrates how to do this. 函数 implementation in
derived classes The AcGiWorldDraw
object pointed at by pMode, as well as the AcGiWorldGeometry and
AcGiSubEntityTraits objects available from the AcGiWorldDraw object, are all
provided to allow this 函数 to generate whatever
graphics primitives are desired to represent the entity in an R12 drawing
file, or when the entity is a proxy and needs to be displayed. Chapter 10 in
the ObjectARX Developer's Guide explains how to use these classes. In the contexts that
this 函数 is called, there is no need to deal with GS marker assignments.
However, all the visible properties such as colors, layer, linetypes,
visibilities, etc. are relevant. The st argument
provides the context for the call of this 函数. The possible values
are:
When the context is
kR12Save, the graphics primitives generated by this 函数 will be
converted into R12 entities and saved to the R12 drawing file. When the context is kR13Save,
the graphics primitives generated by this 函数 will be stored with
the entity in the R13 drawing file so that if the drawing is ever loaded up
with the entity's controlling application not loaded (that is, the entity
becomes a proxy), the entity can still be displayed. Default implementation By default, this
method calls the entity's worldDraw() method using the mode pointer. |
||||||||||
|
|
AcDbEntity::unhighlight
函数 virtual
Acad::ErrorStatus unhighlight( const
AcDbFullSubentPath& subId = kNullSubent, const Adesk::Boolean
highlightAll = false) const;
函数 usage This 函数 uses the AcDbFullSubentPath
id to determine which subentity in the entity is desired. It then
unhighlights that subentity on screen. If no AcDbFullSubentPath argument is
provided, then the entire entity will be unhighlighted. Typically the
AcDbFullSubentPath object passed in via subId will be obtained from the
entity's AcDbEntity::getSubentPathsAtGsMarker()
method. This guarantees that it is fully and properly filled in. This 函数 uses the
entity's getGsMarkersAtSubentPath() method to get the GS markers associated
with subId. If that 函数 does not return Acad::eOk, then this 函数 will fail
and return whatever ErrorStatus was returned by getGsMarkersAtSubentPath(). If this 函数 succeeds,
then it will return Acad::eOk. The highlight and
unhighlight methods must be called in pairs. If highlight is called for this
entity, a call to unhighlight for this entity must follow. If an AcDbFullSubentPath
objectID is provided for highlight, that same AcDbFullSubentPath object is
required for unhighlight. 函数 implementation in
derived classes The
AcDbEntity::unhighlight() implementation does all the work necessary to
unhighlight any subentities that correspond to the subId FullSubentPath. So,
there is no need to override this method unless you wish to do some pre-or
post processing, or you wish to disable the ability to unhighlight
subentities. If this method is
overridden and it is supposed to unhighlight subentities, then the
AcDbEntity::unhighlight() method needs to be invoked at some point within
this 函数 in order to do the actual unhighlighting. Within the
AcDbEntity::unhighlight() method, the getGsMarkersAtSubentPath() method of
this entity is called to translate the FullSubentPath into the corresponding
GS markers. So, if this 函数 is to succeed, the
getGsMarkersAtSubentPath() method needs to be implemented as well. For more information
on the subId AcDbFullSubentPath argument, see the documentation on the AcDbEntity::getGsMarkersAtSubentPath() or
AcDbEntity::getSubentPathsAtGsMarker()
methods. |
||||||||||
|
|
AcDbEntity::viewportDraw
函数 virtual void viewportDraw( AcGiViewportDraw*
mode);
函数 usage Whenever a
regeneration of the entity's graphics is required, AutoCAD calls the entity's
worldDraw() method. If worldDraw() returns Adesk::kFalse, then AutoCAD calls
this 函数 once for each viewport that is currently active in the AutoCAD editor.
This 函数 then generates 3D graphic primitives independently for each viewport. It is possible for
ObjectARX applications to call this 函数, but they will need
to provide a fully functional AcGiViewportDraw object and the
AcGiViewportGeometry, AcGiViewport and AcGiSubentityTraits objects for which
it provides references. The only way to do this is to derive custom classes
from these four AcGi classes. 函数 implementation in
derived classes The AcGiViewportDraw object pointed to by
pMode as well as the AcGiViewportDraw, AcGiViewport, and AcGiSubentityTraits objects available
from the AcGiViewportDraw object are all provided to allow this 函数 to
generate whatever graphics primitives are desired to represent the entity in
a viewport dependent manner. Since this 函数 will be
called once for each viewport that is currently active within AutoCAD, it's
possible to generate completely different images in each viewport (for
example, a schematic image in one, a mesh image another. In addition, the
AcGiViewport object provides detailed information about the viewport being
drawn to for each call, so it's possible to draw the same basic image, but
adjusted to accommodate the view in each viewport (for example, draw
different tesselation lines depending on the view). See Chapter 10 in the
ObjectARX Developer's Guide for more information. Default implementation Immediately returns
without performing any action. |
||||||||||
|
|
AcDbEntity::worldDraw 函数 virtual Adesk::Boolean worldDraw( AcGiWorldDraw* mode);
函数 usage Whenever a regeneration
of the entity's graphics is required, AutoCAD calls this 函数 to
generate the graphics primitives that will represent this entity on screen.
This 函数 will then provide a generic set of 3D graphics primitives that AutoCAD
will adjust for each viewport's parameters as they are displayed. If this 函数 returns
Adesk::kFalse, then AutoCAD calls the AcGiViewportDraw() 函数 once for
each viewport that is currently active in the AutoCAD editor. It is possible for an
ObjectARX application to call this 函数 (for example, in
order to get the face information for an AcDb3dSolid entity), but it will need to
provide a fully functional AcGiViewportDraw object and the AcGiWorldGeometry,
and AcGiSubentityTraits objects for which it provides references. The only
way to do this is to derive custom classes from these three AcGi classes. The
acgisamp.cpp sample program supplied with the ObjectARX SDK demonstrates how
to do this. 函数 implementation in
derived classes The AcGiWorldDraw object pointed to by pMode
as well as the AcGiWorldGeometry and AcGiSubentityTraits objects available
from the AcGiWorldDraw object are all provided to allow this 函数 to
generate whatever graphics primitives are desired to represent the entity in
a viewport independent manner (that is, one 3D image is used for all
viewports and is adjusted by AutoCAD for all the different parameters in the
different viewports). Chapter 10 in the ObjectARX Developer's Guide explains how
to use these classes. If this 函数 generates
the graphics image to be used for display, then it should return
Adesk::kTrue. If the entity intends
to do viewport dependent graphics primitives, then this 函数 should
simply return Adesk::kFalse. This will cause AutoCAD to call the entity's
viewportDraw() method once for each viewport that's currently active. If this method is not
overridden in classes derived from AcDbEntity, then entities of such classes
will not display on screen. Default implementation Immediately returns
Adesk::kTrue. |
AcDbEntity
Intersection Functions
|
|
AcDbEntity::boundingBoxIntersectWith
函数 Acad::ErrorStatus boundingBoxIntersectWith( const AcDbEntity*
pEnt, AcDb::Intersect
intType, const AcGePlane&
projPlane, AcGePoint3dArray&
points, int thisGsMarker, int otherGsMarker)
const;
This version of the 函数 is the
same as the one above except that it projects the bounding box edges of this
entity and the pEnt entity onto the projPlane, finds the intersection points,
and then projects the intersection points back onto the appropriate bounding
box edge of this entity. So, all points appended to the points array will be
on the bounding box edges of this entity. The projections are done parallel
to the projPlane's normal vector. The possible
AcDb::Intersect values for intType are:
Returns Acad::eOk if successful.
ErrorStatus return values for error conditions depend upon how the entity
pointed to by pEnt has implemented its projection plane intersectWith()
method. Acad::ErrorStatus boundingBoxIntersectWith( const AcDbEntity*
pEnt, AcDb::Intersect intType, AcGePoint3dArray&
points, int thisGsMarker, int otherGsMarker)
const;
This method first
calculates the bounding box for this entity (in WCS coordinates) by calling the
entity's getGeomExtents() method (so if this method has not been overridden
with a valid implementation, then the return status of Acad::eInvalidExtents
will be returned by this 函数). It then finds the
intersections of the entity pointed to by pEnt and all the edges of the
bounding box of this entity. The intType is used to
determine how to deal with extending the boundary edges or the pEnt entity in
order to calculate intersections. The possible AcDb::Intersect values are:
Any intersection
points found are appended to the points array. All points are in WCS
coordinates. Note In the process of
determining the intersections of the pEnt entity with the bounding box edges
of this entity, the non-projection plane version of pEnt's intersectWith()
method may be called (if the pEnt entity is a custom entity, then the
intersectWith() method will definitely be called). If the intersectWith()
method has not been implemented for the pEnt entity's class, then this 函数 fails if
that method is called. The thisGsMarker and
otherGsMarker arguments are only used if the pEnt entity's intersectWith()
method is called, and even then they are just passed on into that method
where they may still not be used. Returns Acad::eOk if
successful. ErrorStatus return values for error conditions depend upon how
the entity pointed to by pEnt has implemented its non-projection plane
intersectWith() method. |
||||||||||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::intersectWith
函数 virtual
Acad::ErrorStatus intersectWith( const AcDbEntity*
pEnt, AcDb::Intersect
intType, AcGePoint3dArray&
points, int thisGsMarker = 0, int otherGsMarker = 0)
const;
函数 usage It finds the
intersections of the entity pointed to by pEnt and all the edges of the
bounding box of this entity. The intType is used to
determine how to deal with extending the two entities in order to calculate
intersections. The possible AcDb::Intersect values are:
Any intersection
points found are appended to the points array. All points are in WCS
coordinates. The thisGsMarker and
otherGsMarker arguments are intended to provide this 函数 with information
to allow it to localize the search for intersections to be between specific
subentities. However, this 函数 is not required to
make use of either of these arguments (most, if not all, of the AutoCAD built-in
entity classes do not). When calling this 函数, either or both of
these arguments may be 0 in order to indicate that they should be ignored. If this 函数 is
successful it returns Acad::eOk. Return values for error conditions are
dependent on the implementation of this 函数 in the classes
involved. 函数 implementation in
derived classes This 函数 should do
all it can to find all intersection points between the entity it's being
called on and the entity pointed to by pEnt. All intersection points found
should be appended to the points array. All such points must be in WCS
coordinates. When implementing the
intersection calculation portion of this 函数 you should take a
good look at the AcGe classes to see if they can provide any useful
functionality to help in finding intersections with the geometric primitives
that make up the entity this 函数 is being called on
and the pEnt entity. For example, the AcGeCurve3d class has an isOn() method
that will indicate if a supplied point is on the curve and the AcGeArc3d
class has several intersectWith() methods to find intersections with other
AcGe types. If the pEnt entity is
a type not recognized by this 函数, it is quite
reasonable to call the pEnt entity's intersectWith() method passing in a
pointer to this entity as the "pEnt", and all the other arguments
passed into this 函数 (remembering to convert the intType argument If
necessary) to see if that entity can determine any intersection points. This
is what the AutoCAD built-in classes do. Also, don't forget to
take into account the intType value. The intType tells you which, if any, of
the two entities should be extended to find "apparent"
intersections. It is not required that apparent intersection be supported,
but if it is not, then an appropriate ErrorStatus value should be returned to
indicate that the call failed. The thisGsMarker and
otherGsMarker arguments are provided to allow this 函数 to
determine exactly which subentities are involved in the intersection
operation (for example, if this 函数 is being called by
AutoCAD as part of an intersection Osnap operation these arguments would
indicate which subentities are within the osnap pickbox). For these
arguments, a value less than or equal to zero indicates that that argument
should not be used. If this 函数 completes
successfully (even if no intersection points are found), it should return
Acad::eOk. Determining what is considered an error and what ErrorStatus
return code to use for any such errors are up to the implementor -- there are
no conventions in this regard. Default implementation:
Immediately returns Acad::eNotImplemented. virtual
Acad::ErrorStatus intersectWith( const AcDbEntity*
pEnt, AcDb::Intersect
intType, const AcGePlane&
projPlane, AcGePoint3dArray&
points, int thisGsMarker = 0, int otherGsMarker = 0)
const;
Same as the other
version of this 函数 except that it projects this entity
and the pEnt entity onto the projPlane, finds the intersection points, and
then projects the intersection points back onto this entity. So, all points
appended to the points array will be on this entity. The projections are done
parallel to the projPlane's normal vector. When implementing the
intersection calculation portion of this 函数, in addition to the
intersection functionality mentioned in the documentation on the other
version of this 函数, the AcGe classes have functionality available
to aid in the projection onto a plane and the projection of points onto AcGe
objects. |
AcDbEntity
Miscellaneous Functions
|
|
AcDbEntity::applyPartialUndo
函数 virtual
Acad::ErrorStatus applyPartialUndo( AcDbDwgFiler*
undoFiler, AcRxClass* classObj);
未说明 |
||||
|
|
AcDbEntity::audit 函数 virtual
Acad::ErrorStatus audit( AcDbAuditInfo*
pAuditInfo);
未说明 |
||||
|
|
AcDbEntity::drawable 函数 virtual AcGiDrawable * drawable(); 未说明 |
||||
|
|
AcDbEntity::dwgInFields
函数 virtual
Acad::ErrorStatus dwgInFields( AcDbDwgFiler* pFiler);
未说明 |
||||
|
|
AcDbEntity::dxfOutFields
函数 virtual
Acad::ErrorStatus dxfOutFields( AcDbDxfFiler* pFiler)
const;
未说明 |
||||
|
|
AcDbEntity::dxfInFields
函数 virtual
Acad::ErrorStatus dxfInFields( AcDbDxfFiler* pFiler);
未说明 |
||||
|
|
AcDbEntity::dxfOutFields
函数 virtual
Acad::ErrorStatus dxfOutFields( AcDbDxfFiler* pFiler)
const;
未说明 |
||||
|
|
AcDbEntity::getClassID
函数 virtual
Acad::ErrorStatus getClassID( CLSID* pClsid) const;
未说明 |
||||
|
|
AcDbEntity::getPlotStyleNameId
函数 AcDb::PlotStyleNameType getPlotStyleNameId( AcDbObjectId& id)
const;
未说明 |
||||
|
|
AcDbEntity::gsNode 函数 virtual AcGsNode * gsNode() const; 未说明 |
||||
|
|
AcDbEntity::setAttributes
函数 virtual Adesk::UInt32 setAttributes( AcGiDrawableTraits*
pTraits);
未说明 |
||||
|
|
AcDbEntity::setGsNode 函数 virtual void setGsNode( AcGsNode* pNode);
未说明 |
|
|
AcDbEntity::blockId 函数 AcDbObjectId blockId() const; This 函数 returns
the AcDbObjectId of the entity's owner, which
must be an AcDbBlockTableRecord. If the entity does not
have an owner yet, then AcDbObjectId::kNull will be returned. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::color 函数 AcCmColor color() const; This 函数 returns
the AutoCAD color number of the entity within an instance of AcCmColor. The index value will
be in the range 0 to 256. 0 and 256 are special values. 0 indicates the entity
uses the color of the BlockReference that's displaying it. If the entity is
not displayed through a BlockReference (for example, it's directly owned by
the model space BlockTableRecord) and its color is 0, then it will display as
though its color were 7. 256 indicates the
entity uses the color specified in the LayerTableRecord it references. Note The AcDbEntity::colorIndex() method is a more
direct method to access the AutoCAD color number of the entity. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::colorIndex
函数 Adesk::UInt16 colorIndex() const; This 函数 returns
the AutoCAD color number of the entity. The index value will
be in the range 0 to 256. 0 and 256 are special values. 0 indicates the entity
uses the color of the BlockReference that's displaying it. If the entity is
not displayed through a BlockReference (for example, it's directly owned by the
model space BlockTableRecord) and its color is 0, then it will display as
though its color were 7. 256 indicates the
entity uses the color specified in the LayerTableRecord it references. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getCompoundObjectTransform
函数 virtual Acad::ErrorStatus getCompoundObjectTransform( AcGeMatrix3d &
xMat) const;
This 函数 is
intended to be overridden by derived classes that are compound objects (in other
words, objects that behave like blocks in the display list). A compound object has
little or no geometry of its own; instead it relies on nested entities,
perhaps the contents of a BlockTableRecord, to represent itself. A compound
object must use the same transformation matrix for all of its contained
entities. Otherwise selection and osnap will not 函数 correctly.
This is the method that the system uses to obtain that matrix from the
compound object. This method should
only be overridden if you return the kDrawableIsCompoundObject flag from
setAttributes. The matrix you should return here is the one that you pass to
pushModelTransform before you render your nested objects. You must override
this method if you return the compound object flag in setAttributes, even if
you don't push a transform for your nested objects. In that case you would
return Acad::eOk and the identity transform in xMat. Default
implementation: Returns Acad::eNotApplicable and the identity matrix in xMat. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getEcs 函数 virtual void getEcs( AcGeMatrix3d&
retVal) const;
This 函数 is
intended to be overridden by derived classes that need to be able to provide access
to an object coordinate system for objects of the class. The intent is that
this 函数 provide a transformation matrix that can be used to transform vectors
or points from the object's object coordinate system (OCS) to the World
Coordinate System (WCS). Default
implementation: Return the identity matrix (ones along the diagonal, zeros
elsewhere) in retVal. We recommend that all
data stored in custom classes be stored in WCS coordinates. If this is done,
then the object's OCS will be the WCS and the transformation matrix will be
the identity matrix. Then this 函数 will not need to be
overridden since the identity matrix is this 函数's default return. Note Even the pre-R13
entity types that store their data in OCS format (that is, circle, polyline,
inserts, etc.) return the identity matrix. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getGeomExtents
函数 virtual
Acad::ErrorStatus getGeomExtents( AcDbExtents&
extents) const;
Unimplemented at the AcDbEntity
level, this method is intended to be overridden in derived classes. Derived classes should
calculate and return the corner points (in WCS coordinates) of a box (with
edges parallel to the WCS X, Y, and Z axes) that encloses the 3D extents of
the entity, and return those points as an instance of class AcDbExtents in the "extents"
parameter. Default implementation:
Immediately returns Acad::eInvalidExtents. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getGripPoints
函数 virtual
Acad::ErrorStatus getGripPoints( AcGePoint3dArray&
gripPoints, AcDbIntArray&
osnapModes, AcDbIntArray&
geomIds) const;
函数 usage This 函数 is not
intended to be called by ObjectARX applications. However, it is possible to do
so (for example, as a pass-through from the getStretchPoints() method). 函数 implementation in
derived classes This 函数 should
append to the gripPoints array any points that are to treated as grip points
for the entity. The gripPoints array
is passed to all entities involved in the grip operation, so the array may
already contain grip points for other entities. Therefore, it is very
important to append the new points rather than assigning them to any existing
elements in the array. When finished
appending all desired grip points, return Acad::eOk. If anything other than
Acad::eOk is returned, then grips are not activated for this entity. The osnapModes and
geomIds arguments are not currently used. Default implementation Immediately returns
Adesk::eNotImplemented. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getGsMarkersAtSubentPath
函数 virtual
Acad::ErrorStatus getGsMarkersAtSubentPath( const
AcDbFullSubentPath& subPath, AcDbIntArray&
gsMarkers) const;
Entities use various graphic
primitives defined in AcGi to draw themselves. Part of this mechanism is the
ability to associate an integer identifier called a graphics system marker
(or, GS marker) with each primitive or with groups of primitives. Through the
use of certain selection mechanisms the GS marker for the actual subentity
selected on screen can be obtained and used with this 函数 and
several other functions for various purposes such as highlighting or
unhighlighting the subentity on screen. 函数 usage This 函数 uses the AcDbSubentId object within the subPath
object to determine which GS markers within the entity are appropriate. Any GS
markers that match are appended to the gsMarkers array. The subPath object's
object ID array is not used, so it does not need to be filled in. The subentId object
within subPath does needs to be fully filled in with the desired SubentType and
a valid index value (which may or may not actually be the GS marker). Typically, this 函数 will be
called with an AcDbFullSubentPath object that was filled in by the entity's AcDbEntity::getSubentPathsAtGsMarker()
method. Return values for this
函数 may vary depending on how the 函数 is implemented (see
below). 函数 implementation in
derived classes This 函数 must be
able to properly interpret the SubentType and index values in the
AcDbSubentId object within subPath in order to determine the GS markers for
the corresponding subentity (or subentities). The GS markers thus determined
are then appended to the gsMarkers array. The index values in
AcDbSubentId objects can be any values you want (they are often simply the GS
markers themselves), but if implemented, the getSubentPathsAtGsMarker()
method must be able to calculate them based on a provided GS marker and, if implemented,
the subentPtr() method must be able to interpret them to determine the
corresponding subentity (or subentities): Which return codes to
use are completely up to the implementor, but to be consistent with other
existing entity class implementations of this 函数, the following should
be used: ·
If the 函数 succeeds, it should
return Acad::eOk. ·
If an invalid or unsupported SubentType is
passed in, then Acad::eWrongSubentityType should be returned. ·
If an invalid index is passed in, then
Acad::eInvalidIndex should be returned. Default implementation Immediately returns
Adesk::eNotApplicable. Note The AcDbEntity::highlight() and AcDbEntity::unhighlight() methods both
call this 函数 to obtain the GS marker(s) associated with a
FullSubentPath. So, if this 函数 is not overridden,
then they will not work. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getOsnapPoints
函数 virtual
Acad::ErrorStatus getOsnapPoints( AcDb::OsnapMode
osnapMode, int gsSelectionMark, const AcGePoint3d&
pickPoint, const AcGePoint3d&
lastPoint, const
AcGeMatrix3d& viewXform, AcGePoint3dArray&
snapPoints, AcDbIntArray&
geomIds) const;
This 函数 must use
the material provided in osnapMode, gsSelectionMark, pickPoint, lastPoint, and
viewXform to determine all appropriate osnap points for the entity. It must
then append all such osnap points to the snapPoints array. The snapPoints array
is passed to all entities involved in the osnap operation, so it's possible
that the array will already have entries in it when passed in. For this
reason, it's very important that points be appended to the snapPoints array
instead of assigning to any existing elements. The osnapMode argument
indicates which osnap mode is involved in the operation. Not all modes are
applicable to all entity types (for example, AcDb::kOsModeIns is not
applicable to a line). The possible values for this argument are:
The gsSelectionMark
argument contains the GS marker of the subentity that's involved in the osnap
operation. If the entity hasn't set any GS markers, then this is the default
GS marker value of 0. The GS marker is provided to allow narrowing down the
osnap point(s) search parameter if desired. The pickPoint argument
provides the point (in WCS coordinates) that started this osnap operation. The lastPoint argument
provides the point picked just prior to the pickPoint point. This point is
used when determining perpendicular and tangent osnap values. The viewXform argument
provides a transformation matrix to transform from WCS (World Coordinate
System) to DCS (display coordinate system). The display coordinate
system is oriented such that the positive Z axis is coming out of the display
screen towards the user, the positive X axis is horizontally from left to
right on screen, and the positive Y axis is vertically upward on screen. So, if the current
viewpoint is at (1,0,0) (the viewer is always looking towards (0,0,0)) then
the viewXform matrix would be: 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 In this matrix the last
row and the last column are not used. Notice also that the third row is the
DCS Z axis in WCS coordinates (which is the WCS version of the AutoCAD
VIEWPOINT system variable). This transformation
matrix is provided to allow you to determine positions of various points in
the current view. This is most useful for the AcDb::kOsModeNear mode where
"nearest" may depend on the viewpoint. The snapPoints
argument is the array to append the resulting osnap points to. You may append
zero or more points to the array. This same array is
passed to all entities involved in the osnap operation. When all entities
have been queried, AutoCAD determines which point in the array is most
appropriate for the desired osnap mode. So, this 函数 does not
need to narrow the search down to one point. AutoCAD does not care
what the return status is from this 函数 (there's no reason
for it to), but to be meaningful to anything else that might wish to call it,
we recommend that Acad::eOk be returned for any snap modes that are supported
whether they append any points or not. Note This 函数 does not
work for dimensions, in which case it returns eNotApplicable. To obtain osnap
data for dimensions, use AcDbDimension::getOsnapPoints(). |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getPlane 函数 inline virtual
Acad::ErrorStatus getPlane( AcGePlane&
unnamed, AcDb::Planarity&
unnamed) const;
If the entity is
planar, then the plane containing the entity is returned in plane and flag is
set to AcDb::kPlanar. If the entity is
nonplanar, but is linear, then plane is set to an arbitrary plane that
contains the entity and flag is set to AcDb::kLinear. If the entity is
nonplanar and nonlinear, then plane is left unset and flag is set to AcDb::kNonPlanar. Returns Acad::eOk if
successful. Other ErrorStatus return values are implementation-dependent. The default
implementation is to return Acad::eNotApplicable. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getStretchPoints
函数 virtual
Acad::ErrorStatus getStretchPoints( AcGePoint3dArray&
stretchPoints) const;
函数 usage This 函数 is not intended
to be called by ObjectARX applications. However, it is possible to do so (for
example, as a pass-through from the getGripPoints() method). 函数 implementation in
derived classes This 函数 should
append to the stretchPoints array any points that are to treated as stretch
points for the entity. Stretch points are
used by the stretch command within AutoCAD. Any stretch points that are
within the crossing selection window during the stretch command, will be
moved by whatever amount the user decides to "stretch" the selected
entities. Any stretch points not in the crossing selection window will be
left alone. This combination of some stretch points moving while others do
not is what "stretches" the entity. If all stretch points are in
the crossing window, then the entity is moved instead of stretched. The stretchPoints
array is passed to all entities involved in the stretch operation, so the
array may already contain stretch points for other entities. Therefore it is
very important to append the new points rather than assigning them to any
existing elements in the array. When finished
appending all desired stretch points, return Acad::eOk. If anything other
than Acad::eOk is returned, then this entity's stretch points will be ignored
by the stretch operation. Default implementation Calls the AcDbEntity::getGripPoints() method. So,
unless the entity needs to have stretch points that are different from the
grip points, there is no need to override this method. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getSubentPathsAtGsMarker
函数 virtual
Acad::ErrorStatus getSubentPathsAtGsMarker( AcDb::SubentType type, int gsMark, const AcGePoint3d&
pickPoint, const
AcGeMatrix3d& viewXform, int& numPaths, AcDbFullSubentPath*&
subentPaths, int numInserts = 0, AcDbObjectId*
entAndInsertStack = NULL) const;
Entities use various
graphic primitives defined in AcGi to draw themselves. Part of this mechanism
is the ability to associate an integer identifier called a graphics system
marker (or, GS marker) with each primitive or with groups of primitives.
Through the use of certain selection mechanisms, the GS marker for the actual
subentity selected on screen can be obtained and, along with some other
information passed into this 函数, can be used to
create one or more AcDbFullSubentPath objects, each one representing a
subentity and providing a more complete description of the subentity and its
environment. These AcDbFullSubentPath objects can be used by several other
functions for various purposes such as highlighting or unhighlighting the
subentities on screen. 函数 usage If the entity (of
which the subentity is a part) is directly owned by the model or paper space
BlockTableRecords, then leave out numInserts and entAndInsertStack so that
their default value will be used. Typically the GS
marker is obtained via the use of ads_ssget() followed by ads_ssnamex() (see
the ObjectARX Developer's Guide for more information on this). The pickPoint can be
obtained from ads_ssnamex() as well (it's the first group 5009 in the
returned list). The viewXform can be
calculated using the ads_trans() 函数 on the vectors
(1,0,0), (0,1,0), and (0,0,1) to translate them from DCS to WCS. The
translations of these three vectors (with an extra 0 appended on to the end
of each) would be used as the first three rows of the matrix. The last row is
not used so it can be left as is. This argument is not used by any of the
AutoCAD built-in entities. If the entity is
nested inside one or more block definitions, then the numInserts and
entAndInsertStack arguments must also be filled in with non-zero or non-null
values. If they are not filled in, then this 函数 will fail and return
an error status. One way to get the necessary object IDs is to use
ads_nentselp() to obtain the list of ads_names of the container objects. This
list must then be converted to object IDs and reversed. Upon return, the
subentPaths argument will point to a dynamically allocated array of one or
more AcDbFullSubentPath objects. The numPaths argument will contain the
number of AcDbFullSubentPath objects being returned. The calling application
is responsible for deallocating the memory used by the subentPaths array. The
C++ delete [ ] operator should be used. Return values for this
函数 may vary depending on how the 函数 has been implemented
(see below). 函数 implementation in
derived classes Entity classes which
do not set GS markers probably should not implement this 函数 since the
GS marker is the primary (and often the only) means of subentity distinction. When implemented, this
函数 must use the material provided in type, gsMark, pickPoint,
viewXform, numInserts, and entAndInsertStack to determine which subentity or
subentities meet the criteria in these arguments. Next it must create a
dynamically allocated array of AcDbFullSubentPaths (using the C++ new
operator) with one element for each subentity determined in the first step.
Finally it must fill in each AcDbFullSubentPath object in the array with the
information appropriate to the subentity it will represent. If numInserts == 0 and
entAndInsertStack == NULL, it's important to check to be sure that the
entity's owner is indeed the model or paper space BlockTableRecord. This can
be done by using the entity's ownerId() method to obtain the objectId of its
owner, and then opening up that object and using its name() method to obtain
its name string. If the owner is not the model or paper space
BlockTableRecord, and numInserts == 0 or entAndInsertStack == NULL, or both,
then the input data is invalid and this 函数 should set numPaths
to 0, set subentPaths to NULL and then return the error status
Acad::eInvalidInput. Each
AcDbFullSubentPath object has two parts, an array of objectIds containing all
the container objects, and an embedded AcDbSubentId object which in turn has
two elements: an index value and a SubentityType. If the
"main" entity (the entity on which this 函数 is being
called) is not nested within BlockReferences (that is, numInserts == 0 and
entAndInsertStack == NULL), then the objectId array should contain only the objectId
of the "main" entity. If the "main" entity is nested in
one or more BlockReferences, then the AcDbObjectIdArray is the same as
entAndInsertStack, so copying the entAndInsertStack elements into the
AcDbObjectIdArray is all that's required. The SubentType data
item within the embedded AcDbSubentId should be set the same as type. The index data item
within the embedded AcDbSubentId can be any value you wish (it is often
simply the GS marker), but if implemented, the following functions must be
able to interpret them to determine the corresponding GS marker(s) or
subentity (or subentities): getGsMarkersAtSubentPath() subentPtr() The pickPoint and
viewXform arguments are provided as extra aids (if necessary) in determining
which subentity is involved. For example, some entity types might display
differently depending on the display viewpoint. The viewXform transformation
matrix can be used in such cases. The viewXform argument
provides a transformation matrix to transform from WCS (World Coordinate
System) to DCS (display coordinate system). The display coordinate
system is oriented such that the positive Z axis is coming out of the display
screen towards the user, the positive X axis is horizontally from left to
right on screen, and the positive Y axis is vertically upwards on screen. So, if the current
viewpoint is at (1,0,0) (the viewer is always looking towards (0,0,0)) then
the viewXform matrix would be: 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 In this matrix the
last row and the last column are not used. Notice also that the third row is
the DCS Z axis in WCS coordinates (which is the WCS version of the AutoCAD
VIEWPOINT system variable). When this 函数 returns,
the return code to use is completely up to the implementor, but to be
consistent with other existing entity class implementations of this 函数 the
following should be used: ·
If the 函数 succeeds, it should
return Acad::eOk. ·
If an invalid or unsupported SubentType is
passed in, then numPaths should be set to 0, subentPaths should be set to
NULL, and Acad::eWrongSubentityType should be returned. ·
If an invalid GS marker (or any other data item
that turns out to be needed) is passed in, then numPaths should be set to 0,
subentPaths should be set to NULL, and Acad::eInvalidInput should be
returned. Default implementation Immediately returns
Adesk::eNotApplicable. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::getTransformedCopy
函数 virtual
Acad::ErrorStatus getTransformedCopy( const
AcGeMatrix3d& xform, AcDbEntity*& pEnt)
const;
函数 usage This 函数 creates a
clone of the entity, applies the xform transformation matrix to the clone, and
then returns with pEnt pointing to the transformed clone. Warning For AutoCAD
built-in complex entities such as polylines, this 函数 produces a
shallow clone of the header entity only, which also owns the original set of
"owned" entities (such as vertices for a polyline) which are then
transformed by the xform matrix. This results in a corrupt drawing (two
header entities owning the same set of "owned" entities) as well as
transforming the original set of "owned" entities instead of a
copied set. Returns Acad::eOk if
successful. If xform is a
non-uniform scaling matrix or non-orthogonal then
Acad::eCannotScaleNonUniformly or Acad::eNotImplemented is returned. 函数 implementation in
derived classes The default AcDbEntity
implementation of this 函数 should be adequate
for most derived entity types. However, derived entity classes that wish to
support non-uniform scaling or non-orthogonal transformations will need to
override this method with their own implementation. This 函数 must
create a copy of the entity (using memory that has been dynamically allocated
via the C++ new operator), apply the transformation matrix xform to the copy
and then return with pEnt pointing to the transformed copy. Determining what
constitutes a valid transformation matrix and whether to do a shallow clone
(that is, the entity's clone() method), a deepclone (if the entity owns other
objects), or no clone at all (that is, make this 函数 a no-op),
is up to the implementor. Return values for this
函数 are also up to the implementor, but to be consistent with other
existing classes the following is recommended: ·
If the 函数 succeeds, it should
return Acad::eOk. ·
If the 函数 is to be a no-op, it
should return Acad::eNotImplemented ·
If non-uniform scaling is not to be supported
and a non-uniform scaling matrix is passed in, then either
Acad::eCannotScaleNonUniformly or Acad::eNotImplemented should be returned. Default implementation If the entity is
uniformly scaled and orthogonal, AcDbEntity::getTransformedCopy will call the
entity's clone() method to create a clone of the entity, then call
AcDbEntity::transformBy() on the clone, and then return with pEnt set to
point to the transformed clone. If xform is a non-uniformly scaled or a
non-orthogonal matrix, then this 函数 will return
Acad::eNotImplemented. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::isPlanar 函数 inline virtual
Adesk::Boolean isPlanar() const; This 函数 returns
Adesk::kTrue if and only if there is a plane which contains the entity.
Otherwise Adesk::kFalse is returned. Note Where
appropriate, AutoCAD built-in entity types check for planarity within a
tolerance value (for example, for AcDb3dPolyline the tolerance is 1e-10). Returns Acad::kFalse
in the default implementation. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::layer 函数 char * layer() const; This 函数 returns a
copy of the name string in the AcDbLayerTableRecord object referenced by the
entity. The calling application
is responsible for deallocating the memory used by the returned string. The
acutDelString() 函数 is recommended. Warning Calling this 函数 before the
entity has had its referenced layer object ID set (that is, it抯 still set
to AcDbObjectId::kNull) will terminate AutoCAD. If the referenced layer
objectId is AcDbObjectId::kNull when the entity is added to a database, it
will be set to the object ID of the database抯 current default
layer. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::layerId 函数 AcDbObjectId layerId() const; This 函数 returns
the AcDbObjectId of the AcDbLayerTableRecord referenced by the entity. If the
layerId has not been set yet, then AcDbObjectId::kNull is returned. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::linetype 函数 char * linetype() const; This 函数 returns a copy
of the name string in the AcDbLinetypeTableRecord object referenced
by the entity. The calling
application is responsible for deallocating the memory used by the returned
string. Either the C++ delete [ ] operator or the C free() 函数 may be
used. Warning Calling this 函数 before the
entity has had its referenced linetype object ID set (that is, it's still set
to AcDbObjectId::kNull) will terminate AutoCAD. If the referenced linetype
objectId is AcDbObjectId::kNull when the entity is added to a database it
will be set to the object ID of the database's current default linetype |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::linetypeId
函数 AcDbObjectId linetypeId() const; This 函数 returns
the AcDbObjectId of the AcDbLinetypeTableRecord referenced by the
entity. If the linetypeId has not been set yet, then AcDbObjectId::kNull will
be returned. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::linetypeScale
函数 double linetypeScale() const; This 函数 returns
the linetype scale factor for the entity |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::lineWeight
函数 AcDb::LineWeight lineWeight() const; This 函数 returns
the AcDb::LineWeight of the entity. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::list 函数 virtual void list() const; 函数 usage This 函数 is intended
to be called from AutoCAD whenever the entity is selected during the LIST
command. However, it can be called from ObjectARX applications if desired. This 函数 will print
entity specific information to the AutoCAD command line. 函数 implementation in derived
classes When implementing this
函数 in a derived class, the first thing that should be done in the 函数 is to make
a call to assertReadEnabled(). The next thing to do is to call the parent
class's list() method to allow the parent class to list it's information (the
parent class should in turn call its parent class first and so on up the
inheritance chain until AcDbObject is reached. This way all the entity's
information will be properly printed out in order). Once the parent class's
list 函数 has been called then a series of ads_printf() calls can be used to list
whatever information is desired. Default implementation Lists out the entity's
DXF name, the layer, the space the entity resides in (model or paper), and
the entity's handle. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::plotStyleName
函数 char * plotStyleName() const; This 函数 returns a
copy of the plotStyleName string of the entity. The caller is responsible for
deallocating the returned string. The plotStyleName
value is used for DXF group code 390. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::subentPtr 函数 virtual AcDbEntity * subentPtr( const
AcDbFullSubentPath& id) const;
函数 usage This 函数 uses the AcDbFullSubentPath
id to determine which subentity in the entity is desired. It then creates a
copy of that subentity using one of the classes derived from AcDbEntity so
that the copy is a true "entity" that can be added to the database.
If the 函数 succeeds then a pointer to the resulting copy
is returned, otherwise NULL is returned. Typically the
AcDbFullSubentPath object passed in via id will be obtained from the entity's
AcDbEntity::getSubentPathsAtGsMarker()
method. This guarantees that it is fully and properly filled in. The copy will be
created using dynamically allocated memory (that is, using the new operator),
so if it is not added to the database it will need to be deleted when it's no
longer needed. 函数 implementation in
derived classes This 函数 must be
able to interpret the information in the AcDbFullSubentPath id to determine which
subentity in the entity is desired. It then must create an object (using the
C++ new operator so that it's dynamically allocated and can be added to a
database later if desired) of the appropriate class derived from AcDbEntity
and fill it in with the data necessary to make it a copy of the subentity
just determined. The 函数 then returns a
pointer to the newly allocated and filled in entity. The id
AcDbFullSubentPath object has two parts, an array of objectIds containing all
the container objects of the "main" entity (the entity on which
this 函数 is being called), and an embedded AcDbSubentId object which in turn has
two elements: an index value and a SubentType. The SubentType data
item within the embedded AcDbSubentId should be used to determine what type
of subentity is being looked for. Possible SubentTypes are: AcDb::kFaceSubentType AcDb::kEdgeSubentType AcDb::kVertexSubentType AcDb::kMlineSubentCache Of course it's up to
the implementor of this 函数 to decide what type
of entity to create for each of the SubentTypes, but most commonly a face
subentity will be copied as an AcDbFace, vertex subentities are usually
an AcDbPoint object, and for edge
subentities you have your choice of the appropriate curve entities such as AcDbArc, AcDbLine, AcDbCircle, AcDbSpline, etc. However, since the AcGi
graphics primitives can only be lines, circles, arcs, xlines, and rays, those
are most likely to be the entity types you'll use. The index data item
within the embedded AcDbSubentId is then used to determine exactly which
subentity is to be copied. Though the index value
is often the same as the GS marker, there are no rules governing how to
assign and interpret index values other than that the
getSubentPathsAtGsMarker() method needs to be able to assign them properly
and this 函数 and the getGsMarkersAtSubentPath() must be able
to interpret them to determine the corresponding GS marker(s). If the
"main" entity is not nested within BlockReferences, then the
FullSubentPath's objectId array will contain only the objectId of the
"main" entity and will not be needed by this 函数. If the
"main" entity is nested in one or more BlockReferences, then the
AcDbObjectIdArray contains the objectIds of the objects that are the nested
containers of the subentity. The list is in order from the "main"
entity that the subentity is a part of, out to the outermost
AcDbBlockReference that is in model or paper space. This list of
containers will need to be used to obtain the model coordinate system to
World Coordinate System transform for each container and combine them to
obtain the total transformation from the subentity's coordinate system out to
the World Coordinate System. (Another possibility
might be to implement the entity class's worldDraw to call the
getModelToWorldTransform() method in the AcGiWorldGeometry or
AcGiViewportGeometry [depending on whether the class is using worldDraw() or
viewportDraw()] object passed into it. Then cache the matrix returned since
this will be the complete transformation matrix you need.) Regardless of how the
transformation matrix is obtained, it needs to be applied to the subentity's
data to transform the data to WCS coordinates to be used by the new AcDb
entity just created. The new entity will expect all its information to be in
WCS coordinates. If the 函数 runs to
completion then it should return a pointer to the newly created entity that
copies the subentity. If anything goes wrong, then the 函数 should
simply return NULL. Default implementation Immediately returns
NULL. |
||||||||||||||||||||||||||||||||||
|
|
AcDbEntity::visibility
函数 AcDb::Visibility visibility() const; This method returns
the entity's current visibility state, either AcDb::kVisible or
AcDb::kInvisible. |
|
|