aioxlib 0.0.6__tar.gz → 0.0.7__tar.gz

{aioxlib-0.0.6 → aioxlib-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioxlib
-Version: 0.0.6
+Version: 0.0.7
 Summary: Human friendly interface to XLib subsystems using asyncio python
 Author-email: Jose Tiago Macara Coutinho <coutinhotiago@gmail.com>
 License-Expression: GPL-3.0-or-later

{aioxlib-0.0.6 → aioxlib-0.0.7}/aioxlib/__init__.py

@@ -4,7 +4,7 @@
 # Copyright (c) 2026 Tiago Coutinho
 # Distributed under the GPLv3 license. See LICENSE for more info.
 
-__version__ = "0.0.6"
+__version__ = "0.0.7"
 
 import asyncio
 import enum
@@ -3771,6 +3771,992 @@ class Present(Extension):
         return await self.display.write_read(payload, unpack_present_query_capabilities)
 
 
+# ---------------------------------------------------------------------------
+# RENDER extension (X Rendering Extension)
+# ---------------------------------------------------------------------------
+
+
+class RenderCommand(enum.IntEnum):
+    QueryVersion = 0
+    QueryPictFormats = 1
+    QueryPictIndexValues = 2
+    QueryDithers = 3
+    CreatePicture = 4
+    ChangePicture = 5
+    SetPictureClipRectangles = 6
+    FreePicture = 7
+    Composite = 8
+    Scale = 9
+    Trapezoids = 10
+    Triangles = 11
+    TriStrip = 12
+    TriFan = 13
+    ColorTrapezoids = 14
+    ColorTriangles = 15
+    CreateGlyphSet = 17
+    ReferenceGlyphSet = 18
+    FreeGlyphSet = 19
+    AddGlyphs = 20
+    AddGlyphsFromPicture = 21
+    FreeGlyphs = 22
+    CompositeGlyphs8 = 23
+    CompositeGlyphs16 = 24
+    CompositeGlyphs32 = 25
+    FillRectangles = 26
+    CreateCursor = 27
+    SetPictureTransform = 28
+    QueryFilters = 29
+    SetPictureFilter = 30
+    CreateAnimCursor = 31
+    AddTraps = 32
+    CreateSolidFill = 33
+    CreateLinearGradient = 34
+    CreateRadialGradient = 35
+    CreateConicalGradient = 36
+
+
+class PictType(enum.IntEnum):
+    Indexed = 0
+    Direct = 1
+
+
+class PictOp(enum.IntEnum):
+    """Porter-Duff / blend operators for Composite and FillRectangles."""
+
+    Clear = 0
+    Src = 1
+    Dst = 2
+    Over = 3
+    OverReverse = 4
+    In = 5
+    InReverse = 6
+    Out = 7
+    OutReverse = 8
+    Atop = 9
+    AtopReverse = 10
+    Xor = 11
+    Add = 12
+    Saturate = 13
+    # Disjoint (0.2+)
+    DisjointClear = 0x10
+    DisjointSrc = 0x11
+    DisjointDst = 0x12
+    DisjointOver = 0x13
+    DisjointOverReverse = 0x14
+    DisjointIn = 0x15
+    DisjointInReverse = 0x16
+    DisjointOut = 0x17
+    DisjointOutReverse = 0x18
+    DisjointAtop = 0x19
+    DisjointAtopReverse = 0x1A
+    DisjointXor = 0x1B
+    # Conjoint (0.2+)
+    ConjointClear = 0x20
+    ConjointSrc = 0x21
+    ConjointDst = 0x22
+    ConjointOver = 0x23
+    ConjointOverReverse = 0x24
+    ConjointIn = 0x25
+    ConjointInReverse = 0x26
+    ConjointOut = 0x27
+    ConjointOutReverse = 0x28
+    ConjointAtop = 0x29
+    ConjointAtopReverse = 0x2A
+    ConjointXor = 0x2B
+    # Blend (0.11+)
+    Multiply = 0x30
+    Screen = 0x31
+    Overlay = 0x32
+    Darken = 0x33
+    Lighten = 0x34
+    ColorDodge = 0x35
+    ColorBurn = 0x36
+    HardLight = 0x37
+    SoftLight = 0x38
+    Difference = 0x39
+    Exclusion = 0x3A
+    HSLHue = 0x3B
+    HSLSaturation = 0x3C
+    HSLColor = 0x3D
+    HSLLuminosity = 0x3E
+
+
+class PictureAttributes(enum.IntFlag):
+    Repeat = 1 << 0
+    AlphaMap = 1 << 1
+    AlphaXOrigin = 1 << 2
+    AlphaYOrigin = 1 << 3
+    ClipXOrigin = 1 << 4
+    ClipYOrigin = 1 << 5
+    ClipMask = 1 << 6
+    GraphicsExposures = 1 << 7
+    SubwindowMode = 1 << 8
+    PolyEdge = 1 << 9
+    PolyMode = 1 << 10
+    Dither = 1 << 11
+    ComponentAlpha = 1 << 12
+
+
+PICTURE_ATTR_ORDER = (
+    ("repeat", PictureAttributes.Repeat),
+    ("alpha_map", PictureAttributes.AlphaMap),
+    ("alpha_x_origin", PictureAttributes.AlphaXOrigin),
+    ("alpha_y_origin", PictureAttributes.AlphaYOrigin),
+    ("clip_x_origin", PictureAttributes.ClipXOrigin),
+    ("clip_y_origin", PictureAttributes.ClipYOrigin),
+    ("clip_mask", PictureAttributes.ClipMask),
+    ("graphics_exposures", PictureAttributes.GraphicsExposures),
+    ("subwindow_mode", PictureAttributes.SubwindowMode),
+    ("poly_edge", PictureAttributes.PolyEdge),
+    ("poly_mode", PictureAttributes.PolyMode),
+    ("dither", PictureAttributes.Dither),
+    ("component_alpha", PictureAttributes.ComponentAlpha),
+)
+
+
+class PolyEdge(enum.IntEnum):
+    Sharp = 0
+    Smooth = 1
+
+
+class PolyMode(enum.IntEnum):
+    Precise = 0
+    Imprecise = 1
+
+
+class SubPixel(enum.IntEnum):
+    Unknown = 0
+    HorizontalRGB = 1
+    HorizontalBGR = 2
+    VerticalRGB = 3
+    VerticalBGR = 4
+    None_ = 5
+
+
+class Repeat(enum.IntEnum):
+    None_ = 0
+    Normal = 1
+    Pad = 2
+    Reflect = 3
+
+
+def fixed(value) -> int:
+    """Convert a float (or int) to X Fixed (16.16 signed)."""
+    if isinstance(value, int) and not isinstance(value, bool):
+        # already fixed or integer pixels → treat bare ints as fixed when |v| is large?
+        # Convention: ints are whole numbers in fixed form (value << 16) unless already Fixed.
+        return int(value) << 16
+    return int(round(float(value) * 65536.0))
+
+
+def fixed_to_float(v: int) -> float:
+    return int(v) / 65536.0
+
+
+def pack_render_color(r, g, b, a=1.0):
+    """Pack an xRenderColor from 0..1 floats or 0..0xffff ints."""
+
+    def _chan(c):
+        if isinstance(c, float):
+            return max(0, min(0xFFFF, int(round(c * 0xFFFF))))
+        return max(0, min(0xFFFF, int(c)))
+
+    return struct.pack("HHHH", _chan(r), _chan(g), _chan(b), _chan(a))
+
+
+def _picture_values(**attrs):
+    mask = PictureAttributes(0)
+    values = []
+    for name, bit in PICTURE_ATTR_ORDER:
+        if (val := attrs.get(name)) is None:
+            continue
+        mask |= bit
+        values.append(val)
+    return mask, values
+
+
+def pack_render_query_version(opcode, major=0, minor=11):
+    return struct.pack(
+        "BBHII",
+        opcode,
+        RenderCommand.QueryVersion,
+        3,
+        major,
+        minor,
+    )
+
+
+def unpack_render_query_version(data, offset=0):
+    result, offset = unpack_reply_head(data, offset)
+    major, minor = struct.unpack_from("II", data, offset)
+    offset += 8 + 16
+    result["major_version"] = major
+    result["minor_version"] = minor
+    return result, offset
+
+
+def pack_render_query_pict_formats(opcode):
+    return struct.pack("BBH", opcode, RenderCommand.QueryPictFormats, 1)
+
+
+def unpack_render_query_pict_formats(data, offset=0):
+    result, offset = unpack_reply_head(data, offset)
+    (
+        num_formats,
+        num_screens,
+        num_depths,
+        num_visuals,
+        num_subpixel,
+    ) = struct.unpack_from("5I", data, offset)
+    offset += 20 + 4  # 5I + pad
+
+    formats = []
+    for _ in range(num_formats):
+        (
+            fid,
+            ftype,
+            depth,
+            red,
+            red_mask,
+            green,
+            green_mask,
+            blue,
+            blue_mask,
+            alpha,
+            alpha_mask,
+            colormap,
+        ) = struct.unpack_from("IBB2x8HI", data, offset)
+        offset += 28
+        formats.append(
+            {
+                "id": fid,
+                "type": PictType(ftype),
+                "depth": depth,
+                "direct": {
+                    "red": red,
+                    "red_mask": red_mask,
+                    "green": green,
+                    "green_mask": green_mask,
+                    "blue": blue,
+                    "blue_mask": blue_mask,
+                    "alpha": alpha,
+                    "alpha_mask": alpha_mask,
+                },
+                "colormap": colormap,
+            }
+        )
+
+    # screens: each has nDepth + fallback, then depths follow contiguously
+    screens = []
+    depth_headers = []
+    for _ in range(num_screens):
+        n_depth, fallback = struct.unpack_from("II", data, offset)
+        offset += 8
+        screens.append({"fallback": fallback, "n_depth": n_depth, "depths": []})
+        depth_headers.append(n_depth)
+
+    depths = []
+    for _ in range(num_depths):
+        depth, n_visuals = struct.unpack_from("BxH4x", data, offset)
+        offset += 8
+        depths.append({"depth": depth, "n_visuals": n_visuals, "visuals": []})
+
+    visuals = []
+    for _ in range(num_visuals):
+        visual, fmt = struct.unpack_from("II", data, offset)
+        offset += 8
+        visuals.append({"visual": visual, "format": fmt})
+
+    # attach visuals → depths → screens
+    vi = 0
+    for d in depths:
+        d["visuals"] = visuals[vi : vi + d["n_visuals"]]
+        vi += d["n_visuals"]
+    di = 0
+    for s, n in zip(screens, depth_headers):
+        s["depths"] = depths[di : di + n]
+        di += n
+
+    subpixels = []
+    if num_subpixel:
+        for _ in range(num_subpixel):
+            (sp,) = struct.unpack_from("I", data, offset)
+            offset += 4
+            try:
+                subpixels.append(SubPixel(sp))
+            except ValueError:
+                subpixels.append(sp)
+        # pad to 32-bit boundary already
+
+    result["formats"] = formats
+    result["screens"] = screens
+    result["subpixels"] = subpixels
+    return result, offset
+
+
+def pack_render_create_picture(opcode, pid, drawable, format, **attrs):
+    mask, values = _picture_values(**attrs)
+    length = 5 + len(values)
+    header = struct.pack(
+        "BBHIIII",
+        opcode,
+        RenderCommand.CreatePicture,
+        length,
+        pid,
+        drawable,
+        format,
+        mask,
+    )
+    body = b"".join(struct.pack("I", v) for v in values)
+    return header + body
+
+
+def pack_render_change_picture(opcode, picture, **attrs):
+    mask, values = _picture_values(**attrs)
+    length = 3 + len(values)
+    header = struct.pack(
+        "BBHII",
+        opcode,
+        RenderCommand.ChangePicture,
+        length,
+        picture,
+        mask,
+    )
+    body = b"".join(struct.pack("I", v) for v in values)
+    return header + body
+
+
+def pack_render_set_picture_clip_rectangles(opcode, picture, x_origin, y_origin, rects):
+    """rects: sequence of (x, y, width, height)."""
+    n = len(rects)
+    length = 3 + n  # each rect is 8 bytes = 2 CARD32 units
+    header = struct.pack(
+        "BBHIhh",
+        opcode,
+        RenderCommand.SetPictureClipRectangles,
+        length,
+        picture,
+        x_origin,
+        y_origin,
+    )
+    body = b"".join(struct.pack("hhHH", *r) for r in rects)
+    return header + body
+
+
+def pack_render_free_picture(opcode, picture):
+    return struct.pack(
+        "BBHI", opcode, RenderCommand.FreePicture, 2, int(picture)
+    )
+
+
+def pack_render_composite(
+    opcode,
+    op,
+    src,
+    mask,
+    dst,
+    src_x,
+    src_y,
+    mask_x,
+    mask_y,
+    dst_x,
+    dst_y,
+    width,
+    height,
+):
+    return struct.pack(
+        "BBHBBHIII6hHH",
+        opcode,
+        RenderCommand.Composite,
+        9,
+        int(op),
+        0,
+        0,
+        src,
+        mask if mask is not None else 0,
+        dst,
+        src_x,
+        src_y,
+        mask_x,
+        mask_y,
+        dst_x,
+        dst_y,
+        width,
+        height,
+    )
+
+
+def pack_render_fill_rectangles(opcode, op, dst, color, rects):
+    """color: (r,g,b,a) floats 0..1 or ints 0..0xffff; rects: (x,y,w,h)."""
+    n = len(rects)
+    length = 5 + n * 2  # color=8 bytes=2 units; each rect=8 bytes=2 units
+    header = struct.pack(
+        "BBHBBHI",
+        opcode,
+        RenderCommand.FillRectangles,
+        length,
+        op,
+        0,
+        0,
+        dst,
+    )
+    body = pack_render_color(*color) + b"".join(
+        struct.pack("hhHH", *r) for r in rects
+    )
+    return header + body
+
+
+def pack_render_set_picture_transform(opcode, picture, matrix):
+    """matrix: 9 Fixed values (3×3 row-major) or floats."""
+    vals = [fixed(v) for v in matrix]
+    if len(vals) != 9:
+        raise ValueError("transform matrix must have 9 elements")
+    return struct.pack(
+        "BBHI9i",
+        opcode,
+        RenderCommand.SetPictureTransform,
+        11,
+        picture,
+        *vals,
+    )
+
+
+def pack_render_set_picture_filter(opcode, picture, name, values=()):
+    name_b = name.encode("latin-1") if isinstance(name, str) else bytes(name)
+    n = len(name_b)
+    pad = (4 - (n % 4)) % 4
+    nvals = len(values)
+    length = 3 + (n + pad) // 4 + nvals
+    header = struct.pack(
+        "BBHIHH",
+        opcode,
+        RenderCommand.SetPictureFilter,
+        length,
+        picture,
+        n,
+        0,
+    )
+    body = name_b + b"\0" * pad
+    body += b"".join(struct.pack("i", fixed(v)) for v in values)
+    return header + body
+
+
+def pack_render_query_filters(opcode, drawable):
+    return struct.pack(
+        "BBHI", opcode, RenderCommand.QueryFilters, 2, int(drawable)
+    )
+
+
+def unpack_render_query_filters(data, offset=0):
+    result, offset = unpack_reply_head(data, offset)
+    num_aliases, num_filters = struct.unpack_from("II", data, offset)
+    offset += 8 + 16
+    aliases = list(struct.unpack_from(f"{num_aliases}H", data, offset))
+    offset += num_aliases * 2
+    if num_aliases % 2:
+        offset += 2  # pad to 32-bit
+    filters = []
+    for _ in range(num_filters):
+        (nbytes,) = struct.unpack_from("B", data, offset)
+        offset += 1
+        name = data[offset : offset + nbytes].decode("latin-1")
+        offset += nbytes
+        filters.append(name)
+    # pad remainder of reply
+    result["aliases"] = aliases
+    result["filters"] = filters
+    return result, offset
+
+
+def pack_render_create_solid_fill(opcode, pid, color):
+    return struct.pack(
+        "BBHI",
+        opcode,
+        RenderCommand.CreateSolidFill,
+        4,
+        pid,
+    ) + pack_render_color(*color)
+
+
+def pack_render_create_linear_gradient(opcode, pid, p1, p2, stops):
+    """stops: sequence of (offset, (r,g,b,a)) with offset in 0..1."""
+    n = len(stops)
+    length = 7 + n + n * 2  # points + nStops + n Fixed + n RenderColor
+    header = struct.pack(
+        "BBHI4iI",
+        opcode,
+        RenderCommand.CreateLinearGradient,
+        length,
+        pid,
+        fixed(p1[0]),
+        fixed(p1[1]),
+        fixed(p2[0]),
+        fixed(p2[1]),
+        n,
+    )
+    body = b"".join(struct.pack("i", fixed(s[0])) for s in stops)
+    body += b"".join(pack_render_color(*s[1]) for s in stops)
+    return header + body
+
+
+def pack_render_create_radial_gradient(
+    opcode, pid, inner, outer, inner_radius, outer_radius, stops
+):
+    n = len(stops)
+    length = 9 + n + n * 2
+    header = struct.pack(
+        "BBHI4i2iI",
+        opcode,
+        RenderCommand.CreateRadialGradient,
+        length,
+        pid,
+        fixed(inner[0]),
+        fixed(inner[1]),
+        fixed(outer[0]),
+        fixed(outer[1]),
+        fixed(inner_radius),
+        fixed(outer_radius),
+        n,
+    )
+    body = b"".join(struct.pack("i", fixed(s[0])) for s in stops)
+    body += b"".join(pack_render_color(*s[1]) for s in stops)
+    return header + body
+
+
+def pack_render_create_conical_gradient(opcode, pid, center, angle, stops):
+    n = len(stops)
+    length = 6 + n + n * 2
+    header = struct.pack(
+        "BBHI2iiI",
+        opcode,
+        RenderCommand.CreateConicalGradient,
+        length,
+        pid,
+        fixed(center[0]),
+        fixed(center[1]),
+        fixed(angle),
+        n,
+    )
+    body = b"".join(struct.pack("i", fixed(s[0])) for s in stops)
+    body += b"".join(pack_render_color(*s[1]) for s in stops)
+    return header + body
+
+
+def pack_render_trapezoids(opcode, op, src, dst, mask_format, src_x, src_y, traps):
+    """traps: sequence of (top, bottom, left_p1, left_p2, right_p1, right_p2)
+    each point is (x, y); top/bottom are Fixed y values.
+    """
+    n = len(traps)
+    length = 6 + n * 10  # each trapezoid = 40 bytes = 10 units
+    header = struct.pack(
+        "BBHBBHIIIhh",
+        opcode,
+        RenderCommand.Trapezoids,
+        length,
+        op,
+        0,
+        0,
+        src,
+        dst,
+        mask_format if mask_format else 0,
+        src_x,
+        src_y,
+    )
+    body = b""
+    for top, bottom, lp1, lp2, rp1, rp2 in traps:
+        body += struct.pack(
+            "10i",
+            fixed(top),
+            fixed(bottom),
+            fixed(lp1[0]),
+            fixed(lp1[1]),
+            fixed(lp2[0]),
+            fixed(lp2[1]),
+            fixed(rp1[0]),
+            fixed(rp1[1]),
+            fixed(rp2[0]),
+            fixed(rp2[1]),
+        )
+    return header + body
+
+
+def pack_render_triangles(opcode, op, src, dst, mask_format, src_x, src_y, tris):
+    """tris: sequence of ((x1,y1),(x2,y2),(x3,y3))."""
+    n = len(tris)
+    length = 6 + n * 6
+    header = struct.pack(
+        "BBHBBHIIIhh",
+        opcode,
+        RenderCommand.Triangles,
+        length,
+        op,
+        0,
+        0,
+        src,
+        dst,
+        mask_format if mask_format else 0,
+        src_x,
+        src_y,
+    )
+    body = b""
+    for p1, p2, p3 in tris:
+        body += struct.pack(
+            "6i",
+            fixed(p1[0]),
+            fixed(p1[1]),
+            fixed(p2[0]),
+            fixed(p2[1]),
+            fixed(p3[0]),
+            fixed(p3[1]),
+        )
+    return header + body
+
+
+def pack_render_create_glyphset(opcode, gsid, format):
+    return struct.pack(
+        "BBHII",
+        opcode,
+        RenderCommand.CreateGlyphSet,
+        3,
+        gsid,
+        format,
+    )
+
+
+def pack_render_free_glyphset(opcode, gsid):
+    return struct.pack(
+        "BBHI", opcode, RenderCommand.FreeGlyphSet, 2, gsid
+    )
+
+
+def pack_render_add_glyphs(opcode, gsid, glyph_ids, glyph_infos, data):
+    """glyph_ids: list of CARD32; glyph_infos: list of (width,height,x,y,xOff,yOff);
+    data: concatenated glyph image bytes (padded per glyph to 32-bit).
+    """
+    n = len(glyph_ids)
+    if n != len(glyph_infos):
+        raise ValueError("glyph_ids and glyph_infos length mismatch")
+    info_bytes = b"".join(
+        struct.pack("HHhh hh", *info) for info in glyph_infos
+    )
+    # each GlyphInfo is 12 bytes
+    info_bytes = b"".join(
+        struct.pack("HHhhhh", w, h, x, y, xo, yo)
+        for (w, h, x, y, xo, yo) in glyph_infos
+    )
+    ids_bytes = b"".join(struct.pack("I", int(g)) for g in glyph_ids)
+    # pad image data to 32-bit
+    pad = (4 - (len(data) % 4)) % 4
+    payload = ids_bytes + info_bytes + data + b"\0" * pad
+    length = 3 + len(payload) // 4
+    header = struct.pack(
+        "BBHII",
+        opcode,
+        RenderCommand.AddGlyphs,
+        length,
+        gsid,
+        n,
+    )
+    return header + payload
+
+
+def pack_render_free_glyphs(opcode, gsid, glyph_ids):
+    n = len(glyph_ids)
+    length = 2 + n
+    header = struct.pack(
+        "BBHI", opcode, RenderCommand.FreeGlyphs, length, int(gsid)
+    )
+    body = b"".join(struct.pack("I", int(g)) for g in glyph_ids)
+    return header + body
+
+
+def pack_render_composite_glyphs8(
+    opcode, op, src, dst, mask_format, glyphset, src_x, src_y, elements
+):
+    """elements: sequence of (delta_x, delta_y, glyphs_bytes_or_str).
+
+    Each element becomes an xGlyphElt: 1-byte length + deltas + glyph 8-bit ids,
+    padded to 4 bytes.
+    """
+    body = b""
+    for dx, dy, glyphs in elements:
+        if isinstance(glyphs, str):
+            glyphs = glyphs.encode("latin-1")
+        glyphs = bytes(glyphs)
+        n = len(glyphs)
+        if n > 252:
+            raise ValueError("glyph elt too long (max 252)")
+        elt = struct.pack("BBHhh", n, 0, 0, int(dx), int(dy)) + glyphs
+        pad = (4 - (len(elt) % 4)) % 4
+        body += elt + b"\0" * pad
+    length = 7 + len(body) // 4
+    header = struct.pack(
+        "BBHBBHIIIIhh",
+        opcode,
+        RenderCommand.CompositeGlyphs8,
+        length,
+        op,
+        0,
+        0,
+        src,
+        dst,
+        mask_format if mask_format else 0,
+        glyphset,
+        src_x,
+        src_y,
+    )
+    return header + body
+
+
+class Render(Extension):
+    """X Rendering Extension (RENDER).
+
+    Alpha compositing, transforms, gradients, and glyph rendering.
+
+    Query with::
+
+        render = await display.query_extension("RENDER")
+        ver = await render.query_version()
+        formats = await render.query_pict_formats()
+    """
+
+    Commands = RenderCommand
+
+    BaseBadPictFormat = 0
+    BaseBadPicture = 1
+    BaseBadPictOp = 2
+    BaseBadGlyphSet = 3
+    BaseBadGlyph = 4
+
+    def __init__(self, display, info):
+        super().__init__(display, info)
+        base = info["base_error"]
+        self.BadPictFormat = base + self.BaseBadPictFormat
+        self.BadPicture = base + self.BaseBadPicture
+        self.BadPictOp = base + self.BaseBadPictOp
+        self.BadGlyphSet = base + self.BaseBadGlyphSet
+        self.BadGlyph = base + self.BaseBadGlyph
+        self.errors = {
+            self.BadPictFormat: "BadPictFormat",
+            self.BadPicture: "BadPicture",
+            self.BadPictOp: "BadPictOp",
+            self.BadGlyphSet: "BadGlyphSet",
+            self.BadGlyph: "BadGlyph",
+        }
+        self.commands = {self.code: "Render"}
+        self._formats = None
+
+    async def query_version(self, major=0, minor=11):
+        payload = pack_render_query_version(self.code, major, minor)
+        return await self.display.write_read(payload, unpack_render_query_version)
+
+    async def query_pict_formats(self):
+        payload = pack_render_query_pict_formats(self.code)
+        reply = await self.display.write_read(
+            payload, unpack_render_query_pict_formats
+        )
+        self._formats = reply
+        return reply
+
+    def find_standard_format(self, depth, alpha=True, formats=None):
+        """Pick a direct PictFormat id matching *depth* (and optional alpha).
+
+        Common choices: depth=32 (ARGB), depth=24 (RGB), depth=8 (A).
+        """
+        formats = formats or (self._formats or {}).get("formats") or []
+        best = None
+        for f in formats:
+            if f["type"] != PictType.Direct or f["depth"] != depth:
+                continue
+            d = f["direct"]
+            has_alpha = d["alpha_mask"] != 0
+            if alpha and not has_alpha:
+                continue
+            if not alpha and has_alpha and depth != 8:
+                # prefer non-alpha when requested for 24-bit
+                continue
+            best = f["id"]
+            if alpha == has_alpha:
+                return best
+        return best
+
+    async def create_picture(self, drawable, format, pid=None, **attrs):
+        """Create a Picture for *drawable* using PictFormat *format*."""
+        if pid is None:
+            pid = self.display.resources.allocate()
+        payload = pack_render_create_picture(
+            self.code, pid, drawable, format, **attrs
+        )
+        self.display.write(payload)
+        return pid
+
+    async def change_picture(self, picture, **attrs):
+        payload = pack_render_change_picture(self.code, picture, **attrs)
+        self.display.write(payload)
+
+    async def set_clip_rectangles(self, picture, x_origin, y_origin, rects):
+        payload = pack_render_set_picture_clip_rectangles(
+            self.code, picture, x_origin, y_origin, rects
+        )
+        self.display.write(payload)
+
+    async def free_picture(self, picture):
+        self.display.write(pack_render_free_picture(self.code, picture))
+
+    async def composite(
+        self,
+        op,
+        src,
+        dst,
+        dst_x,
+        dst_y,
+        width,
+        height,
+        src_x=0,
+        src_y=0,
+        mask=None,
+        mask_x=0,
+        mask_y=0,
+    ):
+        payload = pack_render_composite(
+            self.code,
+            op,
+            src,
+            mask,
+            dst,
+            src_x,
+            src_y,
+            mask_x,
+            mask_y,
+            dst_x,
+            dst_y,
+            width,
+            height,
+        )
+        self.display.write(payload)
+
+    async def fill_rectangles(self, op, dst, color, rects):
+        """Fill *rects* on *dst* with solid *color* using operator *op*.
+
+        *color* is ``(r, g, b, a)`` with channels in 0..1 (float) or 0..65535.
+        *rects* is a sequence of ``(x, y, width, height)``.
+        """
+        payload = pack_render_fill_rectangles(self.code, op, dst, color, rects)
+        self.display.write(payload)
+
+    async def set_transform(self, picture, matrix):
+        """Set a 3×3 projective transform (9 floats or Fixed)."""
+        payload = pack_render_set_picture_transform(self.code, picture, matrix)
+        self.display.write(payload)
+
+    async def set_filter(self, picture, name, values=()):
+        """Set filter name (e.g. ``\"bilinear\"``, ``\"nearest\"``) and params."""
+        payload = pack_render_set_picture_filter(
+            self.code, picture, name, values
+        )
+        self.display.write(payload)
+
+    async def query_filters(self, drawable):
+        payload = pack_render_query_filters(self.code, drawable)
+        return await self.display.write_read(payload, unpack_render_query_filters)
+
+    async def create_solid_fill(self, color, pid=None):
+        if pid is None:
+            pid = self.display.resources.allocate()
+        payload = pack_render_create_solid_fill(self.code, pid, color)
+        self.display.write(payload)
+        return pid
+
+    async def create_linear_gradient(self, p1, p2, stops, pid=None):
+        if pid is None:
+            pid = self.display.resources.allocate()
+        payload = pack_render_create_linear_gradient(
+            self.code, pid, p1, p2, stops
+        )
+        self.display.write(payload)
+        return pid
+
+    async def create_radial_gradient(
+        self, inner, outer, inner_radius, outer_radius, stops, pid=None
+    ):
+        if pid is None:
+            pid = self.display.resources.allocate()
+        payload = pack_render_create_radial_gradient(
+            self.code, pid, inner, outer, inner_radius, outer_radius, stops
+        )
+        self.display.write(payload)
+        return pid
+
+    async def create_conical_gradient(self, center, angle, stops, pid=None):
+        if pid is None:
+            pid = self.display.resources.allocate()
+        payload = pack_render_create_conical_gradient(
+            self.code, pid, center, angle, stops
+        )
+        self.display.write(payload)
+        return pid
+
+    async def trapezoids(
+        self, op, src, dst, src_x, src_y, traps, mask_format=0
+    ):
+        payload = pack_render_trapezoids(
+            self.code, op, src, dst, mask_format, src_x, src_y, traps
+        )
+        self.display.write(payload)
+
+    async def triangles(
+        self, op, src, dst, src_x, src_y, tris, mask_format=0
+    ):
+        payload = pack_render_triangles(
+            self.code, op, src, dst, mask_format, src_x, src_y, tris
+        )
+        self.display.write(payload)
+
+    async def create_glyphset(self, format, gsid=None):
+        if gsid is None:
+            gsid = self.display.resources.allocate()
+        payload = pack_render_create_glyphset(self.code, gsid, format)
+        self.display.write(payload)
+        return gsid
+
+    async def free_glyphset(self, gsid):
+        self.display.write(pack_render_free_glyphset(self.code, gsid))
+
+    async def add_glyphs(self, gsid, glyph_ids, glyph_infos, data):
+        payload = pack_render_add_glyphs(
+            self.code, gsid, glyph_ids, glyph_infos, data
+        )
+        self.display.write(payload)
+
+    async def free_glyphs(self, gsid, glyph_ids):
+        payload = pack_render_free_glyphs(self.code, gsid, glyph_ids)
+        self.display.write(payload)
+
+    async def composite_glyphs8(
+        self,
+        op,
+        src,
+        dst,
+        glyphset,
+        src_x,
+        src_y,
+        elements,
+        mask_format=0,
+    ):
+        payload = pack_render_composite_glyphs8(
+            self.code,
+            op,
+            src,
+            dst,
+            mask_format,
+            glyphset,
+            src_x,
+            src_y,
+            elements,
+        )
+        self.display.write(payload)
+
+
 EXTENSIONS = {
     "MIT-SHM": SharedMemory,
     "DOUBLE-BUFFER": DoubleBuffer,
@@ -3778,6 +4764,7 @@ EXTENSIONS = {
     "GLX": GLX,
     "DRI3": DRI3,
     "Present": Present,
+    "RENDER": Render,
 }
 
 

{aioxlib-0.0.6 → aioxlib-0.0.7}/aioxlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioxlib
-Version: 0.0.6
+Version: 0.0.7
 Summary: Human friendly interface to XLib subsystems using asyncio python
 Author-email: Jose Tiago Macara Coutinho <coutinhotiago@gmail.com>
 License-Expression: GPL-3.0-or-later