aioxlib 0.3.0__tar.gz → 0.5.0__tar.gz

{aioxlib-0.3.0 → aioxlib-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioxlib
-Version: 0.3.0
+Version: 0.5.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
@@ -36,10 +36,12 @@ asyncio—without blocking the event loop and without linking to libX11.
 ## Documentation
 
 - Online: [aioxlib.readthedocs.io](https://aioxlib.readthedocs.io)
-- Local: `pip install -r docs/requirements.txt && mkdocs serve`
+- Local: `pip install --group docs && mkdocs serve`
 
 ## Installation
 
+From within your favorite python environment:
+
 ```bash
 pip install aioxlib
 ```
@@ -52,6 +54,7 @@ The **root package** exposes the functional API and `get_display` only:
 import asyncio
 import aioxlib
 
+
 async def main():
     wnd = await aioxlib.create_window(640, 480, title="Hello from aioxlib")
     await wnd.show()
@@ -60,6 +63,7 @@ async def main():
         if wnd.is_delete_window(event):
             break
 
+
 asyncio.run(main())
 ```
 
@@ -69,6 +73,7 @@ asyncio.run(main())
 import asyncio
 import aioxlib
 
+
 async def main():
     display = await aioxlib.get_display()
     async with display:
@@ -80,6 +85,7 @@ async def main():
             if wnd.is_delete_window(event):
                 break
 
+
 asyncio.run(main())
 ```
 
@@ -134,5 +140,5 @@ GPLv3 or later — see [LICENSE](LICENSE).
 
 ## Author
 
-José Tiago Macara Coutinho  
+José Tiago Macara Coutinho
 <https://codeberg.org/tiagocoutinho>

{aioxlib-0.3.0 → aioxlib-0.5.0}/README.md

@@ -12,10 +12,12 @@ asyncio—without blocking the event loop and without linking to libX11.
 ## Documentation
 
 - Online: [aioxlib.readthedocs.io](https://aioxlib.readthedocs.io)
-- Local: `pip install -r docs/requirements.txt && mkdocs serve`
+- Local: `pip install --group docs && mkdocs serve`
 
 ## Installation
 
+From within your favorite python environment:
+
 ```bash
 pip install aioxlib
 ```
@@ -28,6 +30,7 @@ The **root package** exposes the functional API and `get_display` only:
 import asyncio
 import aioxlib
 
+
 async def main():
     wnd = await aioxlib.create_window(640, 480, title="Hello from aioxlib")
     await wnd.show()
@@ -36,6 +39,7 @@ async def main():
         if wnd.is_delete_window(event):
             break
 
+
 asyncio.run(main())
 ```
 
@@ -45,6 +49,7 @@ asyncio.run(main())
 import asyncio
 import aioxlib
 
+
 async def main():
     display = await aioxlib.get_display()
     async with display:
@@ -56,6 +61,7 @@ async def main():
             if wnd.is_delete_window(event):
                 break
 
+
 asyncio.run(main())
 ```
 
@@ -110,5 +116,5 @@ GPLv3 or later — see [LICENSE](LICENSE).
 
 ## Author
 
-José Tiago Macara Coutinho  
+José Tiago Macara Coutinho
 <https://codeberg.org/tiagocoutinho>

{aioxlib-0.3.0 → aioxlib-0.5.0}/aioxlib/__init__.py

@@ -16,19 +16,16 @@ Types and protocol helpers live in submodules::
     from aioxlib.protocol import pack_create_window
 """
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 
+from . import api, constants
 from .api import *  # noqa: F403
-from .api import __all__ as _api_all
 from .constants import *  # noqa: F403
-from .constants import __all__ as _constants_all
 from .display import get_display
 
 __all__ = [
     "__version__",
     "get_display",
-    *_constants_all,
-    *_api_all,
+    *constants.__all__,
+    *api.__all__,
 ]
-
-del _api_all, _constants_all

{aioxlib-0.3.0 → aioxlib-0.5.0}/aioxlib/_extensions.py

@@ -11,6 +11,7 @@ from .dbe import DoubleBuffer
 from .dri3 import DRI3
 from .glx import GLX
 from .present import Present
+from .randr import RandR
 from .render import Render
 from .shm import SharedMemory
 
@@ -22,4 +23,5 @@ EXTENSIONS = {
     "DRI3": DRI3,
     "Present": Present,
     "RENDER": Render,
+    "RANDR": RandR,
 }

{aioxlib-0.3.0 → aioxlib-0.5.0}/aioxlib/api.py

@@ -207,6 +207,11 @@ async def get_font_path(display: Display | None = None):
     return await d.get_font_path()
 
 
+async def set_font_path(path, display: Display | None = None):
+    d = await _resolve_display(display)
+    return await d.set_font_path(path)
+
+
 async def get_atom(name, only_if_exists=False, display: Display | None = None):
     """Intern *name* (with cache) on the default (or given) display."""
     d = await _resolve_display(display)
@@ -296,10 +301,10 @@ async def open_font_name(name, display: Display | None = None):
     return await d.open_font_name(name)
 
 
-async def open_font(display: Display | None = None, **kwargs):
+async def open_font(name=None, display: Display | None = None, **kwargs):
     """Open a font built from keyword XLFD fields."""
     d = await _resolve_display(display)
-    return await d.open_font(**kwargs)
+    return await d.open_font(name=name, **kwargs)
 
 
 async def tree(wnd, display: Display | None = None):
@@ -402,6 +407,7 @@ __all__ = [
     "query_extension",
     "list_fonts",
     "get_font_path",
+    "set_font_path",
     "get_atom",
     "default_screen",
     "create_window",

{aioxlib-0.3.0 → aioxlib-0.5.0}/aioxlib/connection.py

@@ -97,10 +97,6 @@ class Connection:
         """Write."""
         self.writer.write(payload)
 
-    def writelines(self, lines):
-        """Writelines."""
-        self.writer.writelines(lines)
-
     async def flush(self):
         """Flush."""
         return await self.writer.drain()

{aioxlib-0.3.0 → aioxlib-0.5.0}/aioxlib/display.py

@@ -41,12 +41,15 @@ from .protocol import (
     pack_change_property,
     pack_clear_area,
     pack_configure_window,
+    pack_copy_area,
     pack_create_colormap,
     pack_create_gc,
+    pack_create_pixmap,
     pack_create_window,
     pack_delete_property,
     pack_destroy_window,
     pack_free_colormap,
+    pack_free_pixmap,
     pack_get_atom_name,
     pack_get_font_path,
     pack_get_geometry,
@@ -69,12 +72,14 @@ from .protocol import (
     pack_query_extension,
     pack_query_tree,
     pack_reparent_window,
+    pack_set_font_path,
     pack_set_input_focus,
     pack_setup,
     pack_unmap_window,
     unpack_client_message,
     unpack_error,
     unpack_event,
+    unpack_expose_event,
     unpack_get_atom_name,
     unpack_get_font_path,
     unpack_get_geometry,
@@ -155,6 +160,7 @@ class Drawable(Resource):
 
     async def draw_image(self, gc, x, y, w, h, depth, data, drawable=None):
         """Draw image."""
+        drawable = drawable or self
         max_size = self.display.info["max_request_length"]
         nb_pixels = w * h
         n = len(data)
@@ -194,8 +200,7 @@ class Drawable(Resource):
 
     async def put_text(self, gc, x, y, text, drawable=None):
         """Put text."""
-        if drawable is None:
-            drawable = self
+        drawable = drawable or self
         payload = pack_image_text(drawable, gc, x, y, text)
         self.display.connection.write(payload)
 
@@ -203,6 +208,11 @@ class Drawable(Resource):
         """Get geometry."""
         return await self.display.get_geometry(self)
 
+    async def create_pixmap(self, width, height, depth=None, drawable=None):
+        """Create a pixmap. *drawable* defaults to the root window."""
+        drawable = drawable or self
+        return await self.display.create_pixmap(width, height, depth, drawable)
+
 
 class ResourceManager:
     """Allocates resource IDs from the server base and mask."""
@@ -284,7 +294,7 @@ class Window(Drawable):
         delete_on_close=False,
         take_focus=False,
         **attrs,
-    ):
+    ) -> Window:
         """Create window."""
         wid = self.display.resources.allocate()
         payload = pack_create_window(
@@ -482,7 +492,7 @@ class Screen:
         background_pixel=None,
         delete_on_close=True,
         **attrs,
-    ):
+    ) -> Window:
         """Create window."""
         if parent is None:
             parent = self.root
@@ -538,7 +548,10 @@ class Display:
         self.commands = {cmd: cmd.name for cmd in Command}
         self.requests = asyncio.Queue()
         self.listeners = set()
-        self._events = {EventType.ClientMessage: unpack_client_message}
+        self._events = {
+            EventType.ClientMessage: unpack_client_message,
+            EventType.Expose: unpack_expose_event,
+        }
         self._atom_cache = {}
         self._extensions_cache = None
         self._task = None
@@ -670,6 +683,16 @@ class Display:
         reply = await self.write_read(payload, unpack_get_font_path)
         return reply["path"]
 
+    async def set_font_path(self, paths=()):
+        """Set the font search path.
+
+        *paths* is a sequence of directory strings.  Pass an empty sequence
+        (or call with no arguments) to restore the server default path.
+        This is a write-only request (no reply).
+        """
+        payload = pack_set_font_path(paths)
+        self.write(payload)
+
     async def get_atom(self, name, only_if_exists=False):
         """Intern *name* and cache the atom id."""
         if name in self._atom_cache:
@@ -759,9 +782,9 @@ class Display:
         self.write(payload)
         return fid
 
-    async def open_font(self, **kwargs):
+    async def open_font(self, name=None, **kwargs):
         """Open font."""
-        font = build_font(**kwargs)
+        font = build_font(**kwargs) if name is None else name
         return await self.open_font_name(font)
 
     async def tree(self, wnd):
@@ -772,7 +795,7 @@ class Display:
 
     async def poly_fill_rectangles(self, drawable, gc, rectangles):
         """Poly fill rectangles."""
-        if isinstance(rectangles, (bytes, bytearray)):
+        if isinstance(rectangles, bytes | bytearray):
             payload = pack_poly_fill_raw_rectangles(drawable, gc, rectangles)
         else:
             payload = pack_poly_fill_rectangles(drawable, gc, rectangles)
@@ -784,7 +807,7 @@ class Display:
         *arcs* is a sequence of ``(x, y, width, height, angle1, angle2)``
         with angles in 1/64 degree units, or a pre-packed ``bytes`` LISTofARC.
         """
-        if isinstance(arcs, (bytes, bytearray)):
+        if isinstance(arcs, bytes | bytearray):
             payload = pack_poly_fill_raw_arcs(drawable, gc, arcs)
         else:
             payload = pack_poly_fill_arcs(drawable, gc, arcs)
@@ -811,6 +834,24 @@ class Display:
         payload = pack_clear_area(wnd, x, y, w, h, exposure)
         self.write(payload)
 
+    async def copy_area(self, src, dst, gc, src_x, src_y, width, height, dst_x=0, dst_y=0):
+        """Copy a rectangle from *src* to *dst*."""
+        self.write(pack_copy_area(src, dst, gc, src_x, src_y, width, height, dst_x, dst_y))
+
+    async def create_pixmap(self, width, height, depth=None, drawable=None):
+        """Create a pixmap. *drawable* defaults to the root window."""
+        if drawable is None:
+            drawable = self.default_screen().root
+        if depth is None:
+            depth = self.default_screen().root_depth
+        pid = self.resources.allocate()
+        self.write(pack_create_pixmap(pid, drawable, width, height, depth))
+        return pid
+
+    async def free_pixmap(self, pixmap):
+        """Free a pixmap."""
+        self.write(pack_free_pixmap(pixmap))
+
     async def set_input_focus(self, focus, revert_to=1, time=0):
         """Set keyboard input focus to *focus* (window id or resource)."""
         self.write(pack_set_input_focus(focus, revert_to=revert_to, time=time))
@@ -871,42 +912,57 @@ class Display:
                     break
         return error
 
+    async def _handle_buffer(self, buffer, current_decoder=None):
+        packet_type = buffer[0]
+        if packet_type == Status.Success:
+            if current_decoder is None:
+                current_decoder = await self.requests.get()
+            decode, future = current_decoder
+            if decode == unpack_setup:
+                size = 8 + 4 * int.from_bytes(buffer[6:8], BYTE_ORDER_TEXT)
+            else:
+                size = 32 + 4 * int.from_bytes(buffer[4:8], BYTE_ORDER_TEXT)
+            if len(buffer) < size:
+                return True, buffer, current_decoder
+            try:
+                reply, offset = decode(buffer, 0)
+                future.set_result(reply)
+            except Exception as error:
+                future.set_exception(error)
+            return False, buffer[offset:], None
+        elif packet_type == Status.Failed and not self.requests.empty():
+            decode, future = await self.requests.get()
+            if decode == unpack_setup:
+                # todo: check if buffer is complete
+                error, offset = unpack_setup_error(buffer)
+                future.set_exception(RuntimeError(error))
+            else:
+                if len(buffer) < 32:
+                    return True, buffer, current_decoder
+                error, offset = unpack_error(buffer)
+                error = self._handle_error(error)
+                log.warning("ERROR: %s", error)
+                future.set_exception(X11Error(error))
+            return False, buffer[offset:], None
+
+        # An event
+        if len(buffer) < 32:
+            return True, buffer, current_decoder
+        event, offset = unpack_event(self._events, buffer)
+        for listener in self.listeners:
+            await listener.put(event)
+        return False, buffer[offset:], current_decoder
+
     async def _loop(self):
-        buffer, decoder = b"", None
+        buffer, context = b"", None
         while True:
-            if not (data := await self.read(4 * 1024)):
+            if not (data := await self.read(4096)):
                 log.info("Connection closed")
                 return
             buffer += data
-            packet_type = buffer[0]
-            if packet_type == Status.Success:
-                if decoder is None:
-                    decoder = await self.requests.get()
-                decode, future = decoder
-                if decode == unpack_setup:
-                    size = 8 + 4 * int.from_bytes(buffer[6:8], BYTE_ORDER_TEXT)
-                else:
-                    size = 32 + 4 * int.from_bytes(buffer[4:8], BYTE_ORDER_TEXT)
-                if len(buffer) < size:
-                    continue
-                reply, offset = decode(buffer, 0)
-                future.set_result(reply)
-                decoder = None
-            elif packet_type == Status.Failed and not self.requests.empty():
-                decode, future = await self.requests.get()
-                if decode == unpack_setup:
-                    error, offset = unpack_setup_error(buffer)
-                    future.set_exception(RuntimeError(error))
-                else:
-                    error, offset = unpack_error(buffer)
-                    error = self._handle_error(error)
-                    log.warning("ERROR: %s", error)
-                    future.set_exception(X11Error(error))
-            else:
-                event, offset = unpack_event(self._events, buffer)
-                for listener in self.listeners:
-                    await listener.put(event)
-            buffer = buffer[offset:]
+            need_more = False
+            while not need_more and buffer:
+                need_more, buffer, context = await self._handle_buffer(buffer, context)
 
     async def events(self):
         """Async iterator yielding event dicts from the server."""
@@ -933,7 +989,7 @@ def get_display_config(uri: str) -> dict:
         display["protocol"] = protocol
     display["port"] = int(display["port"])
     display["uri"] = uri
-    display["screen"] = display["screen"] or 0
+    display["screen"] = int(display["screen"] or 0)
     return display
 
 

{aioxlib-0.3.0 → aioxlib-0.5.0}/aioxlib/glx.py

@@ -613,7 +613,7 @@ def pack_glx_is_direct(opcode, context):
 def unpack_glx_is_direct(data, offset=0):
     """Unpack a glx is direct reply or event from *data* starting at *offset*."""
     result, offset = unpack_reply_head(data, offset)
-    result["is_direct"] = bool(result["n"])
+    result["is_direct"] = bool(struct.unpack_from("B", data, offset)[0])
     offset += 24
     return result, offset
 
@@ -754,17 +754,22 @@ def pack_glx_get_fb_configs(opcode, screen):
 
 def unpack_glx_get_fb_configs(data, offset=0):
     """Unpack a glx get fb configs reply or event from *data* starting at *offset*."""
+    start = offset
     result, offset = unpack_reply_head(data, offset)
+    # Fixed fields at bytes 8..31 of the reply
     n_cfgs, n_props = struct.unpack_from("II", data, offset)
-    offset += 8 + 16
+    offset += struct.calcsize("II") + 16
     total = n_cfgs * n_props
-    props = list(struct.unpack_from(f"{total}I".format(total=total), data, offset)) if total else []
-    offset += total * 4
+    if total:
+        props = list(struct.unpack_from(f"{total}I", data, offset))
+    else:
+        props = []
     configs = [props[i * n_props : (i + 1) * n_props] for i in range(n_cfgs)]
     result["num_fb_configs"] = n_cfgs
     result["num_properties"] = n_props
     result["fb_configs"] = configs
-    return result, offset
+    # Always consume the full reply so the connection buffer stays aligned
+    return result, start + 32 + 4 * result["length"]
 
 
 def pack_glx_create_new_context(
@@ -793,32 +798,51 @@ def pack_glx_create_new_context(
 
 
 def pack_glx_make_context_current(opcode, drawable, read_drawable, context, old_context_tag=0):
-    """Pack a wire-protocol glx make context current request into ``bytes``."""
+    """Pack a wire-protocol glx make context current request into ``bytes``.
+
+    Wire order (glxproto.h)::
+
+        oldContextTag, drawable, readdrawable, context
+    """
     return struct.pack(
         "BBHIIII",
         opcode,
         GLXCommand.MakeContextCurrent,
         5,
+        int(old_context_tag),
         int(drawable),
         int(read_drawable),
         int(context),
-        int(old_context_tag),
     )
 
 
-def pack_glx_create_pbuffer(opcode, pbuffer, fbconfig, attrs: list[tuple[int, int]] | None = None):
-    """Pack a wire-protocol glx create pbuffer request into ``bytes``."""
+def pack_glx_create_pbuffer(
+    opcode,
+    pbuffer,
+    fbconfig,
+    screen=0,
+    attrs: list[tuple[int, int]] | None = None,
+):
+    """Pack a wire-protocol glx create pbuffer request into ``bytes``.
+
+    Wire order (xcb)::
+
+        screen, fbconfig, pbuffer, num_attribs, attribs[num_attribs*2]
+
+    Fixed header ``BBHIIII`` is 5 units plus 2 per attribute pair.
+    """
     attrs = attrs or []
     n = len(attrs)
-    length = 3 + 2 * n
+    length = 5 + 2 * n
     parts = [
         struct.pack(
-            "BBHIII",
+            "BBHIIII",
             opcode,
             GLXCommand.CreatePbuffer,
             length,
-            int(pbuffer),
+            int(screen),
             int(fbconfig),
+            int(pbuffer),
             n,
         )
     ]
@@ -832,20 +856,36 @@ def pack_glx_destroy_pbuffer(opcode, pbuffer):
     return struct.pack("BBHI", opcode, GLXCommand.DestroyPbuffer, 2, int(pbuffer))
 
 
-def pack_glx_create_window(opcode, window, fbconfig, x_window, attrs: list[tuple[int, int]] | None = None):
-    """Pack a wire-protocol glx create window request into ``bytes``."""
+def pack_glx_create_window(
+    opcode,
+    glx_window,
+    fbconfig,
+    x_window,
+    screen=0,
+    attrs: list[tuple[int, int]] | None = None,
+):
+    """Pack a wire-protocol glx create window request into ``bytes``.
+
+    Wire order (GLX 1.3 / xcb)::
+
+        screen, fbconfig, x_window, glx_window, num_attribs, attribs[num_attribs*2]
+
+    Request length is in 4-byte units: fixed header ``BBHIIIII`` is 6 units
+    plus 2 units per attribute/value pair.
+    """
     attrs = attrs or []
     n = len(attrs)
-    length = 4 + 2 * n
+    length = 6 + 2 * n
     parts = [
         struct.pack(
-            "BBHIIII",
+            "=BBHIIIII",
             opcode,
             GLXCommand.CreateWindow,
             length,
-            int(window),
+            int(screen),
             int(fbconfig),
             int(x_window),
+            int(glx_window),
             n,
         )
     ]
@@ -1395,22 +1435,56 @@ class GLX(Extension):
         )
         return context
 
-    async def create_window(self, fbconfig, x_window, attrs=None, window=None):
-        """Create window."""
+    async def create_window(self, fbconfig, x_window, screen=None, attrs=None, window=None):
+        """Create a GLX window wrapping an X11 window for the given FBConfig.
+
+        Parameters
+        ----------
+        fbconfig:
+            FBConfig id (from :meth:`get_fb_configs`).
+        x_window:
+            Existing X11 window XID (must use a visual compatible with *fbconfig*).
+        screen:
+            Screen number (default: display default screen).
+        attrs:
+            Optional list of ``(attribute, value)`` pairs.
+        window:
+            Optional GLX window id; allocated if omitted (must differ from *x_window*).
+        """
+        x_window = int(x_window)
+        fbconfig = int(fbconfig)
+        if screen is None:
+            screen = self.display.config.get("screen", 0)
+        screen = int(screen)
         if window is None:
             window = self.display.resources.allocate()
-        self.display.write(pack_glx_create_window(self.code, window, fbconfig, x_window, attrs))
+        window = int(window)
+        # GLX window XID must be a fresh client ID, not the X11 window
+        if window == x_window or window == 0:
+            window = int(self.display.resources.allocate())
+        self.display.write(
+            pack_glx_create_window(
+                self.code,
+                window,
+                fbconfig,
+                x_window,
+                screen=screen,
+                attrs=attrs,
+            )
+        )
         return window
 
     async def destroy_window(self, window):
         """Destroy window."""
         self.display.write(pack_glx_destroy_window(self.code, window))
 
-    async def create_pbuffer(self, fbconfig, attrs=None, pbuffer=None):
+    async def create_pbuffer(self, fbconfig, attrs=None, pbuffer=None, screen=None):
         """Create pbuffer."""
         if pbuffer is None:
             pbuffer = self.display.resources.allocate()
-        self.display.write(pack_glx_create_pbuffer(self.code, pbuffer, fbconfig, attrs))
+        if screen is None:
+            screen = self.display.config.get("screen", 0)
+        self.display.write(pack_glx_create_pbuffer(self.code, pbuffer, fbconfig, screen=screen, attrs=attrs))
         return pbuffer
 
     async def destroy_pbuffer(self, pbuffer):