"""
This type stub file was generated by pyright.
"""

from .vtkPolyDataSourceWidget import vtkPolyDataSourceWidget

class vtkPlaneWidget(vtkPolyDataSourceWidget):
    """
    vtkPlaneWidget - 3D widget for manipulating a finite plane
    
    Superclass: vtkPolyDataSourceWidget
    
    This 3D widget defines a finite (bounded) plane that can be
    interactively placed in a scene. The plane has four handles (at its
    corner vertices), a normal vector, and the plane itself. The handles
    are used to resize the plane; the normal vector to rotate it, and the
    plane can be picked and translated. Selecting the plane while
    pressing CTRL makes it spin around the normal. A nice feature of the
    object is that the vtkPlaneWidget, like any 3D widget, will work with
    the current interactor style. That is, if vtkPlaneWidget does not
    handle an event, then all other registered observers (including the
    interactor style) have an opportunity to process the event.
    Otherwise, the vtkPlaneWidget will terminate the processing of the
    event that it handles.
    
    To use this object, just invoke SetInteractor() with the argument of
    the method a vtkRenderWindowInteractor.  You may also wish to invoke
    "PlaceWidget()" to initially position the widget. If the "i" key (for
    "interactor") is pressed, the vtkPlaneWidget will appear. (See
    superclass documentation for information about changing this
    behavior.) By grabbing the one of the four handles (use the left
    mouse button), the plane can be resized.  By grabbing the plane
    itself, the entire plane can be arbitrarily translated. Pressing CTRL
    while grabbing the plane will spin the plane around the normal. If
    you select the normal vector, the plane can be arbitrarily rotated.
    Selecting any part of the widget with the middle mouse button enables
    translation of the plane along its normal. (Once selected using
    middle mouse, moving the mouse in the direction of the normal
    translates the plane in the direction of the normal; moving in the
    direction opposite the normal translates the plane in the direction
    opposite the normal.) Scaling (about the center of the plane) is
    achieved by using the right mouse button. By moving the mouse "up"
    the render window the plane will be made bigger; by moving "down" the
    render window the widget will be made smaller. Events that occur
    outside of the widget (i.e., no part of the widget is picked) are
    propagated to any other registered obsevers (such as the interaction
    style).  Turn off the widget by pressing the "i" key again (or invoke
    the Off() method).
    
    The vtkPlaneWidget has several methods that can be used in
    conjunction with other VTK objects. The Set/GetResolution() methods
    control the number of subdivisions of the plane; the GetPolyData()
    method can be used to get the polygonal representation and can be
    used for things like seeding stream lines. GetPlane() can be used to
    update a vtkPlane implicit function. Typical usage of the widget is
    to make use of the StartInteractionEvent, InteractionEvent, and
    EndInteractionEvent events. The InteractionEvent is called on mouse
    motion; the other two events are called on button down and button up
    (either left or right button).
    
    Some additional features of this class include the ability to control
    the properties of the widget. You can set the properties of the
    selected and unselected representations of the plane. For example,
    you can set the property for the handles and plane. In addition there
    are methods to constrain the plane so that it is perpendicular to the
    x-y-z axes.
    
    @sa
    vtk3DWidget vtkBoxWidget vtkLineWidget vtkSphereWidget
    vtkImplicitPlaneWidget
    """
    def GetCenter(self):
        """
        V.GetCenter() -> (float, float, float)
        C++: double *GetCenter()
        V.GetCenter([float, float, float])
        C++: void GetCenter(double xyz[3])
        
        Get the center of the plane.
        """
        ...
    
    def GetHandleProperty(self):
        """
        V.GetHandleProperty() -> vtkProperty
        C++: virtual vtkProperty *GetHandleProperty()
        
        Get the handle properties (the little balls are the handles). The
        properties of the handles when selected and normal can be
        manipulated.
        """
        ...
    
    def GetNormal(self):
        """
        V.GetNormal() -> (float, float, float)
        C++: double *GetNormal()
        V.GetNormal([float, float, float])
        C++: void GetNormal(double xyz[3])
        
        Get the normal to the plane.
        """
        ...
    
    def GetNormalToXAxis(self):
        """
        V.GetNormalToXAxis() -> int
        C++: virtual vtkTypeBool GetNormalToXAxis()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def GetNormalToYAxis(self):
        """
        V.GetNormalToYAxis() -> int
        C++: virtual vtkTypeBool GetNormalToYAxis()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def GetNormalToZAxis(self):
        """
        V.GetNormalToZAxis() -> int
        C++: virtual vtkTypeBool GetNormalToZAxis()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        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.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> 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.
        """
        ...
    
    def GetOrigin(self):
        """
        V.GetOrigin() -> (float, float, float)
        C++: double *GetOrigin()
        V.GetOrigin([float, float, float])
        C++: void GetOrigin(double xyz[3])
        
        Set/Get the origin of the plane.
        """
        ...
    
    def GetPlane(self, vtkPlane):
        """
        V.GetPlane(vtkPlane)
        C++: void GetPlane(vtkPlane *plane)
        
        Get the planes describing the implicit function defined by the
        plane widget. The user must provide the instance of the class
        vtkPlane. Note that vtkPlane is a subclass of
        vtkImplicitFunction, meaning that it can be used by a variety of
        filters to perform clipping, cutting, and selection of data.
        """
        ...
    
    def GetPlaneProperty(self):
        """
        V.GetPlaneProperty() -> vtkProperty
        C++: virtual vtkProperty *GetPlaneProperty()
        
        Get the plane properties. The properties of the plane when
        selected and unselected can be manipulated.
        """
        ...
    
    def GetPoint1(self):
        """
        V.GetPoint1() -> (float, float, float)
        C++: double *GetPoint1()
        V.GetPoint1([float, float, float])
        C++: void GetPoint1(double xyz[3])
        
        Set/Get the position of the point defining the first axis of the
        plane.
        """
        ...
    
    def GetPoint2(self):
        """
        V.GetPoint2() -> (float, float, float)
        C++: double *GetPoint2()
        V.GetPoint2([float, float, float])
        C++: void GetPoint2(double xyz[3])
        
        Set/Get the position of the point defining the second axis of the
        plane.
        """
        ...
    
    def GetPolyData(self, vtkPolyData):
        """
        V.GetPolyData(vtkPolyData)
        C++: void GetPolyData(vtkPolyData *pd)
        
        Grab the polydata (including points) that defines the plane.  The
        polydata consists of (res+1)*(res+1) points, and res*res
        quadrilateral polygons, where res is the resolution of the plane.
        These point values are guaranteed to be up-to-date when either
        the InteractionEvent or EndInteraction events are invoked. The
        user provides the vtkPolyData and the points and polyplane are
        added to it.
        """
        ...
    
    def GetPolyDataAlgorithm(self):
        """
        V.GetPolyDataAlgorithm() -> vtkPolyDataAlgorithm
        C++: vtkPolyDataAlgorithm *GetPolyDataAlgorithm() override;
        
        Satisfies superclass API.  This returns a pointer to the
        underlying PolyData.  Make changes to this before calling the
        initial PlaceWidget() to have the initial placement follow suit. 
        Or, make changes after the widget has been initialised and call
        UpdatePlacement() to realise.
        """
        ...
    
    def GetRepresentation(self):
        """
        V.GetRepresentation() -> int
        C++: virtual int GetRepresentation()
        
        Control how the plane appears when GetPolyData() is invoked. If
        the mode is "outline", then just the outline of the plane is
        shown. If the mode is "wireframe" then the plane is drawn with
        the outline plus the interior mesh (corresponding to the
        resolution specified). If the mode is "surface" then the plane is
        drawn as a surface.
        """
        ...
    
    def GetRepresentationMaxValue(self):
        """
        V.GetRepresentationMaxValue() -> int
        C++: virtual int GetRepresentationMaxValue()
        
        Control how the plane appears when GetPolyData() is invoked. If
        the mode is "outline", then just the outline of the plane is
        shown. If the mode is "wireframe" then the plane is drawn with
        the outline plus the interior mesh (corresponding to the
        resolution specified). If the mode is "surface" then the plane is
        drawn as a surface.
        """
        ...
    
    def GetRepresentationMinValue(self):
        """
        V.GetRepresentationMinValue() -> int
        C++: virtual int GetRepresentationMinValue()
        
        Control how the plane appears when GetPolyData() is invoked. If
        the mode is "outline", then just the outline of the plane is
        shown. If the mode is "wireframe" then the plane is drawn with
        the outline plus the interior mesh (corresponding to the
        resolution specified). If the mode is "surface" then the plane is
        drawn as a surface.
        """
        ...
    
    def GetResolution(self):
        """
        V.GetResolution() -> int
        C++: int GetResolution()
        
        Set/Get the resolution (number of subdivisions) of the plane.
        """
        ...
    
    def GetSelectedHandleProperty(self):
        """
        V.GetSelectedHandleProperty() -> vtkProperty
        C++: virtual vtkProperty *GetSelectedHandleProperty()
        
        Get the handle properties (the little balls are the handles). The
        properties of the handles when selected and normal can be
        manipulated.
        """
        ...
    
    def GetSelectedPlaneProperty(self):
        """
        V.GetSelectedPlaneProperty() -> vtkProperty
        C++: virtual vtkProperty *GetSelectedPlaneProperty()
        
        Get the plane properties. The properties of the plane when
        selected and unselected can be manipulated.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> 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.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> 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.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkPlaneWidget
        C++: vtkPlaneWidget *NewInstance()
        """
        ...
    
    def NormalToXAxisOff(self):
        """
        V.NormalToXAxisOff()
        C++: virtual void NormalToXAxisOff()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def NormalToXAxisOn(self):
        """
        V.NormalToXAxisOn()
        C++: virtual void NormalToXAxisOn()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def NormalToYAxisOff(self):
        """
        V.NormalToYAxisOff()
        C++: virtual void NormalToYAxisOff()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def NormalToYAxisOn(self):
        """
        V.NormalToYAxisOn()
        C++: virtual void NormalToYAxisOn()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def NormalToZAxisOff(self):
        """
        V.NormalToZAxisOff()
        C++: virtual void NormalToZAxisOff()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def NormalToZAxisOn(self):
        """
        V.NormalToZAxisOn()
        C++: virtual void NormalToZAxisOn()
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def PlaceWidget(self, p_float=..., p_float=..., p_float=..., p_float=..., p_float=..., p_float=...):
        """
        V.PlaceWidget([float, float, float, float, float, float])
        C++: void PlaceWidget(double bounds[6]) override;
        V.PlaceWidget()
        C++: void PlaceWidget() override;
        V.PlaceWidget(float, float, float, float, float, float)
        C++: void PlaceWidget(double xmin, double xmax, double ymin,
            double ymax, double zmin, double zmax) override;
        
        Methods that satisfy the superclass' API.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkPlaneWidget
        C++: static vtkPlaneWidget *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetCenter(self, p_float, p_float_1, p_float_2):
        """
        V.SetCenter(float, float, float)
        C++: void SetCenter(double x, double y, double z)
        V.SetCenter([float, float, float])
        C++: void SetCenter(double x[3])
        
        Get the center of the plane.
        """
        ...
    
    def SetEnabled(self, p_int):
        """
        V.SetEnabled(int)
        C++: void SetEnabled(int) override;
        
        Methods that satisfy the superclass' API.
        """
        ...
    
    def SetNormal(self, p_float, p_float_1, p_float_2):
        """
        V.SetNormal(float, float, float)
        C++: void SetNormal(double x, double y, double z)
        V.SetNormal([float, float, float])
        C++: void SetNormal(double x[3])
        
        Get the normal to the plane.
        """
        ...
    
    def SetNormalToXAxis(self, p_int):
        """
        V.SetNormalToXAxis(int)
        C++: virtual void SetNormalToXAxis(vtkTypeBool _arg)
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def SetNormalToYAxis(self, p_int):
        """
        V.SetNormalToYAxis(int)
        C++: virtual void SetNormalToYAxis(vtkTypeBool _arg)
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def SetNormalToZAxis(self, p_int):
        """
        V.SetNormalToZAxis(int)
        C++: virtual void SetNormalToZAxis(vtkTypeBool _arg)
        
        Force the plane widget to be aligned with one of the x-y-z axes.
        Remember that when the state changes, a ModifiedEvent is invoked.
        This can be used to snap the plane to the axes if it is
        originally not aligned.
        """
        ...
    
    def SetOrigin(self, p_float, p_float_1, p_float_2):
        """
        V.SetOrigin(float, float, float)
        C++: void SetOrigin(double x, double y, double z)
        V.SetOrigin([float, float, float])
        C++: void SetOrigin(double x[3])
        
        Set/Get the origin of the plane.
        """
        ...
    
    def SetPlaneProperty(self, vtkProperty):
        """
        V.SetPlaneProperty(vtkProperty)
        C++: virtual void SetPlaneProperty(vtkProperty *)
        
        Get the plane properties. The properties of the plane when
        selected and unselected can be manipulated.
        """
        ...
    
    def SetPoint1(self, p_float, p_float_1, p_float_2):
        """
        V.SetPoint1(float, float, float)
        C++: void SetPoint1(double x, double y, double z)
        V.SetPoint1([float, float, float])
        C++: void SetPoint1(double x[3])
        
        Set/Get the position of the point defining the first axis of the
        plane.
        """
        ...
    
    def SetPoint2(self, p_float, p_float_1, p_float_2):
        """
        V.SetPoint2(float, float, float)
        C++: void SetPoint2(double x, double y, double z)
        V.SetPoint2([float, float, float])
        C++: void SetPoint2(double x[3])
        
        Set/Get the position of the point defining the second axis of the
        plane.
        """
        ...
    
    def SetRepresentation(self, p_int):
        """
        V.SetRepresentation(int)
        C++: virtual void SetRepresentation(int _arg)
        
        Control how the plane appears when GetPolyData() is invoked. If
        the mode is "outline", then just the outline of the plane is
        shown. If the mode is "wireframe" then the plane is drawn with
        the outline plus the interior mesh (corresponding to the
        resolution specified). If the mode is "surface" then the plane is
        drawn as a surface.
        """
        ...
    
    def SetRepresentationToOff(self):
        """
        V.SetRepresentationToOff()
        C++: void SetRepresentationToOff()
        
        Control how the plane appears when GetPolyData() is invoked. If
        the mode is "outline", then just the outline of the plane is
        shown. If the mode is "wireframe" then the plane is drawn with
        the outline plus the interior mesh (corresponding to the
        resolution specified). If the mode is "surface" then the plane is
        drawn as a surface.
        """
        ...
    
    def SetRepresentationToOutline(self):
        """
        V.SetRepresentationToOutline()
        C++: void SetRepresentationToOutline()
        
        Control how the plane appears when GetPolyData() is invoked. If
        the mode is "outline", then just the outline of the plane is
        shown. If the mode is "wireframe" then the plane is drawn with
        the outline plus the interior mesh (corresponding to the
        resolution specified). If the mode is "surface" then the plane is
        drawn as a surface.
        """
        ...
    
    def SetRepresentationToSurface(self):
        """
        V.SetRepresentationToSurface()
        C++: void SetRepresentationToSurface()
        
        Control how the plane appears when GetPolyData() is invoked. If
        the mode is "outline", then just the outline of the plane is
        shown. If the mode is "wireframe" then the plane is drawn with
        the outline plus the interior mesh (corresponding to the
        resolution specified). If the mode is "surface" then the plane is
        drawn as a surface.
        """
        ...
    
    def SetRepresentationToWireframe(self):
        """
        V.SetRepresentationToWireframe()
        C++: void SetRepresentationToWireframe()
        
        Control how the plane appears when GetPolyData() is invoked. If
        the mode is "outline", then just the outline of the plane is
        shown. If the mode is "wireframe" then the plane is drawn with
        the outline plus the interior mesh (corresponding to the
        resolution specified). If the mode is "surface" then the plane is
        drawn as a surface.
        """
        ...
    
    def SetResolution(self, p_int):
        """
        V.SetResolution(int)
        C++: void SetResolution(int r)
        
        Set/Get the resolution (number of subdivisions) of the plane.
        """
        ...
    
    def UpdatePlacement(self):
        """
        V.UpdatePlacement()
        C++: void UpdatePlacement(void) override;
        
        Satisfies superclass API.  This will change the state of the
        widget to match changes that have been made to the underlying
        PolyDataSource
        """
        ...
    
    def __delattr__(self, *args, **kwargs):
        """ Implement delattr(self, name). """
        ...
    
    def __getattribute__(self, *args, **kwargs):
        """ Return getattr(self, name). """
        ...
    
    def __init__(self, *args, **kwargs) -> None:
        ...
    
    @staticmethod
    def __new__(*args, **kwargs):
        """ Create and return a new object.  See help(type) for accurate signature. """
        ...
    
    def __repr__(self, *args, **kwargs):
        """ Return repr(self). """
        ...
    
    def __setattr__(self, *args, **kwargs):
        """ Implement setattr(self, name, value). """
        ...
    
    def __str__(self, *args, **kwargs) -> str:
        """ Return str(self). """
        ...
    
    __this__ = ...
    __dict__ = ...
    __vtkname__ = ...


