aioxlib 0.8.0__tar.gz → 0.9.0__tar.gz

{aioxlib-0.8.0 → aioxlib-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioxlib
-Version: 0.8.0
+Version: 0.9.0
 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
@@ -38,9 +38,9 @@ Open displays, create windows, draw with GCs and the RENDER extension, and strea
 events — without blocking the event loop and without linking to libX11 or xcb.
 
 <p align="center">
-  <img src="docs/images/game_of_life.gif" style="height: 300px;" alt="Conway's Game of Life on X11 via aioxlib"/>
+  <img src="docs/images/game_of_life.gif" style="height: 300px;" height="300" alt="Conway's Game of Life on X11 via aioxlib"/>
   &nbsp;
-  <img src="docs/images/3d_cube.gif" style="height: 300px;" alt="Rotating 3D wireframe via aioxlib"/>
+  <img src="docs/images/3d_cube.gif" style="height: 300px;" height="300" alt="Rotating 3D wireframe via aioxlib"/>
 </p>
 
 <p align="center"><em>Examples shipped with the library: Game of Life · 3D wireframe</em></p>

{aioxlib-0.8.0 → aioxlib-0.9.0}/README.md

@@ -12,9 +12,9 @@ Open displays, create windows, draw with GCs and the RENDER extension, and strea
 events — without blocking the event loop and without linking to libX11 or xcb.
 
 <p align="center">
-  <img src="docs/images/game_of_life.gif" style="height: 300px;" alt="Conway's Game of Life on X11 via aioxlib"/>
+  <img src="docs/images/game_of_life.gif" style="height: 300px;" height="300" alt="Conway's Game of Life on X11 via aioxlib"/>
   &nbsp;
-  <img src="docs/images/3d_cube.gif" style="height: 300px;" alt="Rotating 3D wireframe via aioxlib"/>
+  <img src="docs/images/3d_cube.gif" style="height: 300px;" height="300" alt="Rotating 3D wireframe via aioxlib"/>
 </p>
 
 <p align="center"><em>Examples shipped with the library: Game of Life · 3D wireframe</em></p>

{aioxlib-0.8.0 → aioxlib-0.9.0}/aioxlib/__init__.py

@@ -16,7 +16,7 @@ Types and protocol helpers live in submodules::
     from aioxlib.protocol import pack_create_window
 """
 
-__version__ = "0.8.0"
+__version__ = "0.9.0"
 
 from . import api, constants
 from .api import *  # noqa: F403

{aioxlib-0.8.0 → aioxlib-0.9.0}/aioxlib/api.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from .constants import (
     Allocate,
     AnyPropertyType,
+    CoordinateMode,
     PropMode,
 )
 from .display import Display
@@ -307,6 +308,17 @@ async def open_font(name=None, display: Display | None = None, **kwargs):
     return await d.open_font(name=name, **kwargs)
 
 
+async def query_text_extents(font, string, display: Display | None = None):
+    """QueryTextExtents — bounding box of *string* in *font* (or GC).
+
+    Returns a dict with draw_direction, font_ascent, font_descent,
+    overall_ascent, overall_descent, overall_width, overall_left,
+    overall_right.
+    """
+    d = await _resolve_display(display)
+    return await d.query_text_extents(font, string)
+
+
 async def tree(wnd, display: Display | None = None):
     """Query the window tree for *wnd*."""
     d = await _resolve_display(display)
@@ -331,12 +343,18 @@ async def poly_segments(drawable, gc, segments, display: Display | None = None):
     return await d.poly_segments(drawable, gc, segments)
 
 
-async def poly_points(drawable, gc, points, mode, display: Display | None = None):
+async def poly_points(drawable, gc, points, mode=CoordinateMode.Origin, display: Display | None = None):
     """PolyPoint on *drawable*."""
     d = await _resolve_display(display)
     return await d.poly_points(drawable, gc, points, mode)
 
 
+async def poly_lines(drawable, gc, points, mode=CoordinateMode.Origin, display: Display | None = None):
+    """PolyLine on *drawable*."""
+    d = await _resolve_display(display)
+    return await d.poly_lines(drawable, gc, points, mode)
+
+
 async def clear_area(wnd, x, y, w, h, exposure=False, display: Display | None = None):
     """ClearArea on *wnd*."""
     d = await _resolve_display(display)
@@ -421,11 +439,13 @@ __all__ = [
     "delete_property",
     "open_font_name",
     "open_font",
+    "query_text_extents",
     "tree",
     "poly_fill_rectangles",
     "poly_fill_arcs",
     "poly_segments",
     "poly_points",
+    "poly_lines",
     "clear_area",
     "set_input_focus",
     "get_geometry",

{aioxlib-0.8.0 → aioxlib-0.9.0}/aioxlib/constants.py

@@ -282,9 +282,25 @@ class Command(enum.IntEnum):
     FreeColormap = 79
     QueryExtension = 98
     ListExtensions = 99
-
+    ChangeKeyboardMapping = 100
+    GetKeyboardMapping = 101
+    ChangeKeyboardControl = 102
+    GetKeyboardControl = 103
+    Bell = 104
+    ChangePointerControl = 105
+    GetPointerControl = 106
     SetScreenSaver = 107
     GetScreenSaver = 108
+    ChangeHosts = 109
+    ListHosts = 110
+    SetAccessControl = 111
+    SetCloseDownMode = 112
+    KillClient = 113
+    RotateProperties = 114
+    ForceScreenSaver = 115
+    SetPointerMapping = 116
+    GetPointerMapping = 117
+    SetModifierMapping = 118
     GetModifierMapping = 119
     NoOperation = 127
 

{aioxlib-0.8.0 → aioxlib-0.9.0}/aioxlib/display.py

@@ -17,6 +17,7 @@ import asyncio
 import logging
 import os
 
+from . import protocol
 from .connection import open_connection
 from .constants import (
     BYTE_ORDER_TEXT,
@@ -28,6 +29,7 @@ from .constants import (
     AnyPropertyType,
     Atom,
     Command,
+    CoordinateMode,
     CopyFromParent,
     ErrorCode,
     EventType,
@@ -59,6 +61,7 @@ from .protocol import (
     pack_get_atom_name,
     pack_get_font_path,
     pack_get_geometry,
+    pack_get_keyboard_mapping,
     pack_get_property,
     pack_image,
     pack_image_text,
@@ -72,10 +75,15 @@ from .protocol import (
     pack_poly_fill_raw_arcs,
     pack_poly_fill_raw_rectangles,
     pack_poly_fill_rectangles,
+    pack_poly_lines,
     pack_poly_points,
+    pack_poly_raw_lines,
+    pack_poly_raw_rectangles,
     pack_poly_raw_segments,
+    pack_poly_rectangles,
     pack_poly_segments,
     pack_query_extension,
+    pack_query_text_extents,
     pack_query_tree,
     pack_reparent_window,
     pack_set_font_path,
@@ -84,15 +92,16 @@ from .protocol import (
     pack_unmap_window,
     unpack_error,
     unpack_event,
-    unpack_get_atom_name,
     unpack_get_font_path,
     unpack_get_geometry,
+    unpack_get_keyboard_mapping,
     unpack_get_property,
     unpack_intern_atom,
     unpack_list_extensions,
     unpack_list_fonts,
     unpack_list_properties,
     unpack_query_extension,
+    unpack_query_text_extents,
     unpack_query_tree,
     unpack_setup,
     unpack_setup_error,
@@ -101,7 +110,11 @@ from .protocol import (
 log = logging.getLogger("aioxlib")
 
 
-# --- extension ---
+def unpack_get_atom_name(data, offset=0):
+    reply, offset = protocol.unpack_get_atom_name(data, offset)
+    return reply["name"], offset
+
+
 class Extension:
     """Base class for X protocol extensions."""
 
@@ -117,7 +130,6 @@ class Extension:
         self.commands = {}
 
 
-# --- resource ---
 class Resource:
     """Base class for server-side resources identified by an XID."""
 
@@ -186,6 +198,10 @@ class Drawable(Resource):
         """Poly fill rectangles."""
         return await self.display.poly_fill_rectangles(self, gc, rectangles)
 
+    async def poly_rectangles(self, gc, rectangles):
+        """Poly rectangles."""
+        return await self.display.poly_rectangles(self, gc, rectangles)
+
     async def poly_fill_arcs(self, gc, arcs):
         """Fill elliptical arcs on this drawable.
 
@@ -202,6 +218,10 @@ class Drawable(Resource):
         """Poly points."""
         return await self.display.poly_points(self, gc, points, mode)
 
+    async def poly_lines(self, gc, points, mode=CoordinateMode.Origin):
+        """Poly lines."""
+        return await self.display.poly_lines(self, gc, points, mode)
+
     async def put_text(self, gc, x, y, text, drawable=None):
         """Put text."""
         drawable = drawable or self
@@ -242,7 +262,6 @@ class ResourceManager:
         return self.base | i
 
 
-# --- gc ---
 class GC(Resource):
     """Graphics context resource used by core drawing requests."""
 
@@ -256,6 +275,11 @@ class GC(Resource):
         drawable = drawable or self.drawable
         return await self.display.poly_fill_rectangles(drawable, self, rectangles)
 
+    async def poly_rectangles(self, rectangles, drawable=None):
+        """Poly rectangles."""
+        drawable = drawable or self.drawable
+        return await self.display.poly_rectangles(drawable, self, rectangles)
+
     async def poly_fill_arcs(self, arcs, drawable=None):
         """Poly fill arcs."""
         if drawable is None:
@@ -267,11 +291,16 @@ class GC(Resource):
         drawable = drawable or self.drawable
         return await self.display.poly_segments(drawable, self, segments)
 
-    async def poly_points(self, points, mode, drawable=None):
+    async def poly_points(self, points, mode=CoordinateMode.Origin, drawable=None):
         """Poly points."""
         drawable = drawable or self.drawable
         return await self.display.poly_points(drawable, self, points, mode)
 
+    async def poly_lines(self, points, mode=CoordinateMode.Origin, drawable=None):
+        """Poly points."""
+        drawable = drawable or self.drawable
+        return await self.display.poly_lines(drawable, self, points, mode)
+
     async def put_text(self, x, y, text, drawable=None):
         """Put text."""
         if drawable is None:
@@ -279,16 +308,22 @@ class GC(Resource):
         payload = pack_image_text(drawable, self, x, y, text)
         self.display.connection.write(payload)
 
+    async def query_text_extents(self, string, font=None):
+        return await self.display.query_text_extents(font or self, string)
+
 
-# --- window ---
 class Window(Drawable):
     """X window resource with mapping, properties, and drawing helpers."""
 
+    def __init__(self, display, wid, depth):
+        super().__init__(display, wid)
+        self.depth = depth
+
     async def create_window(
         self,
         width,
         height,
-        depth,
+        depth=None,
         x=0,
         y=0,
         border_width=0,
@@ -301,6 +336,8 @@ class Window(Drawable):
     ) -> Window:
         """Create window."""
         wid = self.display.resources.allocate()
+        if depth is None:
+            depth = self.depth
         payload = pack_create_window(
             depth=depth,
             wid=wid,
@@ -326,12 +363,16 @@ class Window(Drawable):
             wm_protocols = display.WM_PROTOCOLS
             payload += pack_change_property(wid, wm_protocols, Atom.ATOM, 32, protocols, PropMode.Replace)
         self.display.connection.write(payload)
-        return Window(self.display, wid)
+        return Window(self.display, wid, depth)
 
     async def set_name(self, name):
         """Set name."""
         await self.change_text_property(Atom.WM_NAME, name)
 
+    async def get_name(self):
+        value = await self.get_property(Atom.WM_NAME)
+        return value["value"]
+
     async def set_motif_hints(self, functions=None, decorations=None, input_mode=None, status=None):
         data = build_motif_wm_hints(
             functions=functions,
@@ -601,7 +642,7 @@ class Screen:
         """Initialize a new Screen instance."""
         self.display = display
         self.info = info
-        self.root = Window(display, info["root"])
+        self.root = Window(display, info["root"], self.root_depth)
 
     def __getattr__(self, name):
         return self.info[name]
@@ -626,8 +667,6 @@ class Screen:
             parent = self.root
         if depth is None:
             depth = self.root_depth
-        if background_pixel is None:
-            background_pixel = self.black_pixel
         return await parent.create_window(
             x=x,
             y=y,
@@ -642,8 +681,11 @@ class Screen:
             **attrs,
         )
 
+    async def create_gc(self, drawable=None, **kwargs) -> GC:
+        drawable = drawable or self.root
+        return await drawable.create_gc(**kwargs)
+
 
-# --- display ---
 class Pipeline:
     """Context manager that batches write and write_read requests before flush.
 
@@ -705,7 +747,7 @@ class Display:
         self._events = {}
         self._atom_cache = {}
         self._extensions_cache = None
-        self._task = None
+        self._event_task = None
         self._pipeline = None
 
     async def __aenter__(self):
@@ -722,19 +764,19 @@ class Display:
 
     def close(self):
         """Close."""
-        if self._task:
-            self._task.cancel()
+        if self._event_task:
+            self._event_task.cancel()
         self.connection.close()
 
     async def aclose(self):
         """Aclose."""
-        if self._task:
-            self._task.cancel()
+        if self._event_task:
+            self._event_task.cancel()
             try:
-                await self._task
+                await self._event_task
             except asyncio.CancelledError:
                 pass
-            self._task = None
+            self._event_task = None
         await self.connection.aclose()
 
     def pipeline(self):
@@ -785,8 +827,9 @@ class Display:
 
     async def setup(self):
         """Perform the X11 connection handshake and populate screens."""
-        if self._task is None:
-            self._task = asyncio.create_task(self._loop())
+        if self._event_task is None:
+            self._event_queue = asyncio.Queue()
+            self._event_task = asyncio.create_task(self._loop())
         entry = self.connection.authority()
         payload = pack_setup(entry["name"], entry["data"])
         info = await self.write_read(payload, unpack_setup)
@@ -801,11 +844,10 @@ class Display:
         reply = await self.write_read(payload, unpack_intern_atom)
         return reply["atom"]
 
-    async def get_atom_name(self, atom):
+    def get_atom_name(self, atom):
         """Return the string name for *atom*."""
         payload = pack_get_atom_name(atom)
-        reply = await self.write_read(payload, unpack_get_atom_name)
-        return reply["name"]
+        return self.write_read(payload, unpack_get_atom_name)
 
     async def _list_extensions(self):
         payload = pack_list_extensions()
@@ -955,6 +997,16 @@ class Display:
         font = build_font(**kwargs) if name is None else name
         return await self.open_font_name(font)
 
+    async def query_text_extents(self, font, string):
+        """QueryTextExtents — bounding box of *string* in *font* (or GC).
+
+        Returns a dict with draw_direction, font_ascent, font_descent,
+        overall_ascent, overall_descent, overall_width, overall_left,
+        overall_right.
+        """
+        payload = pack_query_text_extents(font, string)
+        return await self.write_read(payload, unpack_query_text_extents)
+
     async def tree(self, wnd):
         """Tree."""
         payload = pack_query_tree(wnd)
@@ -969,6 +1021,14 @@ class Display:
             payload = pack_poly_fill_rectangles(drawable, gc, rectangles)
         self.write(payload)
 
+    async def poly_rectangles(self, drawable, gc, rectangles):
+        """Poly rectangles."""
+        if isinstance(rectangles, bytes | bytearray):
+            payload = pack_poly_raw_rectangles(drawable, gc, rectangles)
+        else:
+            payload = pack_poly_rectangles(drawable, gc, rectangles)
+        self.write(payload)
+
     async def poly_fill_arcs(self, drawable, gc, arcs):
         """PolyFillArc — fill elliptical arcs (or full ellipses).
 
@@ -997,6 +1057,14 @@ class Display:
             payload = pack_poly_points(drawable, gc, points, mode)
         self.write(payload)
 
+    async def poly_lines(self, drawable, gc, points, mode=CoordinateMode.Origin):
+        """Poly lines."""
+        if isinstance(points, bytes):
+            payload = pack_poly_raw_lines(drawable, gc, points, mode)
+        else:
+            payload = pack_poly_lines(drawable, gc, points, mode)
+        self.write(payload)
+
     async def clear_area(self, wnd, x, y, w, h, exposure=False):
         """Clear area."""
         payload = pack_clear_area(wnd, x, y, w, h, exposure)
@@ -1046,6 +1114,12 @@ class Display:
         payload = pack_reparent_window(window, parent, x, y)
         self.write(payload)
 
+    async def get_keyboard_mapping(self, start=None, count=None):
+        start = start or self.info["min_keycode"]
+        count = count or (self.info["max_keycode"] - start)
+        payload = pack_get_keyboard_mapping(start, count)
+        return await self.write_read(payload, unpack_get_keyboard_mapping)
+
     def add_listener(self, listener):
         """Add listener."""
         self.listeners.add(listener)
@@ -1116,7 +1190,12 @@ class Display:
         # An event
         if len(buffer) < 32:
             return True, buffer, current_decoder
-        event, offset = unpack_event(self._events, buffer)
+        try:
+            event, offset = unpack_event(self._events, buffer)
+        except ValueError:
+            log.exception("discarded buffer: %s", buffer)
+            return False, b"", current_decoder
+
         for listener in self.listeners:
             await listener.put(event)
         return False, buffer[offset:], current_decoder

{aioxlib-0.8.0 → aioxlib-0.9.0}/aioxlib/protocol.py

@@ -26,6 +26,7 @@ from .constants import (
     Atom,
     Command,
     ConfigureWindowAttributes,
+    CoordinateMode,
     CreateWindowAttributes,
     EventType,
     InitialState,
@@ -444,6 +445,15 @@ def pack_poly_fill_rectangles(drawable, gc, rectangles) -> bytes:
     return struct.pack(fmt, Command.PolyFillRectangle, length, drawable, gc, *coords)
 
 
+def pack_poly_rectangles(drawable, gc, rectangles) -> bytes:
+    """Pack a wire-protocol poly rectangles request into ``bytes``."""
+    n = len(rectangles)
+    length = 3 + 2 * n
+    fmt = f"BxHII{4 * n}h"
+    coords = (c for rect in rectangles for c in rect)
+    return struct.pack(fmt, Command.PolyRectangle, length, drawable, gc, *coords)
+
+
 def pack_poly_fill_arcs(drawable, gc, arcs) -> bytes:
     """PolyFillArc: fill elliptical arcs (or full ellipses).
 
@@ -481,6 +491,15 @@ def pack_poly_fill_raw_rectangles(drawable, gc, rectangles: bytes) -> bytes:
     return struct.pack(fmt, Command.PolyFillRectangle, length, drawable, gc, rectangles)
 
 
+def pack_poly_raw_rectangles(drawable, gc, rectangles: bytes) -> bytes:
+    """Pack a wire-protocol poly fill raw rectangles request into ``bytes``."""
+    size = len(rectangles)
+    n = size // 8
+    length = 3 + 2 * n
+    fmt = f"BxHII{size}s"
+    return struct.pack(fmt, Command.PolyRectangle, length, drawable, gc, rectangles)
+
+
 def pack_poly_segments(drawable, gc, segments):
     """Pack a wire-protocol poly segments request into ``bytes``."""
     n = len(segments)
@@ -499,7 +518,7 @@ def pack_poly_raw_segments(drawable, gc, segments: bytes) -> bytes:
     return struct.pack(fmt, Command.PolySegment, length, drawable, gc, segments)
 
 
-def pack_poly_points(drawable, gc, points, mode):
+def pack_poly_points(drawable, gc, points, mode=CoordinateMode.Origin):
     """Pack a wire-protocol poly points request into ``bytes``."""
     n = len(points)
     length = 3 + n
@@ -508,6 +527,22 @@ def pack_poly_points(drawable, gc, points, mode):
     return struct.pack(fmt, Command.PolyPoint, mode, length, drawable, gc, *coords)
 
 
+def pack_poly_lines(drawable, gc, points, mode=CoordinateMode.Origin):
+    n = len(points)
+    length = 3 + n
+    fmt = f"BBHII{2 * n}h"
+    coords = (coord for point in points for coord in point)
+    return struct.pack(fmt, Command.PolyLine, mode, length, drawable, gc, *coords)
+
+
+def pack_poly_raw_lines(drawable, gc, points, mode=CoordinateMode.Origin):
+    size = len(points)
+    n = size // 4
+    length = 3 + n
+    fmt = f"BBHII{size}s"
+    return struct.pack(fmt, Command.PolyLine, mode, length, drawable, gc, points)
+
+
 def pack_open_font(fid, name, encoding=DEFAULT_STRING_ENCODING):
     """Pack a wire-protocol open font request into ``bytes``."""
     name = name.encode(encoding)
@@ -530,6 +565,77 @@ def pack_close_font(fid):
     return struct.pack("BxHI", Command.CloseFont, 8 // 4, fid)
 
 
+def pack_query_text_extents(font, string, encoding=DEFAULT_STRING_ENCODING):
+    """Pack a QueryTextExtents request.
+
+    *font* is a Font or GContext id (Fontable).
+    *string* is a str or bytes (8-bit characters). Each character is sent as
+    a CHAR2B with the high byte zero, matching the classic Xlib behaviour of
+    XQueryTextExtents for Latin-1 / ASCII text.
+    """
+    if isinstance(string, str):
+        string = string.encode(encoding)
+    nchars = len(string)
+    # 2 bytes per character (CHAR2B)
+    nbytes = nchars * 2
+    p = pad(nbytes)
+    # request length in 4-byte units: header (2) + string(+pad)
+    length = 2 + (nbytes + p) // 4
+    odd = nchars & 1
+    # Build CHAR2B list: for each byte c -> (0, c)
+    chars = bytearray()
+    for c in string:
+        chars.append(0)
+        chars.append(c)
+    chars.extend(b"\x00" * p)
+    return struct.pack(
+        f"BBHI{nbytes + p}s",
+        Command.QueryTextExtents,
+        odd,
+        length,
+        int(font),
+        bytes(chars),
+    )
+
+
+def unpack_query_text_extents(data, offset=0):
+    """Unpack a QueryTextExtents reply.
+
+    Returns a dict with:
+      draw_direction, font_ascent, font_descent,
+      overall_ascent, overall_descent, overall_width,
+      overall_left, overall_right
+    """
+    result, offset = unpack_reply_head(data, offset)
+    assert result["reply"] == 1
+    # after the 8-byte reply head:
+    # BYTE draw_direction was already consumed as result["n"]
+    result["draw_direction"] = result.pop("n")
+    fmt = "hhhhiii4x"
+    (
+        font_ascent,
+        font_descent,
+        overall_ascent,
+        overall_descent,
+        overall_width,
+        overall_left,
+        overall_right,
+    ) = struct.unpack_from(fmt, data, offset)
+    offset += struct.calcsize(fmt)
+    result.update(
+        {
+            "font_ascent": font_ascent,
+            "font_descent": font_descent,
+            "overall_ascent": overall_ascent,
+            "overall_descent": overall_descent,
+            "overall_width": overall_width,
+            "overall_left": overall_left,
+            "overall_right": overall_right,
+        }
+    )
+    return result, offset
+
+
 def unpack_reply_head(data: bytes, offset: int = 0) -> tuple[dict, int]:
     """Unpack a reply head reply or event from *data* starting at *offset*."""
     fmt = "BBHI"
@@ -1573,6 +1679,20 @@ def pack_reparent_window(window, parent, x, y) -> bytes:
     )
 
 
+def pack_get_keyboard_mapping(start, count):
+    return struct.pack("BxHBB2x", Command.GetKeyboardMapping, 2, start, count)
+
+
+def unpack_get_keyboard_mapping(data, offset=0):
+    result, offset = unpack_reply_head(data, offset)
+    offset += 24
+    n = result["n"]
+    nm = result["length"]
+    values = struct.unpack_from(f"{nm}I", data, offset)
+    result["values"] = list(zip(*[iter(values)] * n, strict=True))
+    return result, offset + 4 * nm
+
+
 def _gl_pad4(n: int) -> int:
     return (4 - (n & 3)) & 3