# encoding: utf-8 # module vtkmodules.vtkInteractionWidgets # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkInteractionWidgets.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonExecutionModel as __vtkmodules_vtkCommonExecutionModel import vtkmodules.vtkFiltersSources as __vtkmodules_vtkFiltersSources import vtkmodules.vtkRenderingContext2D as __vtkmodules_vtkRenderingContext2D import vtkmodules.vtkRenderingCore as __vtkmodules_vtkRenderingCore from .vtkWidgetRepresentation import vtkWidgetRepresentation class vtkHandleRepresentation(vtkWidgetRepresentation): """ vtkHandleRepresentation - abstract class for representing widget handles Superclass: vtkWidgetRepresentation This class defines an API for widget handle representations. These representations interact with vtkHandleWidget. Various representations can be used depending on the nature of the handle. The basic functionality of the handle representation is to maintain a position. The position is represented via a vtkCoordinate, meaning that the position can be easily obtained in a variety of coordinate systems. Optional features for this representation include an active mode (the widget appears only when the mouse pointer is close to it). The active distance is expressed in pixels and represents a circle in display space. The class may be subclassed so that alternative representations can be created. The class defines an API and a default implementation that the vtkHandleWidget interacts with to render itself in the scene. @warning The separation of the widget event handling and representation enables users and developers to create new appearances for the widget. It also facilitates parallel processing, where the client application handles events, and remote representations of the widget are slaves to the client (and do not handle events). @sa vtkRectilinearWipeWidget vtkWidgetRepresentation vtkAbstractWidget """ def ActiveRepresentationOff(self): # real signature unknown; restored from __doc__ """ ActiveRepresentationOff(self) -> None C++: virtual void ActiveRepresentationOff() """ pass def ActiveRepresentationOn(self): # real signature unknown; restored from __doc__ """ ActiveRepresentationOn(self) -> None C++: virtual void ActiveRepresentationOn() """ pass def CheckConstraint(self, renderer, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ CheckConstraint(self, renderer:vtkRenderer, pos:[float, float]) -> int C++: virtual int CheckConstraint(vtkRenderer *renderer, double pos[2]) Method has to be overridden in the subclasses which has constraints on placing the handle (Ex. vtkConstrainedPointHandleRepresentation). It should return 1 if the position is within the constraint, else it should return 0. By default it returns 1. """ pass def ConstrainedOff(self): # real signature unknown; restored from __doc__ """ ConstrainedOff(self) -> None C++: virtual void ConstrainedOff() """ pass def ConstrainedOn(self): # real signature unknown; restored from __doc__ """ ConstrainedOn(self) -> None C++: virtual void ConstrainedOn() """ pass def DeepCopy(self, prop): # real signature unknown; restored from __doc__ """ DeepCopy(self, prop:vtkProp) -> None C++: virtual void DeepCopy(vtkProp *prop) """ pass def GetActiveRepresentation(self): # real signature unknown; restored from __doc__ """ GetActiveRepresentation(self) -> int C++: virtual vtkTypeBool GetActiveRepresentation() """ return 0 def GetConstrained(self): # real signature unknown; restored from __doc__ """ GetConstrained(self) -> int C++: virtual vtkTypeBool GetConstrained() """ return 0 def GetDisplayPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetDisplayPosition(self, pos:[float, float, float]) -> None C++: virtual void GetDisplayPosition(double pos[3]) GetDisplayPosition(self) -> (float, float, float) C++: virtual double *GetDisplayPosition() """ pass def GetInteractionStateMaxValue(self): # real signature unknown; restored from __doc__ """ GetInteractionStateMaxValue(self) -> int C++: virtual int GetInteractionStateMaxValue() """ return 0 def GetInteractionStateMinValue(self): # real signature unknown; restored from __doc__ """ GetInteractionStateMinValue(self) -> int C++: virtual int GetInteractionStateMinValue() """ return 0 def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Overload the superclasses' GetMTime() because the internal vtkCoordinates are used to keep the state of the representation. """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetPointPlacer(self): # real signature unknown; restored from __doc__ """ GetPointPlacer(self) -> vtkPointPlacer C++: virtual vtkPointPlacer *GetPointPlacer() """ return vtkPointPlacer def GetTolerance(self): # real signature unknown; restored from __doc__ """ GetTolerance(self) -> int C++: virtual int GetTolerance() """ return 0 def GetToleranceMaxValue(self): # real signature unknown; restored from __doc__ """ GetToleranceMaxValue(self) -> int C++: virtual int GetToleranceMaxValue() """ return 0 def GetToleranceMinValue(self): # real signature unknown; restored from __doc__ """ GetToleranceMinValue(self) -> int C++: virtual int GetToleranceMinValue() """ return 0 def GetTranslationAxis(self): # real signature unknown; restored from __doc__ """ GetTranslationAxis(self) -> int C++: virtual int GetTranslationAxis() Gets/Sets the constraint axis for translations. Returns Axis::NONE if none. """ return 0 def GetTranslationAxisMaxValue(self): # real signature unknown; restored from __doc__ """ GetTranslationAxisMaxValue(self) -> int C++: virtual int GetTranslationAxisMaxValue() """ return 0 def GetTranslationAxisMinValue(self): # real signature unknown; restored from __doc__ """ GetTranslationAxisMinValue(self) -> int C++: virtual int GetTranslationAxisMinValue() """ return 0 def GetTranslationVector(self, p1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetTranslationVector(self, p1:(float, ...), p2:(float, ...), v:[float, ...]) -> None C++: virtual void GetTranslationVector(const double *p1, const double *p2, double *v) Gets the translation vector """ pass def GetWorldPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetWorldPosition(self, pos:[float, float, float]) -> None C++: virtual void GetWorldPosition(double pos[3]) GetWorldPosition(self) -> (float, float, float) C++: virtual double *GetWorldPosition() """ pass def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsTranslationConstrained(self): # real signature unknown; restored from __doc__ """ IsTranslationConstrained(self) -> bool C++: bool IsTranslationConstrained() Returns true if ContrainedAxis """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkHandleRepresentation C++: vtkHandleRepresentation *NewInstance() """ return vtkHandleRepresentation def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkHandleRepresentation C++: static vtkHandleRepresentation *SafeDownCast( vtkObjectBase *o) """ return vtkHandleRepresentation def SetActiveRepresentation(self, _arg): # real signature unknown; restored from __doc__ """ SetActiveRepresentation(self, _arg:int) -> None C++: virtual void SetActiveRepresentation(vtkTypeBool _arg) Flag controls whether the widget becomes visible when the mouse pointer moves close to it (i.e., the widget becomes active). By default, ActiveRepresentation is off and the representation is always visible. """ pass def SetConstrained(self, _arg): # real signature unknown; restored from __doc__ """ SetConstrained(self, _arg:int) -> None C++: virtual void SetConstrained(vtkTypeBool _arg) Specify whether any motions (such as scale, translate, etc.) are constrained in some way (along an axis, etc.) Widgets can use this to control the resulting motion. """ pass def SetDisplayPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetDisplayPosition(self, pos:[float, float, float]) -> None C++: virtual void SetDisplayPosition(double pos[3]) Handles usually have their coordinates set in display coordinates (generally by an associated widget) and internally maintain the position in world coordinates. (Using world coordinates insures that handles are rendered in the right position when the camera view changes.) These methods are often subclassed because special constraint operations can be used to control the actual positioning. """ pass def SetInteractionState(self, _arg): # real signature unknown; restored from __doc__ """ SetInteractionState(self, _arg:int) -> None C++: virtual void SetInteractionState(int _arg) The interaction state may be set from a widget (e.g., HandleWidget) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking processwith the widget: First ComputeInteractionState() is invoked that returns a state based on geometric considerations (i.e., cursor near a widget feature), then based on events, the widget may modify this further. """ pass def SetPointPlacer(self, __a): # real signature unknown; restored from __doc__ """ SetPointPlacer(self, __a:vtkPointPlacer) -> None C++: virtual void SetPointPlacer(vtkPointPlacer *) Set/Get the point placer. Point placers can be used to dictate constraints on the placement of handles. As an example, see vtkBoundedPlanePointPlacer (constrains the placement of handles to a set of bounded planes) vtkFocalPlanePointPlacer (constrains placement on the focal plane) etc. The default point placer is vtkPointPlacer (which does not apply any constraints, so the handles are free to move anywhere). """ pass def SetRenderer(self, ren): # real signature unknown; restored from __doc__ """ SetRenderer(self, ren:vtkRenderer) -> None C++: void SetRenderer(vtkRenderer *ren) override; Subclasses of vtkWidgetRepresentation must implement these methods. This is considered the minimum API for a widget representation. SetRenderer() - the renderer in which the representations draws itself. Typically the renderer is set by the associated widget. Use the widget's SetCurrentRenderer() method in most cases; otherwise there is a risk of inconsistent behavior as events and drawing may be performed in different viewports. BuildRepresentation() - update the geometry of the widget based on its current state. WARNING: The renderer is NOT reference counted by the representation, in order to avoid reference loops. Be sure that the representation lifetime does not extend beyond the renderer lifetime. """ pass def SetTolerance(self, _arg): # real signature unknown; restored from __doc__ """ SetTolerance(self, _arg:int) -> None C++: virtual void SetTolerance(int _arg) The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active. """ pass def SetTranslationAxis(self, _arg): # real signature unknown; restored from __doc__ """ SetTranslationAxis(self, _arg:int) -> None C++: virtual void SetTranslationAxis(int _arg) """ pass def SetTranslationAxisOff(self): # real signature unknown; restored from __doc__ """ SetTranslationAxisOff(self) -> None C++: void SetTranslationAxisOff() """ pass def SetWorldPosition(self, pos, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SetWorldPosition(self, pos:[float, float, float]) -> None C++: virtual void SetWorldPosition(double pos[3]) """ pass def SetXTranslationAxisOn(self): # real signature unknown; restored from __doc__ """ SetXTranslationAxisOn(self) -> None C++: void SetXTranslationAxisOn() Toggles constraint translation axis on/off. """ pass def SetYTranslationAxisOn(self): # real signature unknown; restored from __doc__ """ SetYTranslationAxisOn(self) -> None C++: void SetYTranslationAxisOn() """ pass def SetZTranslationAxisOn(self): # real signature unknown; restored from __doc__ """ SetZTranslationAxisOn(self) -> None C++: void SetZTranslationAxisOn() """ pass def ShallowCopy(self, prop): # real signature unknown; restored from __doc__ """ ShallowCopy(self, prop:vtkProp) -> None C++: void ShallowCopy(vtkProp *prop) override; Methods to make this class properly act like a vtkWidgetRepresentation. """ pass def Translate(self, p1, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Translate(self, p1:(float, ...), p2:(float, ...)) -> None C++: virtual void Translate(const double *p1, const double *p2) Translate(self, v:(float, ...)) -> None C++: virtual void Translate(const double *v) Translates world position by vector p1p2 projected on the constraint axis if any. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" InteractionStateType = None # (!) real value is "" Nearby = 1 Outside = 0 Scaling = 4 Selecting = 2 Translating = 3 __dict__ = None # (!) real value is "mappingproxy({'__vtkname__': 'vtkHandleRepresentation', 'IsTypeOf': , 'IsA': , 'SafeDownCast': , 'NewInstance': , 'GetNumberOfGenerationsFromBaseType': , 'GetNumberOfGenerationsFromBase': , 'SetDisplayPosition': , 'GetDisplayPosition': , 'SetWorldPosition': , 'GetWorldPosition': , 'SetTolerance': , 'GetToleranceMinValue': , 'GetToleranceMaxValue': , 'GetTolerance': , 'SetActiveRepresentation': , 'GetActiveRepresentation': , 'ActiveRepresentationOn': , 'ActiveRepresentationOff': , 'SetInteractionState': , 'GetInteractionStateMinValue': , 'GetInteractionStateMaxValue': , 'SetConstrained': , 'GetConstrained': , 'ConstrainedOn': , 'ConstrainedOff': , 'CheckConstraint': , 'ShallowCopy': , 'DeepCopy': , 'SetRenderer': , 'GetMTime': , 'SetPointPlacer': , 'GetPointPlacer': , 'GetTranslationVector': , 'Translate': , 'GetTranslationAxis': , 'SetTranslationAxis': , 'GetTranslationAxisMinValue': , 'GetTranslationAxisMaxValue': , 'SetXTranslationAxisOn': , 'SetYTranslationAxisOn': , 'SetZTranslationAxisOn': , 'SetTranslationAxisOff': , 'IsTranslationConstrained': , 'InteractionStateType': , 'Outside': 0, 'Nearby': 1, 'Selecting': 2, 'Translating': 3, 'Scaling': 4, '__new__': , '__repr__': , '__str__': , '__getattribute__': , '__setattr__': , '__delattr__': , '__dict__': , '__this__': , '__doc__': 'vtkHandleRepresentation - abstract class for representing widget\\nhandles\\n\\nSuperclass: vtkWidgetRepresentation\\n\\nThis class defines an API for widget handle representations. These\\nrepresentations interact with vtkHandleWidget. Various\\nrepresentations can be used depending on the nature of the handle.\\nThe basic functionality of the handle representation is to maintain a\\nposition. The position is represented via a vtkCoordinate, meaning\\nthat the position can be easily obtained in a variety of coordinate\\nsystems.\\n\\nOptional features for this representation include an active mode (the\\nwidget appears only when the mouse pointer is close to it). The\\nactive distance is expressed in pixels and represents a circle in\\ndisplay space.\\n\\nThe class may be subclassed so that alternative representations can\\nbe created. The class defines an API and a default implementation\\nthat the vtkHandleWidget interacts with to render itself in the\\nscene.\\n\\n@warning\\nThe separation of the widget event handling and representation\\nenables users and developers to create new appearances for the\\nwidget. It also facilitates parallel processing, where the client\\napplication handles events, and remote representations of the widget\\nare slaves to the client (and do not handle events).\\n\\n@sa\\nvtkRectilinearWipeWidget vtkWidgetRepresentation vtkAbstractWidget\\n\\n'})" __vtkname__ = 'vtkHandleRepresentation'