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

from .vtkOpenGLRenderWindow import vtkOpenGLRenderWindow

class vtkXOpenGLRenderWindow(vtkOpenGLRenderWindow):
    """
    vtkXOpenGLRenderWindow - OpenGL rendering window
    
    Superclass: vtkOpenGLRenderWindow
    
    vtkXOpenGLRenderWindow is a concrete implementation of the abstract
    class vtkRenderWindow. vtkOpenGLRenderer interfaces to the OpenGL
    graphics library. Application programmers should normally use
    vtkRenderWindow instead of the OpenGL specific version.
    """
    def Finalize(self):
        """
        V.Finalize()
        C++: void Finalize() override;
        
        "Deinitialize" the rendering window.  This will shutdown all
        system-specific resources.  After having called this, it should
        be possible to destroy a window that was used for a SetWindowId()
        call without any ill effects.
        """
        ...
    
    def Frame(self):
        """
        V.Frame()
        C++: void Frame() override;
        
        End the rendering process and display the image.
        """
        ...
    
    def GetDesiredDepth(self):
        """
        V.GetDesiredDepth() -> int
        C++: virtual int GetDesiredDepth()
        
        Get the X properties of an ideal rendering window.
        """
        ...
    
    def GetEventPending(self):
        """
        V.GetEventPending() -> int
        C++: vtkTypeBool GetEventPending() override;
        
        Check to see if a mouse button has been pressed or mouse wheel
        activated. All other events are ignored by this method. This is a
        useful check to abort a long render.
        """
        ...
    
    def GetGenericContext(self):
        """
        V.GetGenericContext() -> void
        C++: void *GetGenericContext() override;
        
        Dummy stubs for vtkWindow API.
        """
        ...
    
    def GetGenericDisplayId(self):
        """
        V.GetGenericDisplayId() -> void
        C++: void *GetGenericDisplayId() override;
        
        Xwindow get set functions
        """
        ...
    
    def GetGenericDrawable(self):
        """
        V.GetGenericDrawable() -> void
        C++: void *GetGenericDrawable() override;
        
        Dummy stubs for vtkWindow API.
        """
        ...
    
    def GetGenericParentId(self):
        """
        V.GetGenericParentId() -> void
        C++: void *GetGenericParentId() override;
        
        Dummy stubs for vtkWindow API.
        """
        ...
    
    def GetGenericWindowId(self):
        """
        V.GetGenericWindowId() -> void
        C++: void *GetGenericWindowId() override;
        
        Dummy stubs for vtkWindow API.
        """
        ...
    
    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 GetPlatformSupportsRenderWindowSharing(self):
        """
        V.GetPlatformSupportsRenderWindowSharing() -> bool
        C++: bool GetPlatformSupportsRenderWindowSharing() override;
        
        Does this platform support render window data sharing.
        """
        ...
    
    def GetPosition(self):
        """
        V.GetPosition() -> (int, int)
        C++: int *GetPosition() override;
        
        Get the position (x and y) of the rendering window in screen
        coordinates (in pixels).
        """
        ...
    
    def GetScreenSize(self):
        """
        V.GetScreenSize() -> (int, int)
        C++: int *GetScreenSize() override;
        
        Get the current size of the screen in pixels. An HDTV for example
        would be 1920 x 1080 pixels.
        """
        ...
    
    def HideCursor(self):
        """
        V.HideCursor()
        C++: void HideCursor() override;
        
        Hide or Show the mouse cursor, it is nice to be able to hide the
        default cursor if you want VTK to display a 3D cursor instead.
        """
        ...
    
    def Initialize(self):
        """
        V.Initialize()
        C++: void Initialize() override;
        
        Initialize the rendering window.  This will setup all
        system-specific resources.  This method and Finalize() must be
        symmetric and it should be possible to call them multiple times,
        even changing WindowId in-between.  This is what WindowRemap
        does.
        """
        ...
    
    def InitializeFromCurrentContext(self):
        """
        V.InitializeFromCurrentContext() -> bool
        C++: bool InitializeFromCurrentContext() override;
        
        Initialize the render window from the information associated with
        the currently activated OpenGL context.
        """
        ...
    
    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 IsCurrent(self):
        """
        V.IsCurrent() -> bool
        C++: bool IsCurrent() override;
        
        Tells if this window is the current OpenGL context for the
        calling thread.
        """
        ...
    
    def IsDirect(self):
        """
        V.IsDirect() -> int
        C++: vtkTypeBool IsDirect() override;
        
        Is this render window using hardware acceleration? 0-false,
        1-true
        """
        ...
    
    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 MakeCurrent(self):
        """
        V.MakeCurrent()
        C++: void MakeCurrent() override;
        
        Make this window the current OpenGL context.
        """
        ...
    
    def NewInstance(self):
        """
        V.NewInstance() -> vtkXOpenGLRenderWindow
        C++: vtkXOpenGLRenderWindow *NewInstance()
        """
        ...
    
    def PopContext(self):
        """
        V.PopContext()
        C++: void PopContext() override;
        
        Ability to push and pop this window's context as the current
        context. The idea being to if needed make this window's context
        current and when done releasing resources restore the prior
        context
        """
        ...
    
    def PrefFullScreen(self):
        """
        V.PrefFullScreen()
        C++: virtual void PrefFullScreen()
        
        Set the preferred window size to full screen.
        """
        ...
    
    def PushContext(self):
        """
        V.PushContext()
        C++: void PushContext() override;
        
        Ability to push and pop this window's context as the current
        context. The idea being to if needed make this window's context
        current and when done releasing resources restore the prior
        context
        """
        ...
    
    def Render(self):
        """
        V.Render()
        C++: void Render() override;
        
        This computes the size of the render window before calling the
        supper classes render
        """
        ...
    
    def ReportCapabilities(self):
        """
        V.ReportCapabilities() -> string
        C++: const char *ReportCapabilities() override;
        
        Get report of capabilities for the render window
        """
        ...
    
    def SafeDownCast(self, vtkObjectBase):
        """
        V.SafeDownCast(vtkObjectBase) -> vtkXOpenGLRenderWindow
        C++: static vtkXOpenGLRenderWindow *SafeDownCast(vtkObjectBase *o)
        """
        ...
    
    def SetCurrentCursor(self, p_int):
        """
        V.SetCurrentCursor(int)
        C++: void SetCurrentCursor(int) override;
        
        Change the shape of the cursor
        """
        ...
    
    def SetDisplayId(self, void):
        """
        V.SetDisplayId(void)
        C++: void SetDisplayId(void *) override;
        
        Set the X display id for this RenderWindow to use to a
        pre-existing X display id.
        """
        ...
    
    def SetForceMakeCurrent(self):
        """
        V.SetForceMakeCurrent()
        C++: void SetForceMakeCurrent() override;
        
        If called, allow MakeCurrent() to skip cache-check when called.
        MakeCurrent() reverts to original behavior of cache-checking on
        the next render.
        """
        ...
    
    def SetFullScreen(self, p_int):
        """
        V.SetFullScreen(int)
        C++: void SetFullScreen(vtkTypeBool) override;
        
        Change the window to fill the entire screen.
        """
        ...
    
    def SetNextWindowId(self, void):
        """
        V.SetNextWindowId(void)
        C++: void SetNextWindowId(void *) override;
        
        Set the window id of the new window once a WindowRemap is done.
        This is the generic prototype as required by the vtkRenderWindow
        parent.
        """
        ...
    
    def SetNextWindowInfo(self, string):
        """
        V.SetNextWindowInfo(string)
        C++: void SetNextWindowInfo(const char *info) override;
        
        Set the window info that will be used after WindowRemap()
        """
        ...
    
    def SetParentId(self, void):
        """
        V.SetParentId(void)
        C++: void SetParentId(void *) override;
        
        Sets the parent of the window that WILL BE created.
        """
        ...
    
    def SetParentInfo(self, string):
        """
        V.SetParentInfo(string)
        C++: void SetParentInfo(const char *info) override;
        
        Sets the X window id of the window that WILL BE created.
        """
        ...
    
    def SetPosition(self, p_int, p_int_1):
        """
        V.SetPosition(int, int)
        C++: void SetPosition(int x, int y) override;
        V.SetPosition([int, int])
        C++: void SetPosition(int a[2]) override;
        
        Set the position (x and y) of the rendering window in screen
        coordinates (in pixels). This resizes the operating system's
        view/window and redraws it.
        """
        ...
    
    def SetShowWindow(self, bool):
        """
        V.SetShowWindow(bool)
        C++: void SetShowWindow(bool val) override;
        
        Show or not Show the window
        """
        ...
    
    def SetSize(self, p_int, p_int_1):
        """
        V.SetSize(int, int)
        C++: void SetSize(int width, int height) override;
        V.SetSize([int, int])
        C++: void SetSize(int a[2]) override;
        
        Set the size (width and height) of the rendering window in screen
        coordinates (in pixels). This resizes the operating system's
        view/window and redraws it.
        
        If the size has changed, this method will fire
        vtkCommand::WindowResizeEvent.
        """
        ...
    
    def SetSizeNoXResize(self, p_int, p_int_1):
        """
        V.SetSizeNoXResize(int, int)
        C++: void SetSizeNoXResize(int, int)
        
        Specify the size of the rendering window in pixels but do not
        resize the XWindow. Useful when resizing is done interactively.
        """
        ...
    
    def SetStereoCapableWindow(self, p_int):
        """
        V.SetStereoCapableWindow(int)
        C++: void SetStereoCapableWindow(vtkTypeBool capable) override;
        
        Prescribe that the window be created in a stereo-capable mode.
        This method must be called before the window is realized. This
        method overrides the superclass method since this class can
        actually check whether the window has been realized yet.
        """
        ...
    
    def SetSwapControl(self, p_int):
        """
        V.SetSwapControl(int) -> bool
        C++: bool SetSwapControl(int i) override;
        
        Set the number of vertical syncs required between frames. A value
        of 0 means swap buffers as quickly as possible regardless of the
        vertical refresh. A value of 1 means swap buffers in sync with
        the vertical refresh to eliminate tearing. A value of -1 means
        use a value of 1 unless we missed a frame in which case swap
        immediately. Returns true if the call succeeded.
        """
        ...
    
    def SetWindowId(self, void):
        """
        V.SetWindowId(void)
        C++: void SetWindowId(void *) override;
        
        Set this RenderWindow's X window id to a pre-existing window.
        """
        ...
    
    def SetWindowInfo(self, string):
        """
        V.SetWindowInfo(string)
        C++: void SetWindowInfo(const char *info) override;
        
        Set this RenderWindow's X window id to a pre-existing window.
        """
        ...
    
    def SetWindowName(self, string):
        """
        V.SetWindowName(string)
        C++: void SetWindowName(const char *) override;
        
        Set name of rendering window.
        """
        ...
    
    def ShowCursor(self):
        """
        V.ShowCursor()
        C++: void ShowCursor() override;
        
        Hide or Show the mouse cursor, it is nice to be able to hide the
        default cursor if you want VTK to display a 3D cursor instead.
        """
        ...
    
    def Start(self):
        """
        V.Start()
        C++: void Start() override;
        
        Begin the rendering process.
        """
        ...
    
    def WindowInitialize(self):
        """
        V.WindowInitialize()
        C++: virtual void WindowInitialize()
        
        Initialize the window for rendering.
        """
        ...
    
    def WindowRemap(self):
        """
        V.WindowRemap()
        C++: void WindowRemap() override;
        
        Resize the window.
        """
        ...
    
    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__ = ...


