aioxlib 0.0.4__tar.gz → 0.0.5__tar.gz

{aioxlib-0.0.4 → aioxlib-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioxlib
-Version: 0.0.4
+Version: 0.0.5
 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.4 → aioxlib-0.0.5}/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.4"
+__version__ = "0.0.5"
 
 import asyncio
 import enum
@@ -1818,7 +1818,213 @@ class SharedMemory(Extension):
         self.display.write(payload)
 
 
-EXTENSIONS = {"MIT-SHM": SharedMemory}
+class DoubleBufferOperation(enum.IntEnum):
+    GetVersion = 0
+    AllocateBackBufferName = 1
+    DeallocateBackBufferName = 2
+    SwapBuffers = 3
+    BeginIdiom = 4
+    EndIdiom = 5
+    GetVisualInfo = 6
+    GetBackBufferAttributes = 7
+
+
+class SwapAction(enum.IntEnum):
+    """What to do with the new back buffer after a swap."""
+
+    Undefined = 0
+    Background = 1
+    Untouched = 2
+    Copied = 3
+
+
+def pack_dbe_get_version(opcode, client_major=1, client_minor=0):
+    return struct.pack(
+        "BBHBBH",
+        opcode,
+        DoubleBufferOperation.GetVersion,
+        2,
+        client_major,
+        client_minor,
+        0,
+    )
+
+
+def unpack_dbe_get_version(data, offset=0):
+    result, offset = unpack_reply_head(data, offset)
+    major, minor = struct.unpack_from("=BB", data, offset)
+    offset += 2 + 22
+    result["major_version"] = major
+    result["minor_version"] = minor
+    return result, offset
+
+
+def pack_dbe_allocate_back_buffer(opcode, window, buffer, swap_action=SwapAction.Undefined):
+    return struct.pack(
+        "BBHIIB3x",
+        opcode,
+        DoubleBufferOperation.AllocateBackBufferName,
+        4,
+        int(window),
+        int(buffer),
+        int(swap_action),
+    )
+
+
+def pack_dbe_deallocate_back_buffer(opcode, buffer):
+    return struct.pack(
+        "BBHI",
+        opcode,
+        DoubleBufferOperation.DeallocateBackBufferName,
+        2,
+        int(buffer),
+    )
+
+
+def pack_dbe_swap_buffers(opcode, actions):
+    """actions: sequence of (window, swap_action) pairs."""
+    n = len(actions)
+    length = 2 + 2 * n
+    parts = [struct.pack("=BBHI", opcode, DoubleBufferOperation.SwapBuffers, length, n)]
+    for window, action in actions:
+        parts.append(struct.pack("=IB3x", int(window), int(action)))
+    return b"".join(parts)
+
+
+def pack_dbe_begin_idiom(opcode):
+    return struct.pack("=BBH", opcode, DoubleBufferOperation.BeginIdiom, 1)
+
+
+def pack_dbe_end_idiom(opcode):
+    return struct.pack("=BBH", opcode, DoubleBufferOperation.EndIdiom, 1)
+
+
+def pack_dbe_get_visual_info(opcode, drawables):
+    """drawables: sequence of drawable ids (empty = all screens)."""
+    n = len(drawables)
+    length = 2 + n
+    header = struct.pack("=BBHI", opcode, DoubleBufferOperation.GetVisualInfo, length, n)
+    body = b"".join(struct.pack("=I", int(d)) for d in drawables)
+    return header + body
+
+
+def unpack_dbe_get_visual_info(data, offset=0):
+    result, offset = unpack_reply_head(data, offset)
+    (n_screens,) = struct.unpack_from("=I", data, offset)
+    offset += 4 + 20
+    screens = []
+    for _ in range(n_screens):
+        (n_infos,) = struct.unpack_from("=I", data, offset)
+        offset += 4
+        infos = []
+        for _ in range(n_infos):
+            visual, depth, perflevel = struct.unpack_from("=IBB2x", data, offset)
+            offset += 8
+            infos.append({"visual": visual, "depth": depth, "perflevel": perflevel})
+        screens.append(infos)
+    result["screens"] = screens
+    return result, offset
+
+
+def pack_dbe_get_back_buffer_attributes(opcode, buffer):
+    return struct.pack(
+        "BBHI",
+        opcode,
+        DoubleBufferOperation.GetBackBufferAttributes,
+        2,
+        int(buffer),
+    )
+
+
+def unpack_dbe_get_back_buffer_attributes(data, offset=0):
+    result, offset = unpack_reply_head(data, offset)
+    (window,) = struct.unpack_from("=I", data, offset)
+    offset += 4 + 20
+    result["window"] = window
+    return result, offset
+
+
+class BackBuffer(Drawable):
+    def __init__(self, bid, window, extension):
+        super().__init__(extension.display, bid)
+        self.window = window
+        self.extension = extension
+
+    async def swap(self, swap_action=SwapAction.Undefined):
+        return await self.extension.swap(self.window, swap_action)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *_):
+        await self.extension.deallocate_back_buffer(self.id)
+
+
+class DoubleBuffer(Extension):
+    """X Double Buffer Extension (DOUBLE-BUFFER / DBE).
+
+    Provides front/back buffers for flicker-free animation. Query with::
+
+        dbe = await display.query_extension("DOUBLE-BUFFER")
+    """
+
+    BaseBadBuffer = 0
+
+    def __init__(self, display, info):
+        super().__init__(display, info)
+        self.BadBuffer = info["base_error"] + self.BaseBadBuffer
+        self.errors = {self.BadBuffer: "BadBuffer"}
+        self.commands = {self.code: "Dbe"}
+
+    async def version(self, client_major=1, client_minor=0):
+        payload = pack_dbe_get_version(self.code, client_major, client_minor)
+        return await self.display.write_read(payload, unpack_dbe_get_version)
+
+    async def allocate_back_buffer(self, window, swap_action=SwapAction.Undefined, buffer=None):
+        """Allocate a back-buffer XID for *window*.
+
+        Returns the back-buffer resource id (drawable usable with core
+        drawing requests).
+        """
+        if buffer is None:
+            buffer = self.display.resources.allocate()
+        payload = pack_dbe_allocate_back_buffer(self.code, window, buffer, swap_action)
+        self.display.write(payload)
+        return BackBuffer(buffer, window, self)
+
+    async def deallocate_back_buffer(self, buffer):
+        payload = pack_dbe_deallocate_back_buffer(self.code, buffer)
+        self.display.write(payload)
+
+    async def swap_buffers(self, actions):
+        """Swap front/back buffers.
+
+        *actions* is a sequence of ``(window, swap_action)`` pairs.
+        """
+        payload = pack_dbe_swap_buffers(self.code, actions)
+        self.display.write(payload)
+
+    async def swap(self, window, swap_action=SwapAction.Undefined):
+        """Convenience: swap a single window."""
+        await self.swap_buffers([(window, swap_action)])
+
+    async def begin_idiom(self):
+        self.display.write(pack_dbe_begin_idiom(self.code))
+
+    async def end_idiom(self):
+        self.display.write(pack_dbe_end_idiom(self.code))
+
+    async def get_visual_info(self, drawables=()):
+        """Return per-screen lists of visuals that support double buffering."""
+        payload = pack_dbe_get_visual_info(self.code, drawables)
+        return await self.display.write_read(payload, unpack_dbe_get_visual_info)
+
+    async def get_back_buffer_attributes(self, buffer):
+        payload = pack_dbe_get_back_buffer_attributes(self.code, buffer)
+        return await self.display.write_read(payload, unpack_dbe_get_back_buffer_attributes)
+
+
+EXTENSIONS = {"MIT-SHM": SharedMemory, "DOUBLE-BUFFER": DoubleBuffer}
 
 
 class Pipeline:

