# encoding: utf-8
# module wx._adv
# from D:\project\A_Board\.venv\Lib\site-packages\wx\_adv.cp313-win_amd64.pyd
# by generator 1.147
# no doc

# imports
import sip as __sip
import wx._core as __wx__core


class PseudoDC(__wx__core.Object):
    """
    PseudoDC() -> None
    
    A PseudoDC is an object that can be used much like real
    :class:`wx.DC`, however it provides some additional features for
    object recording and manipulation beyond what a ``wx.DC`` can
    provide.
    
    All commands issued to the ``PseudoDC`` are stored in a list.  You
    can then play these commands back to a real DC object as often as
    needed, using the :meth:`DrawToDC` method or one of the similar
    methods.  Commands in the command list can be tagged by an ID. You
    can use this ID to clear the operations associated with a single
    ID, redraw the objects associated with that ID, grey them, adjust
    their position, etc.
    """
    def Clear(self): # real signature unknown; restored from __doc__
        """
        Clear() -> None
        
        Clears the device context using the current background brush.
        """
        pass

    def ClearId(self, id): # real signature unknown; restored from __doc__
        """
        ClearId(id) -> None
        
        Removes all operations associated with id so the object can be
        redrawn.
        """
        pass

    def CrossHair(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        CrossHair(x, y) -> None
        CrossHair(pt) -> None
        
        Displays a cross hair using the current pen. This is a
        vertical and horizontal line the height and width of the
        window, centred on the given point.
        """
        pass

    def DrawArc(self, x1, y1, x2, y2, xc, yc): # real signature unknown; restored from __doc__
        """
        DrawArc(x1, y1, x2, y2, xc, yc) -> None
        
        Draws an arc of a circle, centred on the *center* point
        (xc, yc), from the first point to the second. The current
        pen is used for the outline and the current brush for
        filling the shape.
        
        The arc is drawn in an anticlockwise direction from the
        start point to the end point.
        """
        pass

    def DrawBitmap(self, bmp, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawBitmap(bmp, x, y, useMask=False) -> None
        DrawBitmap(bmp, pt, useMask=False) -> None
        
        Draw a bitmap on the device context at the specified
        point. If *useMask* is true and the bitmap has a
        transparency mask, (or alpha channel on the platforms that
        support it) then the bitmap will be drawn transparently.
        
        When drawing a mono-bitmap, the current text foreground
        colour will be used to draw the foreground of the bitmap
        (all bits set to 1), and the current text background
        colour to draw the background (all bits set to 0).
        
        :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC`
        """
        pass

    def DrawCheckMark(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawCheckMark(x, y, width, height) -> None
        DrawCheckMark(rect) -> None
        
        Draws a check mark inside the given rectangle
        """
        pass

    def DrawCircle(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawCircle(x, y, radius) -> None
        DrawCircle(pt, radius) -> None
        
        Draws a circle with the given center point and radius.
        The current pen is used for the outline and the current
        brush for filling the shape.
        
        :see: `DrawEllipse`
        """
        pass

    def DrawEllipse(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawEllipse(x, y, width, height) -> None
        DrawEllipse(rect) -> None
        DrawEllipse(pt, sz) -> None
        
        Draws an ellipse contained in the specified rectangle. The current pen
        is used for the outline and the current brush for filling the shape.",
        "
        
        :see: `DrawCircle`
        """
        pass

    def DrawEllipticArc(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawEllipticArc(x, y, w, h, start, end) -> None
        DrawEllipticArc(pt, sz, start, end) -> None
        
        Draws an arc of an ellipse, with the given rectangle
        defining the bounds of the ellipse. The current pen is
        used for drawing the arc and the current brush is used for
        drawing the pie.
        
        The *start* and *end* parameters specify the start and end
        of the arc relative to the three-o'clock position from the
        center of the rectangle. Angles are specified in degrees
        (360 is a complete circle). Positive values mean
        counter-clockwise motion. If start is equal to end, a
        complete ellipse will be drawn.
        """
        pass

    def DrawIcon(self, icon, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawIcon(icon, x, y) -> None
        DrawIcon(icon, pt) -> None
        
        Draw an icon on the display at the given position.
        """
        pass

    def DrawIdToDC(self, id, dc): # real signature unknown; restored from __doc__
        """
        DrawIdToDC(id, dc) -> None
        
        Draw recorded operations tagged with id to dc.
        """
        pass

    def DrawLabel(self, text, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawLabel(text, rect, alignment=wx.ALIGN_LEFT|wx.ALIGN_TOP, indexAccel=-1) -> None
        DrawLabel(text, image, rect, alignment=wx.ALIGN_LEFT|wx.ALIGN_TOP, indexAccel=-1) -> None
        
        Draw *text* within the specified rectangle, abiding by the
        alignment flags.  Will additionally emphasize the
        character at *indexAccel* if it is not -1.
        """
        pass

    def DrawLine(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawLine(x1, y1, x2, y2) -> None
        DrawLine(pt1, pt2) -> None
        
        Draws a line from the first point to the second.
        The current pen is used for drawing the line. Note that
        the second point is *not* part of the line and is not
        drawn by this function (this is consistent with the
        behaviour of many other toolkits).
        """
        pass

    def DrawLines(self, points, xoffset=0, yoffset=0): # real signature unknown; restored from __doc__
        """
        DrawLines(points, xoffset=0, yoffset=0) -> None
        
        Draws lines using a sequence of `wx.Point` objects, adding the
        optional offset coordinate. The current pen is used for drawing the
        lines.
        """
        pass

    def DrawPoint(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawPoint(x, y) -> None
        DrawPoint(pt) -> None
        
        Draws a point using the current pen.
        """
        pass

    def DrawPolygon(self, points, xoffset=0, yoffset=0, fillStyle=None): # real signature unknown; restored from __doc__
        """
        DrawPolygon(points, xoffset=0, yoffset=0, fillStyle=wx.ODDEVEN_RULE) -> None
        
        Draws a filled polygon using a sequence of `wx.Point` objects, adding
        the optional offset coordinate.  The last argument specifies the fill
        rule: ``wx.ODDEVEN_RULE`` (the default) or ``wx.WINDING_RULE``.
        
        The current pen is used for drawing the outline, and the current brush
        for filling the shape. Using a transparent brush suppresses
        filling. Note that wxWidgets automatically closes the first and last
        points.
        """
        pass

    def DrawRectangle(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawRectangle(x, y, width, height) -> None
        DrawRectangle(rect) -> None
        DrawRectangle(pt, sz) -> None
        
        Draws a rectangle with the given top left corner, and with
        the given size. The current pen is used for the outline
        and the current brush for filling the shape.
        """
        pass

    def DrawRotatedText(self, text, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawRotatedText(text, x, y, angle) -> None
        DrawRotatedText(text, pt, angle) -> None
        
        Draws the text rotated by *angle* degrees, if supported by the
        platform.
        """
        pass

    def DrawRoundedRectangle(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawRoundedRectangle(x, y, width, height, radius) -> None
        DrawRoundedRectangle(rect, radius) -> None
        DrawRoundedRectangle(pt, sz, radius) -> None
        
        Draws a rectangle with the given top left corner, and with
        the given size. The current pen is used for the outline
        and the current brush for filling the shape.
        """
        pass

    def DrawSpline(self, points): # real signature unknown; restored from __doc__
        """
        DrawSpline(points) -> None
        
        Draws a spline between all given control points, (a list of `wx.Point`
        objects) using the current pen. The spline is drawn using a series of
        lines, using an algorithm taken from the X drawing program 'XFIG'.
        """
        pass

    def DrawText(self, text, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        DrawText(text, x, y) -> None
        DrawText(text, pt) -> None
        
        Draws a text string at the specified point, using the
        current text font, and the current text foreground and
        background colours.
        
        The coordinates refer to the top-left corner of the
        rectangle bounding the string. See `wx.DC.GetTextExtent`
        for how to get the dimensions of a text string, which can
        be used to position the text more precisely, (you will
        need to use a real DC with GetTextExtent as wx.PseudoDC
        does not implement it.)
        
        **NOTE**: under wxGTK the current logical function is used
        *by this function but it is ignored by wxMSW. Thus, you
        *should avoid using logical functions with this function
        *in portable programs.", "
        
        :see: `DrawRotatedText`
        """
        pass

    def DrawToDC(self, dc): # real signature unknown; restored from __doc__
        """
        DrawToDC(dc) -> None
        
        Draws the recorded operations to dc.
        """
        pass

    def DrawToDCClipped(self, dc, rect): # real signature unknown; restored from __doc__
        """
        DrawToDCClipped(dc, rect) -> None
        
        Draws the recorded operations to dc,
        unless the operation is known to be outside of rect.
        """
        pass

    def DrawToDCClippedRgn(self, dc, region): # real signature unknown; restored from __doc__
        """
        DrawToDCClippedRgn(dc, region) -> None
        
        Draws the recorded operations to dc,
        unless the operation is known to be outside the given region.
        """
        pass

    def FindObjects(self, x, y, radius=1, bg=None): # real signature unknown; restored from __doc__
        """
        FindObjects(x, y, radius=1, bg=wx.WHITE) -> Any
        
        Returns a list of all the id's that draw a pixel with
        color not equal to bg within radius of (x,y). Returns an
        empty list if nothing is found.  The list is in reverse
        drawing order so list[0] is the top id.
        """
        pass

    def FindObjectsByBBox(self, x, y): # real signature unknown; restored from __doc__
        """
        FindObjectsByBBox(x, y) -> Any
        
        Returns a list of all the id's whose bounding boxes include (x,y).
        Returns an empty list if nothing is found.  The list is in
        reverse drawing order so list[0] is the top id.
        """
        pass

    def FloodFill(self, *__args): # real signature unknown; restored from __doc__ with multiple overloads
        """
        FloodFill(x, y, col, style=wx.FLOOD_SURFACE) -> None
        FloodFill(pt, col, style=wx.FLOOD_SURFACE) -> None
        
        Flood fills the device context starting from the given point,
        using the current brush colour, and using a style:
        
            - ``wx.FLOOD_SURFACE``: the flooding occurs until a colour other
        than the given colour is encountered.
        
            - ``wx.FLOOD_BORDER``: the area to be flooded is bounded by the
        given colour.
        """
        pass

    def GetIdBounds(self, id): # real signature unknown; restored from __doc__
        """
        GetIdBounds(id) -> wx.Rect
        
        Returns the bounding rectangle previously set with `SetIdBounds`.
        If no bounds have been set, it returns wx.Rect(0,0,0,0).
        """
        pass

    def GetIdGreyedOut(self, id): # real signature unknown; restored from __doc__
        """
        GetIdGreyedOut(id) -> bool
        
        Get whether the set of objects with tag `id` are drawn greyed out or
        not.
        """
        return False

    def GetLen(self): # real signature unknown; restored from __doc__
        """
        GetLen() -> int
        
        Returns the number of operations in the recorded list.
        """
        return 0

    def RemoveAll(self): # real signature unknown; restored from __doc__
        """
        RemoveAll() -> None
        
        Removes all objects and operations from the recorded list.
        """
        pass

    def RemoveId(self, id): # real signature unknown; restored from __doc__
        """
        RemoveId(id) -> None
        
        Remove the object node (and all operations) associated with an id.
        """
        pass

    def SetBackground(self, brush): # real signature unknown; restored from __doc__
        """
        SetBackground(brush) -> None
        
        Sets the current background brush for the DC.
        """
        pass

    def SetBackgroundMode(self, mode): # real signature unknown; restored from __doc__
        """
        SetBackgroundMode(mode) -> None
        
        The *mode* parameter may be one of ``wx.SOLID`` and
        ``wx.TRANSPARENT``. This setting determines whether text
        will be drawn with a background colour or not.
        """
        pass

    def SetBrush(self, brush): # real signature unknown; restored from __doc__
        """
        SetBrush(brush) -> None
        
        Sets the current brush for the DC.
        
        If the argument is ``wx.NullBrush``, the current brush is selected out
        of the device context, and the original brush restored, allowing the
        current brush to be destroyed safely.
        
        :see: `wx.Brush`
        """
        pass

    def SetFont(self, font): # real signature unknown; restored from __doc__
        """
        SetFont(font) -> None
        
        Sets the current font for the DC. It must be a valid font, in
        particular you should not pass ``wx.NullFont`` to this method.
        
        :see: `wx.Font`
        """
        pass

    def SetId(self, id): # real signature unknown; restored from __doc__
        """
        SetId(id) -> None
        
        Sets the id to be associated with subsequent operations.
        """
        pass

    def SetIdBounds(self, id, rect): # real signature unknown; restored from __doc__
        """
        SetIdBounds(id, rect) -> None
        
        Set the bounding rect of a given object.
        This will create an object node if one doesn't exist.
        """
        pass

    def SetIdGreyedOut(self, id, greyout): # real signature unknown; restored from __doc__
        """
        SetIdGreyedOut(id, greyout) -> None
        
        Set whether the set of objects with tag `id` are drawn greyed out or
        not.
        """
        pass

    def SetLogicalFunction(self, function): # real signature unknown; restored from __doc__
        """
        SetLogicalFunction(function) -> None
        
        Sets the current logical function for the device context. This
        determines how a source pixel (from a pen or brush colour, combines
        with a destination pixel in the current device context.
        
        The possible values and their meaning in terms of source and
        destination pixel values are defined in the
        :ref:`wx.RasterOperationMode`
        enumeration.
        
        The default is wx.COPY, which simply draws with the current
        colour. The others combine the current colour and the background using
        a logical operation. wx.INVERT is commonly used for drawing rubber
        bands or moving outlines, since drawing twice reverts to the original
        colour.
        """
        pass

    def SetPen(self, pen): # real signature unknown; restored from __doc__
        """
        SetPen(pen) -> None
        
        Sets the current pen for the DC.
        
        If the argument is ``wx.NullPen``, the current pen is selected out of
        the
        device context, and the original pen restored.
        
        :see: `wx.Pen`
        """
        pass

    def SetTextBackground(self, colour): # real signature unknown; restored from __doc__
        """
        SetTextBackground(colour) -> None
        
        Sets the current text background colour for the DC.
        """
        pass

    def SetTextForeground(self, colour): # real signature unknown; restored from __doc__
        """
        SetTextForeground(colour) -> None
        
        Sets the current text foreground colour for the DC.
        """
        pass

    def TranslateId(self, id, dx, dy): # real signature unknown; restored from __doc__
        """
        TranslateId(id, dx, dy) -> None
        
        Translate the position of the operations of tag `id` by (`dx`, `dy`).
        """
        pass

    def __init__(self): # real signature unknown; restored from __doc__
        pass

    Len = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """GetLen() -> int

Returns the number of operations in the recorded list."""