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

from .vtkAbstractWidget import vtkAbstractWidget

class vtkContourWidget(vtkAbstractWidget):
    """
    vtkContourWidget - create a contour with a set of points
    
    Superclass: vtkAbstractWidget
    
    The vtkContourWidget is used to select a set of points, and draw
    lines between these points. The contour may be opened or closed,
    depending on how the last point is added. The widget handles all
    processing of widget events (that are triggered by VTK events). The
    vtkContourRepresentation is responsible for all placement of the
    points, calculation of the lines, and contour manipulation. This is
    done through two main helper classes: vtkPointPlacer and
    vtkContourLineInterpolator. The representation is also responsible
    for drawing the points and lines.
    
    @par Event Bindings: By default, the widget responds to the following
    VTK events (i.e., it watches the vtkRenderWindowInteractor for these
    events):
    
    
      LeftButtonPressEvent - triggers a Select event
      RightButtonPressEvent - triggers a AddFinalPoint event
      MouseMoveEvent - triggers a Move event
      LeftButtonReleaseEvent - triggers an EndSelect event
      Delete key event - triggers a Delete event
      Shift + Delete key event - triggers a Reset event 
    
    @par Event Bindings: Note that the event bindings described above can
    be changed using this class's vtkWidgetEventTranslator. This class
    translates VTK events into the vtkContourWidget's widget events:
    
    
      vtkWidgetEvent::Select
           widget state is:
               Start or
               Define: If we already have at least 2 nodes, test
                    whether the current (X,Y) location is near an
    existing
                    node. If so, close the contour and change to
    Manipulate
                    state. Otherwise, attempt to add a node at this (X,Y)
                    location.
               Manipulate: If this (X,Y) location activates a node, then
                    set the current operation to Translate. Otherwise, if
                    this location is near the contour, attempt to add a
                    new node on the contour at this (X,Y) location.
    
    @par Event Bindings:
      vtkWidgetEvent::AddFinalPoint
           widget state is:
               Start: Do nothing.
               Define: If we already have at least 2 nodes, test
                    whether the current (X,Y) location is near an
    existing
                    node. If so, close the contour and change to
    Manipulate
                    state. Otherwise, attempt to add a node at this (X,Y)
                    location. If we do, then leave the contour open and
                    change to Manipulate state.
               Manipulate: Do nothing.
    
    @par Event Bindings:
      vtkWidgetEvent::Move
           widget state is:
               Start or
               Define: Do nothing.
               Manipulate: If our operation is Translate, then invoke
                     WidgetInteraction() on the representation. If our
                     operation is Inactive, then just attempt to activate
                     a node at this (X,Y) location.
    
    @par Event Bindings:
      vtkWidgetEvent::EndSelect
           widget state is:
               Start or
               Define: Do nothing.
               Manipulate: If our operation is not Inactive, set it to
                     Inactive.
    
    @par Event Bindings:
      vtkWidgetEvent::Delete
           widget state is:
               Start: Do nothing.
               Define: Remove the last point on the contour.
               Manipulate: Attempt to activate a node at (X,Y). If
                      we do activate a node, delete it. If we now
                      have less than 3 nodes, go back to Define state.
    
    @par Event Bindings:
      vtkWidgetEvent::Reset
           widget state is:
               Start: Do nothing.
               Define: Remove all points and line segments of the
    contour.
                    Essentially calls Initialize(nullptr)
               Manipulate: Do nothing. 
    
    @par Event Bindings: This widget invokes the following VTK events on
    itself (which observers can listen for):
    
    
      vtkCommand::StartInteractionEvent (beginning to interact)
      vtkCommand::EndInteractionEvent (completing interaction)
      vtkCommand::InteractionEvent (moving after selecting something)
      vtkCommand::PlacePointEvent (after point is positioned;
                                   call data includes handle id (0,1))
      vtkCommand::WidgetValueChangedEvent (Invoked when the contour is
    closed
                                           for the first time. ) 
    
    @sa
    vtkHandleWidget
    """
    def AllowNodePickingOff(self):
        """
        V.AllowNodePickingOff()
        C++: virtual void AllowNodePickingOff()
        
        Set / Get the AllowNodePicking value. This ivar indicates whether
        the nodes and points between nodes can be picked/un-picked by
        Ctrl+Click on the node.
        """
        ...
    
    def AllowNodePickingOn(self):
        """
        V.AllowNodePickingOn()
        C++: virtual void AllowNodePickingOn()
        
        Set / Get the AllowNodePicking value. This ivar indicates whether
        the nodes and points between nodes can be picked/un-picked by
        Ctrl+Click on the node.
        """
        ...
    
    def CloseLoop(self):
        """
        V.CloseLoop()
        C++: void CloseLoop()
        
        Convenient method to close the contour loop.
        """
        ...
    
    def ContinuousDrawOff(self):
        """
        V.ContinuousDrawOff()
        C++: virtual void ContinuousDrawOff()
        
        Define a contour by continuously drawing with the mouse cursor.
        Press and hold the left mouse button down to continuously draw.
        Releasing the left mouse button switches into a snap drawing
        mode. Terminate the contour by pressing the right mouse button. 
        If you do not want to see the nodes as they are added to the
        contour, set the opacity to 0 of the representation's property. 
        If you do not want to see the last active node as it is being
        added, set the opacity to 0 of the representation's active
        property.
        """
        ...
    
    def ContinuousDrawOn(self):
        """
        V.ContinuousDrawOn()
        C++: virtual void ContinuousDrawOn()
        
        Define a contour by continuously drawing with the mouse cursor.
        Press and hold the left mouse button down to continuously draw.
        Releasing the left mouse button switches into a snap drawing
        mode. Terminate the contour by pressing the right mouse button. 
        If you do not want to see the nodes as they are added to the
        contour, set the opacity to 0 of the representation's property. 
        If you do not want to see the last active node as it is being
        added, set the opacity to 0 of the representation's active
        property.
        """
        ...
    
    def CreateDefaultRepresentation(self):
        """
        V.CreateDefaultRepresentation()
        C++: void CreateDefaultRepresentation() override;
        
        Create the default widget representation if one is not set.
        """
        ...
    
    def FollowCursorOff(self):
        """
        V.FollowCursorOff()
        C++: virtual void FollowCursorOff()
        
        Follow the cursor ? If this is ON, during definition, the last
        node of the contour will automatically follow the cursor, without
        waiting for the point to be dropped. This may be useful for some
        interpolators, such as the live-wire interpolator to see the
        shape of the contour that will be placed as you move the mouse
        cursor.
        """
        ...
    
    def FollowCursorOn(self):
        """
        V.FollowCursorOn()
        C++: virtual void FollowCursorOn()
        
        Follow the cursor ? If this is ON, during definition, the last
        node of the contour will automatically follow the cursor, without
        waiting for the point to be dropped. This may be useful for some
        interpolators, such as the live-wire interpolator to see the
        shape of the contour that will be placed as you move the mouse
        cursor.
        """
        ...
    
    def GetAllowNodePicking(self):
        """
        V.GetAllowNodePicking() -> int
        C++: virtual vtkTypeBool GetAllowNodePicking()
        
        Set / Get the AllowNodePicking value. This ivar indicates whether
        the nodes and points between nodes can be picked/un-picked by
        Ctrl+Click on the node.
        """
        ...
    
    def GetContinuousDraw(self):
        """
        V.GetContinuousDraw() -> int
        C++: virtual vtkTypeBool GetContinuousDraw()
        
        Define a contour by continuously drawing with the mouse cursor.
        Press and hold the left mouse button down to continuously draw.
        Releasing the left mouse button switches into a snap drawing
        mode. Terminate the contour by pressing the right mouse button. 
        If you do not want to see the nodes as they are added to the
        contour, set the opacity to 0 of the representation's property. 
        If you do not want to see the last active node as it is being
        added, set the opacity to 0 of the representation's active
        property.
        """
        ...
    
    def GetContourRepresentation(self):
        """
        V.GetContourRepresentation() -> vtkContourRepresentation
        C++: vtkContourRepresentation *GetContourRepresentation()
        
        Return the representation as a vtkContourRepresentation.
        """
        ...
    
    def GetFollowCursor(self):
        """
        V.GetFollowCursor() -> int
        C++: virtual vtkTypeBool GetFollowCursor()
        
        Follow the cursor ? If this is ON, during definition, the last
        node of the contour will automatically follow the cursor, without
        waiting for the point to be dropped. This may be useful for some
        interpolators, such as the live-wire interpolator to see the
        shape of the contour that will be placed as you move the mouse
        cursor.
        """
        ...
    
    def GetNumberOfGenerationsFromBase(self, string):
        """
        V.GetNumberOfGenerationsFromBase(string) -> int
        C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type)
            override;
        
        Standard methods for a VTK class.
        """
        ...
    
    def GetNumberOfGenerationsFromBaseType(self, string):
        """
        V.GetNumberOfGenerationsFromBaseType(string) -> int
        C++: static vtkIdType GetNumberOfGenerationsFromBaseType(
            const char *type)
        
        Standard methods for a VTK class.
        """
        ...
    
    def GetWidgetState(self):
        """
        V.GetWidgetState() -> int
        C++: virtual int GetWidgetState()
        
        Convenient method to determine the state of the method
        """
        ...
    
    def Initialize(self, vtkPolyData, p_int, vtkIdList):
        """
        V.Initialize(vtkPolyData, int, vtkIdList)
        C++: virtual void Initialize(vtkPolyData *poly, int state=1,
            vtkIdList *idList=nullptr)
        V.Initialize()
        C++: virtual void Initialize()
        
        Initialize the contour widget from a user supplied set of points.
        The state of the widget decides if you are still defining the
        widget, or if you've finished defining (added the last point) are
        manipulating it. Note that if the polydata supplied is closed,
        the state will be set to manipulate. State: Define = 0,
        Manipulate = 1.
        """
        ...
    
    def IsA(self, string):
        """
        V.IsA(string) -> int
        C++: vtkTypeBool IsA(const char *type) override;
        
        Standard methods for a VTK class.
        """
        ...
    
    def IsTypeOf(self, string):
        """
        V.IsTypeOf(string) -> int
        C++: static vtkTypeBool IsTypeOf(const char *type)
        
        Standard methods for a VTK class.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkContourWidget
        C++: vtkContourWidget *NewInstance()
        
        Standard methods for a VTK class.
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkContourWidget
        C++: static vtkContourWidget *SafeDownCast(vtkObjectBase *o)
        
        Standard methods for a VTK class.
        """
        ...
    
    def SetAllowNodePicking(self, p_int):
        """
        V.SetAllowNodePicking(int)
        C++: void SetAllowNodePicking(vtkTypeBool)
        
        Set / Get the AllowNodePicking value. This ivar indicates whether
        the nodes and points between nodes can be picked/un-picked by
        Ctrl+Click on the node.
        """
        ...
    
    def SetContinuousDraw(self, p_int):
        """
        V.SetContinuousDraw(int)
        C++: virtual void SetContinuousDraw(vtkTypeBool _arg)
        
        Define a contour by continuously drawing with the mouse cursor.
        Press and hold the left mouse button down to continuously draw.
        Releasing the left mouse button switches into a snap drawing
        mode. Terminate the contour by pressing the right mouse button. 
        If you do not want to see the nodes as they are added to the
        contour, set the opacity to 0 of the representation's property. 
        If you do not want to see the last active node as it is being
        added, set the opacity to 0 of the representation's active
        property.
        """
        ...
    
    def SetEnabled(self, p_int):
        """
        V.SetEnabled(int)
        C++: void SetEnabled(int) override;
        
        The method for activating and deactivating this widget. This
        method must be overridden because it is a composite widget and
        does more than its superclasses' vtkAbstractWidget::SetEnabled()
        method.
        """
        ...
    
    def SetFollowCursor(self, p_int):
        """
        V.SetFollowCursor(int)
        C++: virtual void SetFollowCursor(vtkTypeBool _arg)
        
        Follow the cursor ? If this is ON, during definition, the last
        node of the contour will automatically follow the cursor, without
        waiting for the point to be dropped. This may be useful for some
        interpolators, such as the live-wire interpolator to see the
        shape of the contour that will be placed as you move the mouse
        cursor.
        """
        ...
    
    def SetRepresentation(self, vtkContourRepresentation):
        """
        V.SetRepresentation(vtkContourRepresentation)
        C++: void SetRepresentation(vtkContourRepresentation *r)
        
        Specify an instance of vtkWidgetRepresentation used to represent
        this widget in the scene. Note that the representation is a
        subclass of vtkProp so it can be added to the renderer
        independent of the widget.
        """
        ...
    
    def SetWidgetState(self, p_int):
        """
        V.SetWidgetState(int)
        C++: virtual void SetWidgetState(int _arg)
        
        Convenient method to change what state the widget is in.
        """
        ...
    
    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__ = ...
    Define = ...
    Manipulate = ...
    Start = ...
    __dict__ = ...
    __vtkname__ = ...