{aioxlib-0.0.4 → aioxlib-0.0.5}/aioxlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioxlib
-Version: 0.0.4
+Version: 0.0.5
 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.4 → aioxlib-0.0.5}/tests/test_aioxlib.py

@@ -34,6 +34,8 @@ from aioxlib import (
     CoordinateMode,
     CreateWindowAttributes,
     Display,
+    DoubleBuffer,
+    DoubleBufferOperation,
     Drawable,
     ErrorCode,
     Event,
@@ -48,6 +50,7 @@ from aioxlib import (
     SharedMemory,
     SharedMemoryOperation,
     Status,
+    SwapAction,
     VisualClass,
     Window,
     Xauthority,
@@ -60,6 +63,14 @@ from aioxlib import (
     pack_close_font,
     pack_create_gc,
     pack_create_window,
+    pack_dbe_allocate_back_buffer,
+    pack_dbe_begin_idiom,
+    pack_dbe_deallocate_back_buffer,
+    pack_dbe_end_idiom,
+    pack_dbe_get_back_buffer_attributes,
+    pack_dbe_get_version,
+    pack_dbe_get_visual_info,
+    pack_dbe_swap_buffers,
     pack_destroy_window,
     pack_free_gc,
     pack_get_font_path,
@@ -88,6 +99,9 @@ from aioxlib import (
     read_setup,
     round_bytes,
     unpack_client_message,
+    unpack_dbe_get_back_buffer_attributes,
+    unpack_dbe_get_version,
+    unpack_dbe_get_visual_info,
     unpack_depth,
     unpack_error,
     unpack_event,
@@ -2811,6 +2825,283 @@ class TestSharedMemory:
         assert EXTENSIONS["MIT-SHM"] is SharedMemory
 
 
+# ===========================================================================
+# DOUBLE-BUFFER (DBE) extension
+# ===========================================================================
+
+
+class TestDbePack:
+    def test_get_version(self):
+        data = pack_dbe_get_version(140, client_major=1, client_minor=0)
+        assert data[0] == 140
+        assert data[1] == DoubleBufferOperation.GetVersion
+        assert len(data) == 8
+
+    def test_allocate_back_buffer(self):
+        data = pack_dbe_allocate_back_buffer(140, window=0x100, buffer=0x200, swap_action=SwapAction.Copied)
+        assert data[0] == 140
+        assert data[1] == DoubleBufferOperation.AllocateBackBufferName
+        wnd, buf = struct.unpack_from("=II", data, 4)
+        assert wnd == 0x100
+        assert buf == 0x200
+        assert data[12] == SwapAction.Copied
+        assert len(data) == 16
+
+    def test_deallocate_back_buffer(self):
+        data = pack_dbe_deallocate_back_buffer(140, 0x200)
+        assert data[0] == 140
+        assert data[1] == DoubleBufferOperation.DeallocateBackBufferName
+        assert struct.unpack_from("=I", data, 4)[0] == 0x200
+
+    def test_swap_buffers(self):
+        actions = [
+            (0x10, SwapAction.Background),
+            (0x20, SwapAction.Untouched),
+        ]
+        data = pack_dbe_swap_buffers(140, actions)
+        assert data[0] == 140
+        assert data[1] == DoubleBufferOperation.SwapBuffers
+        n = struct.unpack_from("=I", data, 4)[0]
+        assert n == 2
+        assert len(data) == 8 + 2 * 8
+
+    def test_begin_end_idiom(self):
+        b = pack_dbe_begin_idiom(140)
+        e = pack_dbe_end_idiom(140)
+        assert b[1] == DoubleBufferOperation.BeginIdiom
+        assert e[1] == DoubleBufferOperation.EndIdiom
+        assert len(b) == 4 and len(e) == 4
+
+    def test_get_visual_info_empty(self):
+        data = pack_dbe_get_visual_info(140, [])
+        assert data[1] == DoubleBufferOperation.GetVisualInfo
+        assert struct.unpack_from("=I", data, 4)[0] == 0
+
+    def test_get_visual_info_with_drawables(self):
+        data = pack_dbe_get_visual_info(140, [0x100, 0x200])
+        assert struct.unpack_from("=I", data, 4)[0] == 2
+        assert struct.unpack_from("=II", data, 8) == (0x100, 0x200)
+
+    def test_get_back_buffer_attributes(self):
+        data = pack_dbe_get_back_buffer_attributes(140, 0x30)
+        assert data[1] == DoubleBufferOperation.GetBackBufferAttributes
+        assert struct.unpack_from("=I", data, 4)[0] == 0x30
+
+
+class TestDbeUnpack:
+    def test_get_version(self):
+        head = struct.pack("=BBHI", 1, 0, 1, 0)
+        body = struct.pack("=BB22x", 1, 0)
+        result, offset = unpack_dbe_get_version(head + body)
+        assert result["major_version"] == 1
+        assert result["minor_version"] == 0
+        assert offset == 32
+
+    def test_get_visual_info(self):
+        # 1 screen, 2 visuals
+        head = struct.pack("=BBHI", 1, 0, 1, 0)
+        # n_screens + 20 pad, then per screen: n_infos + infos
+        body = struct.pack("=I20x", 1)
+        body += struct.pack("=I", 2)
+        body += struct.pack("=IBB2x", 0x21, 24, 0)
+        body += struct.pack("=IBB2x", 0x22, 16, 1)
+        result, _ = unpack_dbe_get_visual_info(head + body)
+        assert len(result["screens"]) == 1
+        infos = result["screens"][0]
+        assert len(infos) == 2
+        assert infos[0] == {"visual": 0x21, "depth": 24, "perflevel": 0}
+        assert infos[1]["visual"] == 0x22
+
+    def test_get_back_buffer_attributes(self):
+        head = struct.pack("=BBHI", 1, 0, 1, 0)
+        body = struct.pack("=I20x", 0x100)
+        result, offset = unpack_dbe_get_back_buffer_attributes(head + body)
+        assert result["window"] == 0x100
+        assert offset == 32
+
+
+class TestDoubleBuffer:
+    @pytest.fixture
+    def display(self):
+        conn = MagicMock()
+        conn.write = MagicMock()
+        d = Display(conn, {"protocol": "unix", "port": 0, "screen": 0})
+        d.resources = ResourceManager(0x200000, 0x1FFFFF)
+        d.info = {"max_request_length": 65535}
+        return d
+
+    @pytest.fixture
+    def dbe(self, display):
+        info = {
+            "present": 1,
+            "opcode": 141,
+            "base_event": 0,
+            "base_error": 130,
+        }
+        return DoubleBuffer(display, info)
+
+    def test_init(self, dbe):
+        assert dbe.code == 141
+        assert dbe.BadBuffer == 130
+        assert dbe.errors[130] == "BadBuffer"
+        assert dbe.commands[141] == "Dbe"
+
+    def test_registered_in_extensions(self):
+        assert EXTENSIONS["DOUBLE-BUFFER"] is DoubleBuffer
+        assert "MIT-SHM" in EXTENSIONS
+
+    @pytest.mark.asyncio
+    async def test_version(self, dbe, display):
+        expected = {"major_version": 1, "minor_version": 0}
+
+        async def write_read(payload, cb):
+            assert payload[0] == 141
+            assert payload[1] == DoubleBufferOperation.GetVersion
+            return expected
+
+        display.write_read = write_read
+        result = await dbe.version()
+        assert result is expected
+
+    @pytest.mark.asyncio
+    async def test_allocate_back_buffer(self, dbe, display):
+        buf = await dbe.allocate_back_buffer(0x100, SwapAction.Copied)
+        assert buf.id == 0x200000
+        payload = display.connection.write.call_args[0][0]
+        assert payload[0] == 141
+        assert payload[1] == DoubleBufferOperation.AllocateBackBufferName
+        assert payload[12] == SwapAction.Copied
+
+    @pytest.mark.asyncio
+    async def test_allocate_explicit_buffer_id(self, dbe, display):
+        buf = await dbe.allocate_back_buffer(0x100, buffer=0x99)
+        assert buf.id == 0x99
+
+    @pytest.mark.asyncio
+    async def test_deallocate_back_buffer(self, dbe, display):
+        await dbe.deallocate_back_buffer(0x30)
+        payload = display.connection.write.call_args[0][0]
+        assert payload[1] == DoubleBufferOperation.DeallocateBackBufferName
+
+    @pytest.mark.asyncio
+    async def test_swap_buffers(self, dbe, display):
+        await dbe.swap_buffers([(0x10, SwapAction.Background)])
+        payload = display.connection.write.call_args[0][0]
+        assert payload[1] == DoubleBufferOperation.SwapBuffers
+
+    @pytest.mark.asyncio
+    async def test_swap_convenience(self, dbe, display):
+        await dbe.swap(0x10, SwapAction.Untouched)
+        payload = display.connection.write.call_args[0][0]
+        assert payload[1] == DoubleBufferOperation.SwapBuffers
+        n = struct.unpack_from("=I", payload, 4)[0]
+        assert n == 1
+
+    @pytest.mark.asyncio
+    async def test_begin_end_idiom(self, dbe, display):
+        await dbe.begin_idiom()
+        await dbe.end_idiom()
+        calls = display.connection.write.call_args_list
+        assert calls[0][0][0][1] == DoubleBufferOperation.BeginIdiom
+        assert calls[1][0][0][1] == DoubleBufferOperation.EndIdiom
+
+    @pytest.mark.asyncio
+    async def test_get_visual_info(self, dbe, display):
+        expected = {"screens": [[{"visual": 1, "depth": 24, "perflevel": 0}]]}
+
+        async def write_read(payload, cb):
+            assert payload[1] == DoubleBufferOperation.GetVisualInfo
+            return expected
+
+        display.write_read = write_read
+        result = await dbe.get_visual_info()
+        assert result is expected
+
+    @pytest.mark.asyncio
+    async def test_get_back_buffer_attributes(self, dbe, display):
+        expected = {"window": 0x100}
+
+        async def write_read(payload, cb):
+            assert payload[1] == DoubleBufferOperation.GetBackBufferAttributes
+            return expected
+
+        display.write_read = write_read
+        result = await dbe.get_back_buffer_attributes(0x30)
+        assert result["window"] == 0x100
+
+    @pytest.mark.asyncio
+    async def test_query_extension_wires_dbe(self, display):
+        display._extensions_cache = {"DOUBLE-BUFFER": None}
+
+        async def write_read(payload, callback):
+            head = struct.pack("=BBHI", 1, 0, 1, 0)
+            body = struct.pack("=BBBB20x", 1, 141, 0, 130)
+            reply, _ = callback(head + body, 0)
+            return reply
+
+        display.write_read = write_read
+        # Display.query_extension needs list_extensions path — use the
+        # already-primed cache of known extension names.
+        ext = await display.query_extension("DOUBLE-BUFFER")
+        assert isinstance(ext, DoubleBuffer)
+        assert ext.code == 141
+        assert 141 in display.commands
+
+
+class TestBackBuffer:
+    @pytest.fixture
+    def display(self):
+        conn = MagicMock()
+        conn.write = MagicMock()
+        d = Display(conn, {"protocol": "unix", "port": 0, "screen": 0})
+        d.resources = ResourceManager(0x200000, 0x1FFFFF)
+        d.info = {"max_request_length": 65535}
+        return d
+
+    @pytest.fixture
+    def dbe(self, display):
+        info = {
+            "present": 1,
+            "opcode": 141,
+            "base_event": 0,
+            "base_error": 130,
+        }
+        return DoubleBuffer(display, info)
+
+    @pytest.mark.asyncio
+    async def test_back_buffer_context(self, dbe, display):
+        async with await dbe.allocate_back_buffer(0x100, SwapAction.Copied) as buf:
+            assert buf.id == 0x200000
+            payload = display.connection.write.call_args[0][0]
+            assert payload[0] == 141
+            assert payload[1] == DoubleBufferOperation.AllocateBackBufferName
+            assert payload[12] == SwapAction.Copied
+
+        payload = display.connection.write.call_args[0][0]
+        assert payload[1] == DoubleBufferOperation.DeallocateBackBufferName
+
+    @pytest.mark.asyncio
+    async def test_swap_buffers(self, dbe, display):
+        async with await dbe.allocate_back_buffer(0x100, SwapAction.Copied) as buf:
+            payload = display.connection.write.call_args[0][0]
+            assert payload[0] == 141
+            assert payload[1] == DoubleBufferOperation.AllocateBackBufferName
+            assert payload[12] == SwapAction.Copied
+            await buf.swap(SwapAction.Background)
+            payload = display.connection.write.call_args[0][0]
+            assert payload[1] == DoubleBufferOperation.SwapBuffers
+        payload = display.connection.write.call_args[0][0]
+        assert payload[1] == DoubleBufferOperation.DeallocateBackBufferName
+
+
+class TestSwapActionEnum:
+    def test_values(self):
+        assert SwapAction.Undefined == 0
+        assert SwapAction.Background == 1
+        assert SwapAction.Untouched == 2
+        assert SwapAction.Copied == 3
+
+
 # ---------------------------------------------------------------------------
 # Display — deeper coverage
 # ---------------------------------------------------------------------------