# encoding: utf-8
# module vtkmodules.vtkCommonDataModel
# from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonDataModel.cp311-win_amd64.pyd
# by generator 1.147
# no doc

# imports
import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore
import vtkmodules.vtkCommonMath as __vtkmodules_vtkCommonMath
import vtkmodules.vtkCommonTransforms as __vtkmodules_vtkCommonTransforms


from .vtkVector_IfLi4EE import vtkVector_IfLi4EE

class vtkRect_IfE(vtkVector_IfLi4EE):
    """
    vtkRect() -> vtkRect
    C++: vtkRect()
    vtkRect(x:float, y:float, width:float, height:float) -> vtkRect
    C++: vtkRect(const float &x, const float &y, const float &width,
        const float &height)
    vtkRect(init:(float, float, float, float)) -> vtkRect
    C++: explicit vtkRect(const float *init)
    vtkRect(__a:vtkRect_IfE) -> vtkRect
    C++: vtkRect(const &vtkRect<float>)
    
    vtkRect- templated base type for storage of 2D rectangles.
    
    Superclass: vtkVector[float32,4]
    
    This class is a templated data type for storing and manipulating
    rectangles. The memory layout is a contiguous array of the specified
    type, such that a float[4] can be cast to a vtkRectf and manipulated.
    Also a float[12] could be cast and used as a vtkRectf[3].
    """
    def AddPoint(self, point, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        AddPoint(self, point:(float, float)) -> None
        C++: void AddPoint(const float point[2])
        AddPoint(self, x:float, y:float) -> None
        C++: void AddPoint(float x, float y)
        
        Expand this rect to contain the point passed in.
        """
        pass

    def AddRect(self, rect): # real signature unknown; restored from __doc__
        """
        AddRect(self, rect:vtkRect_IfE) -> None
        C++: void AddRect(const vtkRect<float> &rect)
        
        Expand this rect to contain the rect passed in.
        """
        pass

    def GetBottom(self): # real signature unknown; restored from __doc__
        """
        GetBottom(self) -> float
        C++: const float &GetBottom()
        
        Get the bottom boundary of the rectangle along the Y direction.
        """
        return 0.0

    def GetBottomLeft(self): # real signature unknown; restored from __doc__
        """
        GetBottomLeft(self) -> vtkVector2_IfE
        C++: vtkVector2<float> GetBottomLeft()
        
        Get the bottom left corner of the rect as a vtkVector.
        """
        return vtkVector2_IfE

    def GetBottomRight(self): # real signature unknown; restored from __doc__
        """
        GetBottomRight(self) -> vtkVector_IfLi2EE
        C++: vtkVector<float, 2> GetBottomRight()
        
        Get the bottom right corner of the rect as a vtkVector.
        """
        return vtkVector_IfLi2EE

    def GetCenter(self): # real signature unknown; restored from __doc__
        """
        GetCenter(self) -> vtkVector2d
        C++: vtkVector2d GetCenter()
        
        Returns the center of the rect as a vtkVector2d.
        """
        return vtkVector2d

    def GetHeight(self): # real signature unknown; restored from __doc__
        """
        GetHeight(self) -> float
        C++: const float &GetHeight()
        
        Get the height of the rectangle, i.e. element 3.
        """
        return 0.0

    def GetLeft(self): # real signature unknown; restored from __doc__
        """
        GetLeft(self) -> float
        C++: const float &GetLeft()
        
        Get the left boundary of the rectangle along the X direction.
        """
        return 0.0

    def GetRight(self): # real signature unknown; restored from __doc__
        """
        GetRight(self) -> float
        C++: float GetRight()
        
        Get the right boundary of the rectangle along the X direction.
        """
        return 0.0

    def GetTop(self): # real signature unknown; restored from __doc__
        """
        GetTop(self) -> float
        C++: float GetTop()
        
        Get the top boundary of the rectangle along the Y direction.
        """
        return 0.0

    def GetTopLeft(self): # real signature unknown; restored from __doc__
        """
        GetTopLeft(self) -> vtkVector_IfLi2EE
        C++: vtkVector<float, 2> GetTopLeft()
        
        Get the top left corner of the rect as a vtkVector.
        """
        return vtkVector_IfLi2EE

    def GetTopRight(self): # real signature unknown; restored from __doc__
        """
        GetTopRight(self) -> vtkVector_IfLi2EE
        C++: vtkVector<float, 2> GetTopRight()
        
        Get the bottom left corner of the rect as a vtkVector.
        """
        return vtkVector_IfLi2EE

    def GetWidth(self): # real signature unknown; restored from __doc__
        """
        GetWidth(self) -> float
        C++: const float &GetWidth()
        
        Get the width of the rectangle, i.e. element 2.
        """
        return 0.0

    def GetX(self): # real signature unknown; restored from __doc__
        """
        GetX(self) -> float
        C++: const float &GetX()
        
        Get the x component of the rectangle bottom corner, i.e. element
        0.
        """
        return 0.0

    def GetY(self): # real signature unknown; restored from __doc__
        """
        GetY(self) -> float
        C++: const float &GetY()
        
        Get the y component of the rectangle bottom corner, i.e. element
        1.
        """
        return 0.0

    def Intersect(self, other): # real signature unknown; restored from __doc__
        """
        Intersect(self, other:vtkRect_IfE) -> bool
        C++: bool Intersect(const vtkRect<float> &other)
        
        Intersect with `other` rectangle. If
        `this->IntersectsWith(other)` is true, this method will update
        this rect to the intersection of `this` and `other` and return
        true. If `this->IntersectsWith(other)` returns false, then this
        method will return false leaving this rect unchanged.
        
        Returns true if the intersection was performed otherwise false.
        """
        return False

    def IntersectsWith(self, rect): # real signature unknown; restored from __doc__
        """
        IntersectsWith(self, rect:vtkRect_IfE) -> bool
        C++: bool IntersectsWith(const vtkRect<float> &rect)
        
        Returns true if the rect argument overlaps this rect. If the
        upper bound of one rect is equal to the lower bound of the other
        rect, then this will return false (in that case, the rects would
        be considered to be adjacent but not overlapping).
        """
        return False

    def MoveTo(self, x, y): # real signature unknown; restored from __doc__
        """
        MoveTo(self, x:float, y:float) -> None
        C++: void MoveTo(float x, float y)
        
        Move the rectangle, moving the bottom-left corner to the given
        position. The rectangles size remains unchanged.
        """
        pass

    def Set(self, x, y, width, height): # real signature unknown; restored from __doc__
        """
        Set(self, x:float, y:float, width:float, height:float) -> None
        C++: void Set(const float &x, const float &y, const float &width,
            const float &height)
        
        Set the x, y components of the rectangle, and the width/height.
        """
        pass

    def SetHeight(self, height): # real signature unknown; restored from __doc__
        """
        SetHeight(self, height:float) -> None
        C++: void SetHeight(const float &height)
        
        Set the height of the rectangle, i.e. element 3.
        """
        pass

    def SetWidth(self, width): # real signature unknown; restored from __doc__
        """
        SetWidth(self, width:float) -> None
        C++: void SetWidth(const float &width)
        
        Set the width of the rectanle, i.e. element 2.
        """
        pass

    def SetX(self, x): # real signature unknown; restored from __doc__
        """
        SetX(self, x:float) -> None
        C++: void SetX(const float &x)
        
        Set the x component of the rectangle bottom corner, i.e. element
        0.
        """
        pass

    def SetY(self, y): # real signature unknown; restored from __doc__
        """
        SetY(self, y:float) -> None
        C++: void SetY(const float &y)
        
        Set the y component of the rectangle bottom corner, i.e. element
        1.
        """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        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