PyGi.pyi
class ArcType Class
kAcGiArcSimple: ClassVar[Self]
kAcGiArcSector: ClassVar[Self]
kAcGiArcChord: ClassVar[Self]
class CommonDraw Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def isDragging(self) -> bool:
Returns Adesk::kTrue if the entity is currently being dragged; otherwise, returns
Adesk::kFalse. Graphically complex entities might find that using a simpler graphical
representation during dragging enhances performance with little or no loss of
functionality.
def regenAbort(self) -> bool:
Provides a means to find out if an immediate termination of the graphics regeneration is
requested by the system. If the return value is Adesk::kFalse, then all is well. But, if
the return value is Adesk::kTrue, then an immediate clean up and return should be
accomplished.
def regenType(self) -> RegenType:
Returns the current elaboration mode. The current elaboration modes of type AcGiRegenType
are: kAcGiStandardDisplay The display you normally see is being generated (REGEN).
kAcGiHideOrShadeCommand The HIDE or SHADE command is being executed. kAcGRenderCommand The
RENDER command is being executed. kAcGiSaveWorldDrawForProxy The graphics will be going
into the entity's graphics metafile in case the entity is a proxy when next loaded, so
provide graphics for proxy representation. This information allows the user to take special
action for the four different situations. Normally, you may not need to consider which mode
is in effect. However, if RENDER is running, then only geometry with filled area is
accepted (filled polygon, etc.); other geometry (polyline, unfilled polygon, etc.) is
ignored.
def subEntityTraits(self) -> SubEntityTraits:
Returns a reference to the AcGiSubEntityTraits object. The subEntityTraits object gives the
user control of, and access to, the attribute (color, layer, linetype, etc.) settings of
the current geometry. For a description of this object, see class AcGiSubEntityTraits.
class DefaultLightingType Class
kOneDistantLight: ClassVar[Self]
kTwoDistantLights: ClassVar[Self]
kBackLighting: ClassVar[Self]
class DrawFlags Class
kNoDrawFlags: ClassVar[Self]
kDrawHatchGroup: ClassVar[Self]
kDrawFrontfacesOnly: ClassVar[Self]
kDrawGradientFill: ClassVar[Self]
kDrawSolidFill: ClassVar[Self]
kDrawNoLineWeight: ClassVar[Self]
kDrawNoOptimization: ClassVar[Self]
kDrawUseAcGiEntityForDgnLineType: ClassVar[Self]
kDrawFillTextBoundaryStart: ClassVar[Self]
kDrawFillTextBoundaryEnd: ClassVar[Self]
kDrawFillSelectionWindow: ClassVar[Self]
kDrawNoForceByLayer: ClassVar[Self]
kDrawIsInWCS: ClassVar[Self]
kDrawNoImageFrame: ClassVar[Self]
class Drawable Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def bounds(self, ext: PyDb.Extents) -> bool:
This method returns reasonable, but not necessarily precise, bounds for the drawable. In
the case of nested drawables, the bounds of any child drawables are included as well. In
the case of view-dependent geometries, or other drawables with potentially varying bounds,
the union of all possible representations is returned. In the case of uncertain extents or
infinite extents (such as an infinite line or ray), the method returns False to indicate
the bounds are not available. The behavior of the drawable is undefined if the geometry
created by the drawable in its viewportDraw() and/or worldDraw() implementation extends
outside the bounds returned by AcGiDrawable::bounds().
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def drawableType(self) -> GiDrawableType:
Returns the type of the current drawable.
def id(self) -> PyDb.ObjectId:
This function returns the database ID that corresponds to this drawable (if the drawable is
persistent).
def isPersistent(self) -> bool:
This function will determine if the calling AcGiDrawable object is persistent (stored in a
database). Returns Adesk::kTrue if the AcGiDrawable object is database resident (belongs to
an AcGsModel that requires the use of open and close functions). Returns Adesk::kFalse if
the AcGiDrawable object is non-persistent (pointer-based); these drawables are accessed
directly through their AcGiDrawable pointer.
def rolloverHit(self, nSubentId: int, nMouseFlags: int, bReset: bool) -> bool:
For internal use only.
def setAttributes(self, traits: PyGi.DrawableTraits) -> int:
This function will take the input AcGiDrawableTraits object and set the values for the
current object's subentity traits. The setAttributes() method is called by the GS to setup
a drawable's default attributes. The current rendering state will employ these ambient
attributes before worldDraw() and viewportDraw() are executed (and for the 3D GS before
their cached geometry is drawn).
def viewportDraw(self, vpdraw: PyGi.ViewportDraw) -> None:
In response to viewportDraw(), a drawable uses the passed in AcGiViewportDraw interface to
describe its view-dependent geometry. This function is called per view; the results may be
cached, but the 3D GS guarantees it will call viewportDraw() (if specified by the return
value from worldDraw()) for each view and whenever the view parameters are modified. See
AcGsView for more information.
def viewportDrawLogicalFlags(self, vpdraw: PyGi.ViewportDraw) -> int:
Entity implementers who desire view-independent viewportDraw caching must provide a
meaningful response to this API -- the return value is a combination of the
AcGiDrawablesetAttributes flags. In particular, the graphic system is watching for the
kDrawableRegenTypeDependantGeometry flag which indicates that the entity in this logical
set employs isolines. The passed in AcGiViewportDraw context can be used by the drawable to
help determine which logical set is being regenerated.
def worldDraw(self, wdraw: PyGi.WorldDraw) -> bool:
In response to worldDraw(), a drawable uses the passed-in AcGiWorldDraw interface to
describe its geometry that is sharable across viewports. The 3D GS guarantees that this
function will be called at least once, but subsequent display updates may be cached. Use
AcGsModel::onModified() to invalidate any cache that the GS has associated with a drawable
so that worldDraw() will again be called upon the next display update. A return value of
Adesk::kFalse indicates that the 3D GS must call viewportDraw() in order to obtain the
complete geometry and attribute set for this drawable.
class DrawableOverrule Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def baseViewportDraw(self) -> None:
def baseViewportDrawLogicalFlags(self) -> int:
def baseWorldDraw(self) -> bool:
def className() -> str:
def desc() -> PyRx.RxClass:
def isApplicable(self) -> bool:
def setAttributes(self) -> int:
def viewportDraw(self) -> None:
def viewportDrawLogicalFlags(self) -> int:
def worldDraw(self) -> bool:
class DrawableTraits Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def setupForEntity(self, entity: PyDb.Entity) -> None:
This call initializes the entire AcGiSubEntityTraits and AcGiDrawableTraits from the
entity. This is more efficient than setting each property individually. The default
implemetation of AcDbEntity::setAttributes() uses this method. If you are implementing AcGi
you need not implement this method since and implementation is supplied which delegates to
the setXXX methods in AcGiSubEntityTraits.
class FillType Class
kAcGiFillAlways: ClassVar[Self]
kAcGiFillNever: ClassVar[Self]
class Geometry Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def circle(self, center: PyGe.Point3d, radius: float, normal: PyGe.Vector3d) -> bool:
Displays a circle primitive with center at center and a radius of radius. The circle is on
the plane defined by the normal vector normal and the point center. A return value of
Adesk::kFalse (that is, 0) indicates that the primitive has been successfully stored in the
graphics database. A return value of Adesk::kTrue indicates that the operation has been
terminated and the application wants to get control back as soon as possible.
def circle(self, p1: PyGe.Point3d, p2: PyGe.Point3d, p3: PyGe.Point3d) -> bool:
Displays a circle primitive with center at center and a radius of radius. The circle is on
the plane defined by the normal vector normal and the point center. A return value of
Adesk::kFalse (that is, 0) indicates that the primitive has been successfully stored in the
graphics database. A return value of Adesk::kTrue indicates that the operation has been
terminated and the application wants to get control back as soon as possible.
def circle(*args) -> bool:
Displays a circle primitive with center at center and a radius of radius. The circle is on
the plane defined by the normal vector normal and the point center. A return value of
Adesk::kFalse (that is, 0) indicates that the primitive has been successfully stored in the
graphics database. A return value of Adesk::kTrue indicates that the operation has been
terminated and the application wants to get control back as soon as possible.
def circularArc(self, center: PyGe.Point3d, radius: float, normal: PyGe.Vector3d, startVector: PyGe.Vector3d, sweepAngle: float) -> bool:
Displays an arc primitive defined by the arc's center of curvature center, the radius of
curvature radius, the containment plane's normal vector normal, the vector from the center
of curvature to the arc start point startVector, the angle that the arc spans sweepAngle,
and the arc type arcType. A return value of Adesk::kFalse (that is, 0) indicates that the
primitive has been successfully stored in the graphics database. A return value of
Adesk::kTrue indicates that the operation has been terminated and the application wants to
get control back as soon as possible.
def circularArc(self, center: PyGe.Point3d, radius: float, normal: PyGe.Vector3d, startVector: PyGe.Vector3d, sweepAngle: float, arcType: PyGi.ArcType) -> bool:
Displays an arc primitive defined by the arc's center of curvature center, the radius of
curvature radius, the containment plane's normal vector normal, the vector from the center
of curvature to the arc start point startVector, the angle that the arc spans sweepAngle,
and the arc type arcType. A return value of Adesk::kFalse (that is, 0) indicates that the
primitive has been successfully stored in the graphics database. A return value of
Adesk::kTrue indicates that the operation has been terminated and the application wants to
get control back as soon as possible.
def circularArc(self, p1: PyGe.Point3d, p2: PyGe.Point3d, p3: PyGe.Point3d) -> bool:
Displays an arc primitive defined by the arc's center of curvature center, the radius of
curvature radius, the containment plane's normal vector normal, the vector from the center
of curvature to the arc start point startVector, the angle that the arc spans sweepAngle,
and the arc type arcType. A return value of Adesk::kFalse (that is, 0) indicates that the
primitive has been successfully stored in the graphics database. A return value of
Adesk::kTrue indicates that the operation has been terminated and the application wants to
get control back as soon as possible.
def circularArc(self, p1: PyGe.Point3d, p2: PyGe.Point3d, p3: PyGe.Point3d, arcType: PyGe.ArcType) -> bool:
Displays an arc primitive defined by the arc's center of curvature center, the radius of
curvature radius, the containment plane's normal vector normal, the vector from the center
of curvature to the arc start point startVector, the angle that the arc spans sweepAngle,
and the arc type arcType. A return value of Adesk::kFalse (that is, 0) indicates that the
primitive has been successfully stored in the graphics database. A return value of
Adesk::kTrue indicates that the operation has been terminated and the application wants to
get control back as soon as possible.
def circularArc(*args) -> bool:
Displays an arc primitive defined by the arc's center of curvature center, the radius of
curvature radius, the containment plane's normal vector normal, the vector from the center
of curvature to the arc start point startVector, the angle that the arc spans sweepAngle,
and the arc type arcType. A return value of Adesk::kFalse (that is, 0) indicates that the
primitive has been successfully stored in the graphics database. A return value of
Adesk::kTrue indicates that the operation has been terminated and the application wants to
get control back as soon as possible.
def className() -> str:
def desc() -> PyRx.RxClass:
def draw(self, drawable: PyGi.Drawable) -> bool:
Instructs the graphics system to regenerate pDrawable as a component of this object. For
example, a Block Definition (AcDbBlockTableRecord) uses it to draw its contained objects.
Any object that owns another AcDb object should use this method to have that subentity draw
itself (as opposed to directly calling its worldDraw() method). This allows a graphics
system to cache the graphics of the object. Calling worldDraw directly would prevent this
type of caching. To implement this method: Set up linetype, layer, color, and fill type for
the AcGiDrawable using a call to setAttributes(), passing in your implementation of
AcGiSubEntityTraits. Call worldDraw() on the drawable and record the return value. If false
is returned, call viewportDraw() once for each viewport. Returning false to the caller
indicates that you did not process the request.
def edge(self, edgeList: list[PyGe.Curve2d]) -> bool:
Define the boundary of the fill.
def ellipticalArc(self, center: PyGe.Point3d, norm: PyGe.Vector3d, majAxisLen: float, minAxisLen: float, startDeg: float, endDeg: float, tilt: float, arcType: ArcType) -> bool:
This method draws an elliptical arc or full ellipse, filled or unfilled.
def getModelToWorldTransform(self) -> PyGe.Matrix3d:
This gets the net block insert transform; that is, the model-to-world coordinate transform.
The main purpose of the BLOCK entity is to transform an entity--whether to stretch, rotate,
or move it. It is possible that during the current worldDraw(), the entity is in one or
more BLOCKs. In this case, to determine the end result of the entity being transformed by
one or more BLOCKs, use the net block insert transform (model-to-world coordinate
transform) on your entity's model coordinate geometry. This will determine the location in
world coordinate space that it occupies.
def getWorldToModelTransform(self) -> PyGe.Matrix3d:
This gets the inverse of the net block insert transform. This can transform an entity's
world coordinate representation back into the original model coordinates.
def image(self, image: wx.Image, position: PyGe.Point3d, u: PyGe.Vector3d, v: PyGe.Vector3d) -> bool:
This method uses the basic transparent image parameters provided to determine where and
what size image to paint. It will stretch the image if its size is not equal to specified
size.
def image(self, image: PyGi.PixelBGRA32Array, width: int, height: int, position: PyGe.Point3d, u: PyGe.Vector3d, v: PyGe.Vector3d) -> bool:
This method uses the basic transparent image parameters provided to determine where and
what size image to paint. It will stretch the image if its size is not equal to specified
size.
def image(*args) -> bool:
This method uses the basic transparent image parameters provided to determine where and
what size image to paint. It will stretch the image if its size is not equal to specified
size.
def pline(self, p1: PyDb.Polyline, fromIndex: int, numSegs: int) -> bool:
This function uses the AcDbPolylinelwBuf as the template for the geometry it draws. It
generates display geometry that duplicates the geometry of the polyline's segments.
def polygon(self, vertexList: list[PyGe.Point3d]) -> bool:
Draws a filled or unfilled polygon, depending on AcGiSubEntityTraits::fillType(). An edge
between the last vertex and the first vertex is automatically created in order to generate
a closed polygon. The caller is responsible for the memory used by the pVertexList array.
def polyline(self, vertexList: list[PyGe.Point3d], normal: PyGe.Vector3d, marker: int) -> bool:
Walks down the list of vertex points pVertexList drawing line segments from point to point
(hence the requirement for a minimum of two points). If a thickness is currently specified
it will be applied to the segments of this polyline. The caller is responsible for the
memory used by the pVertexList array. The lBaseSubEntMarker argument has been added to
allow the caller to specify sequential sub-entity markers for the segments of the polyline.
If lBaseSubEntMarker'n' is greater than zero then the segments of the polyline will be
assigned markers beginning with 'n' incrementing by 1 for each segment.
def popModelTransform(self) -> bool:
The method must be called to restore the model transform after a call to
pushModelTransform(). Returns Adesk::kTrue if successful; otherwise, returns Adesk::kFalse.
def pushModelTransform(self, val: PyGe.Vector3d | PyGe.Matrix3d) -> bool:
This function pushes a new transform onto the transform stack. It generates the input
matrix using the arbitrary axis algorithm and the supplied vector. When you have finished
with the transform, you must call popModelTransform() to leave the pipe in the same state
as before. Returns Adesk::kTrue if successful; otherwise, returns Adesk::kFalse.
def pushOrientationTransform(self, behavior: PyGi.AcGiOrientationTransformBehavior) -> PyGe.Matrix3d:
This method places orientation transform behavior onto the current transform stack
def pushPositionTransform(self, behavior: PyGi.AcGiPositionTransformBehavior, offset: PyGe.Point2d | PyGe.Point2d) -> PyGe.Matrix3d:
This method places position transform behavior onto the current transform stack.This method
ignores z for position if behavior implies a 2D coordinate system, such as
kAcGiViewportPosition, kAcGiScreenPosition , kAcGiScreenLocalOriginPosition, or
kAcGiWorldWithScreenOffsetPosition .
def pushScaleTransform(self, behavior: PyGi.AcGiScaleTransformBehavior, extents: PyGe.Point2d | PyGe.Point2d) -> PyGe.Matrix3d:
This method places scale transform behavior onto the current transform stack.This method
ignores z for scale if behavior implies a 2D coordinate system, such as kAcGiViewportScale,
kAcGiScreenScale, kAcGiViewportLocalOriginScale, or kAcGiScreenLocalOriginScale.
def ray(self, p1: PyGe.Point3d, p2: PyGe.Point3d) -> bool:
This function displays a ray that starts at raysStartingPoint and passes through
aDifferentRayPoint. A return value of Adesk::kFalse (that is, 0) indicates that the
primitive has been successfully stored in the graphics database. A return value of
Adesk::kTrue indicates that the operation has been terminated and the application wants to
get control back as soon as possible.
def rowOfDots(self, count: int, start: PyGe.Point3d, step: PyGe.Vector3d) -> bool:
This method draws a row of dots.
def text(self, pos: PyGe.Point3d, normal: PyGe.Vector3d, direction: PyGe.Vector3d, height: float, width: float, oblique: float, msg: str) -> bool:
This method uses the current AcGiTextStyle when generating the text graphics primitive.
When worldDraw() is first entered, the AcGiTextStyle is set to the STANDARD text style
that's built into the acad.exe file (not the STANDARD text style in the drawing). The
position, normal, and direction can be thought of as the foundation for a coordinate system
that orients the text in 3D world space, where the position is the origin, the direction is
the X axis, and the normal is the Z axis. The obliquing angle for oblique is the angular
slant from vertical of each character, much the way italic text is angled. A copy of the
text string is used in pMsg, so the calling application is responsible for the memory of
the string passed in. WarningThe direction and normal vectors must be mutually
perpendicular or the results will be unpredictable. Here is an example of some text drawing
code: Adesk::Boolean someEntity::worldDraw(AcGiWorldDraw *pWd){ // Position this text to
start at 'origin', draw parallel // to the XY-plane at an upward slant of 45 degrees. //
AcGePoint3d origin(2.0, 2.0, 3.0); AcGeVector3d direction(1.0, 1.0, 0.0); AcGeVector3d
normal(0.0, 0.0, 1.0); pWd->geometry().text(origin, normal, direction, 1.0, 1.0, 0.0, 'some
text'); return Adesk:kTrue;}A return value of Adesk::kFalse (that is, 0) indicates that the
primitive has been successfully stored in the graphics database. A return value of
Adesk::kTrue indicates that the operation has been terminated and the application wants to
get control back as soon as possible.
def worldLine(self, p1: PyGe.Point3d, p2: PyGe.Point3d) -> bool:
This function draws a line between the two points in the pnts array. The points must be in
world coordinates. A return value of Adesk::kFalse (that is, 0) indicates that the
primitive has been successfully stored in the graphics database. A return value of
Adesk::kTrue indicates that the operation has been terminated, and the application wants to
get control back as soon as possible.
def xline(self, p1: PyGe.Point3d, p2: PyGe.Point3d) -> bool:
An xline passing oneXlinePoint and a DifferentXlinePoint is displayed. A return value of
Adesk::kFalse (that is, 0) indicates that the primitive has been successfully stored in the
graphics database. A return value of Adesk::kTrue indicates that the operation has been
terminated and the application wants to get control back as soon as possible.
class GiAttributesFlags Class
kDrawableNone: ClassVar[Self]
kDrawableIsAnEntity: ClassVar[Self]
kDrawableUsesNesting: ClassVar[Self]
kDrawableIsCompoundObject: ClassVar[Self]
kDrawableViewIndependentViewportDraw: ClassVar[Self]
kDrawableIsInvisible: ClassVar[Self]
kDrawableHasAttributes: ClassVar[Self]
kDrawableRegenTypeDependentGeometry: ClassVar[Self]
kDrawableIsDimension: ClassVar[Self]
kDrawableRegenDraw: ClassVar[Self]
kDrawableStandardDisplaySingleLOD: ClassVar[Self]
kDrawableShadedDisplaySingleLOD: ClassVar[Self]
kDrawableViewDependentViewportDraw: ClassVar[Self]
kDrawableBlockDependentViewportDraw: ClassVar[Self]
kDrawableIsExternalReference: ClassVar[Self]
kDrawableNotPlottable: ClassVar[Self]
kDrawableNotAllowLCS: ClassVar[Self]
kDrawableMergeControlOff: ClassVar[Self]
kThreadedWorldDrawViewportDraw: ClassVar[Self]
class GiDrawableType Class
kGeometry: ClassVar[Self]
kDistantLight: ClassVar[Self]
kPointLight: ClassVar[Self]
kSpotLight: ClassVar[Self]
kAmbientLight: ClassVar[Self]
kSolidBackground: ClassVar[Self]
kGradientBackground: ClassVar[Self]
kImageBackground: ClassVar[Self]
kGroundPlaneBackground: ClassVar[Self]
kViewport: ClassVar[Self]
kWebLight: ClassVar[Self]
kSkyBackground: ClassVar[Self]
kImageBasedLightingBackground: ClassVar[Self]
class GiGraphicsKernel Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def getDescriptor(self) -> GiKernelDescriptor:
This method returns the kernel descriptor for the graphics kernel. A given kernel only has
one descriptor, but it's possible for multiple kernels to have the same descriptor.
class GiKernelDescriptor Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def supports(self) -> bool:
This used by a consumer of an AcGsGraphicsKernel to determine which features are supported
by the kernel.
class OrientationTransformBehavior Class
kAcGiWorldOrientation: ClassVar[Self]
kAcGiScreenOrientation: ClassVar[Self]
kAcGiZAxisOrientation: ClassVar[Self]
class OrientationType Class
kAcGiCounterClockwise: ClassVar[Self]
kAcGiNoOrientation: ClassVar[Self]
kAcGiClockwise: ClassVar[Self]
class PixelBGRA32Array Class
def __contains__(self) -> bool:
def __delitem__(self) -> None:
def __getitem__(self) -> object:
def __init__(self) -> None:
def __iter__(self) -> object:
def __len__(self) -> int:
def __reduce__(self) -> Any:
def __setitem__(self) -> None:
def append(self) -> None:
def createFromWxImage(image: wx.Image, alpha: int) -> PixelBGRA32Array:
def extend(self) -> None:
class PositionTransformBehavior Class
kAcGiWorldPosition: ClassVar[Self]
kAcGiViewportPosition: ClassVar[Self]
kAcGiScreenPosition: ClassVar[Self]
kAcGiScreenLocalOriginPosition: ClassVar[Self]
kAcGiWorldWithScreenOffsetPosition: ClassVar[Self]
class RegenType Class
eAcGiRegenTypeInvalid: ClassVar[Self]
kAcGiStandardDisplay: ClassVar[Self]
kAcGiHideOrShadeCommand: ClassVar[Self]
kAcGiShadedDisplay: ClassVar[Self]
kAcGiForExplode: ClassVar[Self]
kAcGiSaveWorldDrawForProxy: ClassVar[Self]
class ScaleTransformBehavior Class
kAcGiWorldScale: ClassVar[Self]
kAcGiViewportScale: ClassVar[Self]
kAcGiScreenScale: ClassVar[Self]
kAcGiViewportLocalOriginScale: ClassVar[Self]
kAcGiScreenLocalOriginScale: ClassVar[Self]
class SelectionFlags Class
kNoSelectionFlags: ClassVar[Self]
kSelectionIgnore: ClassVar[Self]
class ShadowFlags Class
kNoDrawFlags: ClassVar[Self]
kShadowsDoesNotCast: ClassVar[Self]
kShadowsDoesNotReceive: ClassVar[Self]
kShadowsIgnore: ClassVar[Self]
class SubEntityTraits Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def color(self) -> int:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def drawFlags(self) -> int:
def fillType(self) -> FillType:
def getPlotStyleNameId(self) -> PyDb.ObjectId:
def layerId(self) -> PyDb.ObjectId:
def lineTypeId(self) -> PyDb.ObjectId:
def lineTypeScale(self) -> float:
def lineWeight(self) -> PyDb.LineWeight:
def materialId(self) -> PyDb.ObjectId:
def sectionable(self) -> bool:
def selectionGeom(self) -> bool:
def setColor(self, val: int) -> None:
def setDrawFlags(self, flags: int) -> None:
def setFillType(self, val: PyGi.FillType) -> None:
def setLayer(self, id: PyDb.ObjectId) -> None:
def setLineType(self, id: PyDb.ObjectId) -> None:
def setLineTypeScale(self, val: float) -> None:
def setLineWeight(self, val: PyDb.LineWeight) -> None:
def setMaterial(self, id: PyDb.ObjectId) -> None:
def setPlotStyleName(self, val: PyDb.PlotStyleNameType, id: PyDb.ObjectId) -> None:
def setSectionable(self, val: bool) -> None:
def setSelectionGeom(self, val: bool) -> None:
def setSelectionMarker(self, val: int) -> None:
def setShadowFlags(self, val: PyGi.ShadowFlags) -> None:
def setThickness(self, val: float) -> None:
def setTransparency(self, val: PyDb.Transparency) -> None:
def setTrueColor(self, clr: PyDb.EntityColor) -> None:
def setVisualStyle(self, id: PyDb.ObjectId) -> None:
def shadowFlags(self) -> ShadowFlags:
def thickness(self) -> float:
def transparency(self) -> PyDb.Transparency:
def trueColor(self) -> PyDb.EntityColor:
def visualStyle(self) -> PyDb.ObjectId:
class TransientDrawingMode Class
kAcGiMain: ClassVar[Self]
kAcGiSprite: ClassVar[Self]
kAcGiDirectShortTerm: ClassVar[Self]
kAcGiHighlight: ClassVar[Self]
kAcGiDirectTopmost: ClassVar[Self]
kAcGiContrast: ClassVar[Self]
kAcGiDrawingModeCount: ClassVar[Self]
class TransientManager Class
def __init__(self) -> None:
def __reduce__(self) -> Any:
def addChildTransient(self, drawable: PyGi.Drawable, parentDrawable: PyGi.Drawable) -> bool:
This function adds a child transient to specified parent transient. This allows for partial
updates of the parent drawable. Returns true if successful. This function doesn't need to
specify a drawing mode, subDrawingMode or viewportNumber; these properties of the child
transient will be the same as parent transient
def addTransient(self, drawable: PyGi.Drawable, mode: PyGi.TransientDrawingMode, subDrawingMode: int, viewportNumbers: list[int]) -> bool:
This function adds a transient to a list of viewports. Returns true if successful.
def current() -> TransientManager:
def eraseChildTransient(self, drawable: PyGi.Drawable, parentDrawable: PyGi.Drawable) -> bool:
This function erases a child transient from specified parent transient. Returns true if
successful.
def eraseTransient(self, drawable: PyGi.Drawable, viewportNumbers: list[int]) -> bool:
This function erases a transient from a list of viewports. Returns true if successful. This
function erases a specified drawable which has been added by addTransient().
def eraseTransients(self, mode: PyGi.TransientDrawingMode, subDrawingMode: int, viewportNumbers: list[int]) -> bool:
This function erases all transients in the specified subDrawingMode from a list of
viewports. Returns true if successful.
def getFreeSubDrawingMode(self, mode: PyGi.TransientDrawingMode, subDrawingMode: int, viewportNumbers: list[int]) -> tuple[int, int]:
Get the free draw order in a certain transient drawing mode. Returns 0 if the input draw
order is not free and transient manager also could not get a free draw order. Returns 1 if
the inputting draw order is available. Returns 2 if the inputting draw order is
unavailable, but transient manager could return a free draw order.
def updateChildTransient(self, drawable: PyGi.Drawable, parentDrawable: PyGi.Drawable) -> None:
This function only updates a child transient of the specified parent transient. This means
partial updates of parent drawable.
def updateTransient(self, drawable: PyGi.Drawable, viewportNumbers: list[int]) -> None:
Update a transient via the transient manager.
class TransparencyMode Class
kTransparencyOff: ClassVar[Self]
kTransparency1Bit: ClassVar[Self]
kTransparency8Bit: ClassVar[Self]
class ViewportDraw Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def geometry(self) -> ViewportGeometry:
Returns a reference to the AcGiViewportGeometry object. The viewportGeometry object allows
the user to generate geometry (polylines, arcs, meshes, etc.). For a description of this
object, see class AcGiViewportGeometry.
class ViewportGeometry Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
class Visibility Class
kAcGiInvisible: ClassVar[Self]
kAcGiVisible: ClassVar[Self]
kAcGiSilhouette: ClassVar[Self]
class WorldDraw Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.
def geometry(self) -> WorldGeometry:
Returns a reference to the AcGiWorldGeometry object. The AcGiWorldGeometry object allows
the user to generate geometry (polylines, arcs, meshes, etc.). For a description of this
object, see class AcGiWorldGeometry.
class WorldGeometry Class
def __init__() -> None:
Raises an exception.
This class cannot be instantiated from Python.
def __reduce__(self) -> Any:
def className() -> str:
def desc() -> PyRx.RxClass:
Returns a pointer to the AcRxClass object representing the specific class, or most recent
parent class explicitly registered with ObjectARX of either the pointer type used to invoke
it or the class qualifier used with it. (Remember that when a static member function is
invoked via a pointer, the pointer type, not the object type, determines which
implementation of the function is invoked.) When working with a pointer to an object and
the proper AcRxClass object for the class of the object pointed to is desired, the
AcRxObject::isA() function should be used, since it is a virtual non-static method and is
therefore not pointer type dependent. Caching the value of the pointer returned by this
method is acceptable, provided the application knows that the AcRxClass object pointed to
by the returned pointer was created by an ObjectARX application that will not be unloaded.