aioxlib 0.0.1__py3-none-any.whl

aioxlib/__init__.py

@@ -0,0 +1,1571 @@
+#
+# This file is part of the aioxlib project
+#
+# Copyright (c) 2026 Tiago Coutinho
+# Distributed under the GPLv3 license. See LICENSE for more info.
+
+__version__ = "0.0.1"
+
+import asyncio
+import enum
+import logging
+import os
+import re
+import socket
+import struct
+import sys
+
+log = logging.getLogger("aioxlib")
+
+BIG_ENDIAN = 0x42
+LITTLE_ENDIAN = 0x6C
+BYTE_ORDER = LITTLE_ENDIAN if sys.byteorder == "little" else BIG_ENDIAN
+
+PROTOCOL_MAJOR = 11
+PROTOCOL_MINOR = 0
+
+TYPE = b"MIT-MAGIC-COOKIE-1"
+SUPPORTED_PROTOCOLS = "unix", "tcp"
+DISPLAY_RE = re.compile(r"^((?P<protocol>tcp|unix)/)?(?P<host>[-a-zA-Z0-9._]*):(?P<port>\d+)(\.(?P<screen>\d+))?$")
+
+BASE_TCP_PORT = 6000
+UNIX_PATH_TEMPLATE = "/tmp/.X11-unix/X{}"
+
+DEFAULT_STRING_ENCODING = "ISO-8859-1"
+UTF8_STRING_ENCODING = "UTF-8"
+
+NONE = 0
+
+ParentRelative = 1  # background pixmap in CreateWindow
+# and ChangeWindowAttributes
+
+CopyFromParent = 0  # border pixmap in CreateWindow
+# and ChangeWindowAttributes
+# special VisualID and special window
+# class passed to CreateWindow
+
+PointerWindow = 0  # destination window in SendEvent
+InputFocus = 1  # destination window in SendEvent
+PointerRoot = 1  # focus window in SetInputFocus
+AnyPropertyType = 0  # special Atom, passed to GetProperty
+AnyKey = 0  # special Key Code, passed to GrabKey
+AnyButton = 0  # special Button Code, passed to GrabButton
+AllTemporary = 0  # special Resource ID passed to KillClient
+CurrentTime = 0  # special Time
+NoSymbol = 0  # special KeySym
+
+
+class EventMask(enum.IntFlag):
+    NoEvent = 0
+    KeyPress = 1 << 0
+    KeyRelease = 1 << 1
+    ButtonPress = 1 << 2
+    ButtonRelease = 1 << 3
+    EnterWindow = 1 << 4
+    LeaveWindow = 1 << 5
+    PointerMotion = 1 << 6
+    PointerMotionHint = 1 << 7
+    Button1Motion = 1 << 8
+    Button2Motion = 1 << 9
+    Button3Motion = 1 << 10
+    Button4Motion = 1 << 11
+    Button5Motion = 1 << 12
+    ButtonMotion = 1 << 13
+    KeymapState = 1 << 14
+    Exposure = 1 << 15
+    VisibilityChange = 1 << 16
+    StructureNotify = 1 << 17
+    ResizeRedirect = 1 << 18
+    SubstructureNotify = 1 << 19
+    SubstructureRedirect = 1 << 20
+    FocusChange = 1 << 21
+    PropertyChange = 1 << 22
+    ColormapChange = 1 << 23
+    OwnerGrabButton = 1 << 24
+
+
+class PacketType(enum.IntEnum):
+    Error = 0
+    Reply = 1
+
+
+class Event(enum.IntEnum):
+    KeyPress = 2
+    KeyRelease = 3
+    ButtonPress = 4
+    ButtonRelease = 5
+    MotionNotify = 6
+    EnterNotify = 7
+    LeaveNotify = 8
+    FocusIn = 9
+    FocusOut = 10
+    KeymapNotify = 11
+    Expose = 12
+    GraphicsExpose = 13
+    NoExpose = 14
+    VisibilityNotify = 15
+    CreateNotify = 16
+    DestroyNotify = 17
+    UnmapNotify = 18
+    MapNotify = 19
+    MapRequest = 20
+    ReparentNotify = 21
+    ConfigureNotify = 22
+    ConfigureRequest = 23
+    GravityNotify = 24
+    ResizeRequest = 25
+    CirculateNotify = 26
+    CirculateRequest = 27
+    PropertyNotify = 28
+    SelectionClear = 29
+    SelectionRequest = 30
+    SelectionNotify = 31
+    ColormapNotify = 32
+    ClientMessage = 33
+    MappingNotify = 34
+
+
+class KeyMask(enum.IntFlag):
+    Shift = 1 << 0
+    Lock = 1 << 1
+    Control = 1 << 2
+    Mod1 = 1 << 3
+    Mod2 = 1 << 4
+    Mod3 = 1 << 5
+    Mod4 = 1 << 6
+    Mod5 = 1 << 7
+
+
+class Modifier(enum.IntEnum):
+    ShiftMapIndex = 0
+    LockMapIndex = 1
+    ControlMapIndex = 2
+    Mod1MapIndex = 3
+    Mod2MapIndex = 4
+    Mod3MapIndex = 5
+    Mod4MapIndex = 6
+    Mod5MapIndex = 7
+
+
+class ButtonMask(enum.IntFlag):
+    Button1Mask = 1 << 8
+    Button2Mask = 1 << 9
+    Button3Mask = 1 << 10
+    Button4Mask = 1 << 11
+    Button5Mask = 1 << 12
+    AnyModifier = 1 << 15  # used in GrabButton, GrabKey
+
+
+class Button(enum.IntEnum):
+    Button1 = 1
+    Button2 = 2
+    Button3 = 3
+    Button4 = 4
+    Button5 = 5
+
+
+class Family(enum.IntEnum):
+    Internet = 0
+    DECnet = 1
+    Chaos = 2
+    ServerInterpreted = 5
+    InternetV6 = 6
+    Local = 256
+
+
+class Status(enum.IntEnum):
+    Failed = 0
+    Success = 1
+    Authenticate = 2
+
+
+class Command(enum.IntEnum):
+    CreateWindow = 1
+    ChangeWindowAttributes = 2
+    GetWindowAttributes = 3
+    DestroyWindow = 4
+    DestroySubwindows = 5
+    ChangeSaveSet = 6
+    ReparentWindow = 7
+    MapWindow = 8
+    MapSubwindows = 9
+    UnmapWindow = 10
+    UnmapSubwindows = 11
+    ConfigureWindow = 12
+    CirculateWindow = 13
+    GetGeometry = 14
+    QueryTree = 15
+    InternAtom = 16
+    GetAtomName = 17
+    ChangeProperty = 18
+    DeleteProperty = 19
+    GetProperty = 20
+    ListProperties = 21
+    SetSelectionOwner = 22
+    GetSelectionOwner = 23
+    ConvertSelection = 24
+    SendEvent = 25
+    GrabPointer = 26
+    UngrabPointer = 27
+    GrabButton = 28
+    UngrabButton = 29
+    ChangeActivePointerGrab = 30
+    GrabKeyboard = 31
+    UngrabKeyboard = 32
+    GrabKey = 33
+    UngrabKey = 34
+    AllowEvents = 35
+    GrabServer = 36
+    UngrabServer = 37
+    QueryPointer = 38
+    GetMotionEvents = 39
+    TranslateCoordinates = 40
+    WarpPointer = 41
+    SetInputFocus = 42
+    GetInputFocus = 43
+    QueryKeymap = 44
+    OpenFont = 45
+    CloseFont = 46
+    QueryFont = 47
+    QueryTextExtents = 48
+    ListFonts = 49
+    ListFontsWithInfo = 50
+    SetFontPath = 51
+    GetFontPath = 52
+    CreatePixmap = 53
+    FreePixmap = 54
+    CreateGC = 55
+    ChangeGC = 56
+    CopyGC = 57
+    SetDashes = 58
+    SetClipRectangles = 59
+    FreeGC = 60
+    ClearArea = 61
+    CopyArea = 62
+    CopyPlane = 63
+    PolyPoint = 64
+    PolyLine = 65
+    PolySegment = 66
+    PolyRectangle = 67
+    PolyArc = 68
+    FillPoly = 69
+    PolyFillRectangle = 70
+    PolyFillArc = 71
+    PutImage = 72
+    GetImage = 73
+    PolyText8 = 74
+    PolyText16 = 75
+    ImageText8 = 76
+    ImageText16 = 77
+    QueryExtension = 98
+    ListExtensions = 99
+
+    SetScreenSaver = 107
+    GetScreenSaver = 108
+    GetModifierMapping = 119
+    NoOperation = 127
+
+
+# -----------------------------------------------------------------------
+# XXX These still need documentation -- for now, read <X11/X.h>
+#
+#
+NotifyNormal = 0
+NotifyGrab = 1
+NotifyUngrab = 2
+NotifyWhileGrabbed = 3
+NotifyHint = 1
+NotifyAncestor = 0
+NotifyVirtual = 1
+NotifyInferior = 2
+NotifyNonlinear = 3
+NotifyNonlinearVirtual = 4
+NotifyPointer = 5
+NotifyPointerRoot = 6
+NotifyDetailNone = 7
+VisibilityUnobscured = 0
+VisibilityPartiallyObscured = 1
+VisibilityFullyObscured = 2
+PlaceOnTop = 0
+PlaceOnBottom = 1
+
+PropertyNewValue = 0
+PropertyDelete = 1
+ColormapUninstalled = 0
+ColormapInstalled = 1
+GrabModeSync = 0
+GrabModeAsync = 1
+GrabSuccess = 0
+AlreadyGrabbed = 1
+GrabInvalidTime = 2
+GrabNotViewable = 3
+GrabFrozen = 4
+AsyncPointer = 0
+SyncPointer = 1
+ReplayPointer = 2
+AsyncKeyboard = 3
+SyncKeyboard = 4
+ReplayKeyboard = 5
+AsyncBoth = 6
+SyncBoth = 7
+RevertToNone = 0
+RevertToPointerRoot = PointerRoot
+RevertToParent = 2
+Success = 0
+
+
+class ErrorCode(enum.IntEnum):
+    BadRequest = 1
+    BadValue = 2
+    BadWindow = 3
+    BadPixmap = 4
+    BadAtom = 5
+    BadCursor = 6
+    BadFont = 7
+    BadMatch = 8
+    BadDrawable = 9
+    BadAccess = 10
+    BadAlloc = 11
+    BadColor = 12
+    BadGC = 13
+    BadIDChoice = 14
+    BadName = 15
+    BadLength = 16
+    BadImplementation = 17
+
+
+class PropMode(enum.IntEnum):
+    Replace = 0
+    Prepend = 1
+    Append = 2
+
+
+class Atom(enum.IntEnum):
+    PRIMARY = 1
+    SECONDARY = 2
+    ARC = 3
+    ATOM = 4
+    BITMAP = 5
+    CARDINAL = 6
+    COLORMAP = 7
+    CURSOR = 8
+    CUT_BUFFER0 = 9
+    CUT_BUFFER1 = 10
+    CUT_BUFFER2 = 11
+    CUT_BUFFER3 = 12
+    CUT_BUFFER4 = 13
+    CUT_BUFFER5 = 14
+    CUT_BUFFER6 = 15
+    CUT_BUFFER7 = 16
+    DRAWABLE = 17
+    FONT = 18
+    INTEGER = 19
+    PIXMAP = 20
+    POINT = 21
+    RECTANGLE = 22
+    RESOURCE_MANAGER = 23
+    RGB_COLOR_MAP = 24
+    RGB_BEST_MAP = 25
+    RGB_BLUE_MAP = 26
+    RGB_DEFAULT_MAP = 27
+    RGB_GRAY_MAP = 28
+    RGB_GREEN_MAP = 29
+    RGB_RED_MAP = 30
+    STRING = 31
+    VISUALID = 32
+    WINDOW = 33
+    WM_COMMAND = 34
+    WM_HINTS = 35
+    WM_CLIENT_MACHINE = 36
+    WM_ICON_NAME = 37
+    WM_ICON_SIZE = 38
+    WM_NAME = 39
+    WM_NORMAL_HINTS = 40
+    WM_SIZE_HINTS = 41
+    WM_ZOOM_HINTS = 42
+    MIN_SPACE = 43
+    NORM_SPACE = 44
+    MAX_SPACE = 45
+    END_SPACE = 46
+    SUPERSCRIPT_X = 47
+    SUPERSCRIPT_Y = 48
+    SUBSCRIPT_X = 49
+    SUBSCRIPT_Y = 50
+    UNDERLINE_POSITION = 51
+    UNDERLINE_THICKNESS = 52
+    STRIKEOUT_ASCENT = 53
+    STRIKEOUT_DESCENT = 54
+    ITALIC_ANGLE = 55
+    X_HEIGHT = 56
+    QUAD_WIDTH = 57
+    WEIGHT = 58
+    POINT_SIZE = 59
+    RESOLUTION = 60
+    COPYRIGHT = 61
+    NOTICE = 62
+    FONT_NAME = 63
+    FAMILY_NAME = 64
+    FULL_NAME = 65
+    CAP_HEIGHT = 66
+    WM_CLASS = 67
+    WM_TRANSIENT_FOR = 68
+
+
+class ImageFormat(enum.IntEnum):
+    XYBitmap = 0
+    XYPixmap = 1
+    ZPixmap = 2
+
+
+FirstExtensionError = 128
+LastExtensionError = 255
+InputOutput = 1
+InputOnly = 2
+CWBackPixmap = 1 << 0
+CWBackPixel = 1 << 1
+CWBorderPixmap = 1 << 2
+CWBorderPixel = 1 << 3
+CWBitGravity = 1 << 4
+CWWinGravity = 1 << 5
+CWBackingStore = 1 << 6
+CWBackingPlanes = 1 << 7
+CWBackingPixel = 1 << 8
+CWOverrideRedirect = 1 << 9
+CWSaveUnder = 1 << 10
+CWEventMask = 1 << 11
+CWDontPropagate = 1 << 12
+CWColormap = 1 << 13
+CWCursor = 1 << 14
+CWX = 1 << 0
+CWY = 1 << 1
+CWWidth = 1 << 2
+CWHeight = 1 << 3
+CWBorderWidth = 1 << 4
+CWSibling = 1 << 5
+CWStackMode = 1 << 6
+ForgetGravity = 0
+NorthWestGravity = 1
+NorthGravity = 2
+NorthEastGravity = 3
+WestGravity = 4
+CenterGravity = 5
+EastGravity = 6
+SouthWestGravity = 7
+SouthGravity = 8
+SouthEastGravity = 9
+StaticGravity = 10
+UnmapGravity = 0
+NotUseful = 0
+WhenMapped = 1
+Always = 2
+IsUnmapped = 0
+IsUnviewable = 1
+IsViewable = 2
+SetModeInsert = 0
+SetModeDelete = 1
+DestroyAll = 0
+RetainPermanent = 1
+RetainTemporary = 2
+Above = 0
+Below = 1
+TopIf = 2
+BottomIf = 3
+Opposite = 4
+RaiseLowest = 0
+LowerHighest = 1
+
+GXclear = 0x0
+GXand = 0x1
+GXandReverse = 0x2
+GXcopy = 0x3
+GXandInverted = 0x4
+GXnoop = 0x5
+GXxor = 0x6
+GXor = 0x7
+GXnor = 0x8
+GXequiv = 0x9
+GXinvert = 0xA
+GXorReverse = 0xB
+GXcopyInverted = 0xC
+GXorInverted = 0xD
+GXnand = 0xE
+GXset = 0xF
+LineSolid = 0
+LineOnOffDash = 1
+LineDoubleDash = 2
+CapNotLast = 0
+CapButt = 1
+CapRound = 2
+CapProjecting = 3
+JoinMiter = 0
+JoinRound = 1
+JoinBevel = 2
+FillSolid = 0
+FillTiled = 1
+FillStippled = 2
+FillOpaqueStippled = 3
+EvenOddRule = 0
+WindingRule = 1
+ClipByChildren = 0
+IncludeInferiors = 1
+Unsorted = 0
+YSorted = 1
+YXSorted = 2
+YXBanded = 3
+CoordModeOrigin = 0
+CoordModePrevious = 1
+Complex = 0
+Nonconvex = 1
+Convex = 2
+ArcChord = 0
+ArcPieSlice = 1
+GCFunction = 1 << 0
+GCPlaneMask = 1 << 1
+GCForeground = 1 << 2
+GCBackground = 1 << 3
+GCLineWidth = 1 << 4
+GCLineStyle = 1 << 5
+GCCapStyle = 1 << 6
+GCJoinStyle = 1 << 7
+GCFillStyle = 1 << 8
+GCFillRule = 1 << 9
+GCTile = 1 << 10
+GCStipple = 1 << 11
+GCTileStipXOrigin = 1 << 12
+GCTileStipYOrigin = 1 << 13
+GCFont = 1 << 14
+GCSubwindowMode = 1 << 15
+GCGraphicsExposures = 1 << 16
+GCClipXOrigin = 1 << 17
+GCClipYOrigin = 1 << 18
+GCClipMask = 1 << 19
+GCDashOffset = 1 << 20
+GCDashList = 1 << 21
+GCArcMode = 1 << 22
+GCLastBit = 22
+FontLeftToRight = 0
+FontRightToLeft = 1
+FontChange = 255
+
+AllocNone = 0
+AllocAll = 1
+DoRed = 1 << 0
+DoGreen = 1 << 1
+DoBlue = 1 << 2
+CursorShape = 0
+TileShape = 1
+StippleShape = 2
+AutoRepeatModeOff = 0
+AutoRepeatModeOn = 1
+AutoRepeatModeDefault = 2
+LedModeOff = 0
+LedModeOn = 1
+KBKeyClickPercent = 1 << 0
+KBBellPercent = 1 << 1
+KBBellPitch = 1 << 2
+KBBellDuration = 1 << 3
+KBLed = 1 << 4
+KBLedMode = 1 << 5
+KBKey = 1 << 6
+KBAutoRepeatMode = 1 << 7
+MappingSuccess = 0
+MappingBusy = 1
+MappingFailed = 2
+MappingModifier = 0
+MappingKeyboard = 1
+MappingPointer = 2
+DontPreferBlanking = 0
+PreferBlanking = 1
+DefaultBlanking = 2
+DisableScreenSaver = 0
+DisableScreenInterval = 0
+DontAllowExposures = 0
+AllowExposures = 1
+DefaultExposures = 2
+ScreenSaverReset = 0
+ScreenSaverActive = 1
+HostInsert = 0
+HostDelete = 1
+EnableAccess = 1
+DisableAccess = 0
+StaticGray = 0
+GrayScale = 1
+StaticColor = 2
+PseudoColor = 3
+TrueColor = 4
+DirectColor = 5
+LSBFirst = 0
+MSBFirst = 1
+
+
+GenericEventCode = 35
+
+
+def pad(n: int) -> int:
+    return (4 - n % 4) % 4
+
+
+def round_bytes(s: bytes) -> tuple[bytes, int, int]:
+    n = len(s)
+    r = pad(n)
+    return s + r * b"\0", n, n + r
+
+
+def pack_setup(auth_name, auth_data, byte_order=BYTE_ORDER, protocol=(PROTOCOL_MAJOR, PROTOCOL_MINOR)):
+    auth_name, n1, n2 = round_bytes(auth_name)
+    auth_data, d1, d2 = round_bytes(auth_data)
+    fmt = f"=BxHHHH2x{n2}s{d2}s"
+    return struct.pack(fmt, byte_order, *protocol, n1, d1, auth_name, auth_data)
+
+
+async def read_setup(reader):
+    data = await reader.readexactly(1)
+    status = Status(ord(data))
+    if status == Status.Success:
+        head = "BxHHH"
+        head_len = struct.calcsize(head)
+        data += await reader.readexactly(head_len - 1)
+        status, proto_major, proto_minor, length = struct.unpack_from(head, data)
+        assert proto_major >= 11
+        length *= 4
+        data = await reader.readexactly(length)
+        return unpack_successfull_setup(data)[0]
+    elif status == Status.Failed:
+        head = "BBHHH"
+        head_len = struct.calcsize(head)
+        data += await reader.readexactly(head_len - 1)
+        status, _, proto_major, proto_minor, length = struct.unpack_from(head, data)
+        length *= 4
+        reason = (await reader.readexactly(length)).decode()
+        raise RuntimeError(reason)
+    elif status == Status.Authenticate:
+        head = "BxH"
+        head_len = struct.calcsize(head)
+        data = await reader.readexactly(head_len - 1)
+        status, length = struct.unpack_from(head, data)
+        n = ord(data[1]) * 4
+        reason = (await reader.readexactly(n)).decode()
+        raise ValueError(reason)
+
+
+def unpack_successfull_setup(data, offset=0):
+    fmt = "4I2H8B4x"
+    fields = (
+        "release",
+        "resource_id_base",
+        "resource_id_mask",
+        "motion_buffer_size",
+        "vendor_length",
+        "max_request_length",
+        "root_length",
+        "pixmap_length",
+        "image_byte_order",
+        "bitmap_format_bit_order",
+        "bitmap_format_scanline_unit",
+        "bitmap_format_scanline_pad",
+        "min_keycode",
+        "max_keycode",
+    )
+    setup = dict(zip(fields, struct.unpack_from(fmt, data, offset), strict=True))
+    offset += struct.calcsize(fmt)
+    vendor_length = setup["vendor_length"]
+    setup["vendor"] = struct.unpack_from(f"{vendor_length}s", data, offset)[0].decode()
+    offset += vendor_length
+    setup["pixmap_formats"] = pixmap_formats = []
+    for _ in range(setup["pixmap_length"]):
+        pixmap_format, offset = unpack_pixmap_format(data, offset)
+        pixmap_formats.append(pixmap_format)
+
+    setup["screens"] = screens = []
+    for _ in range(setup["root_length"]):
+        screen, offset = unpack_screen(data, offset)
+        screens.append(screen)
+    return setup, offset
+
+
+def unpack_pixmap_format(data, offset) -> tuple[dict, int]:
+    fmt = "BBB5x"
+    fields = "depth", "bits_per_pixel", "pad"
+    pixel_format = dict(zip(fields, struct.unpack_from(fmt, data, offset), strict=True))
+    offset += struct.calcsize(fmt)
+    return pixel_format, offset
+
+
+def unpack_screen(data, offset) -> tuple[dict, int]:
+    fields = (
+        "root",
+        "colormap",
+        "white_pixel",
+        "black_pixel",
+        "current_input_mask",
+        "width",
+        "height",
+        "width_in_mms",
+        "height_in_mms",
+        "min_installed_maps",
+        "max_installed_maps",
+        "root_visual",
+        "backing_store",
+        "save_unders",
+        "root_depth",
+        "depths_length",
+    )
+    fmt = "5I6HI4B"
+    screen = dict(zip(fields, struct.unpack_from(fmt, data, offset), strict=True))
+    offset += struct.calcsize(fmt)
+    screen["depths"] = depths = []
+    for _ in range(screen["depths_length"]):
+        depth, offset = unpack_depth(data, offset)
+        depths.append(depth)
+    return screen, offset
+
+
+def unpack_depth(data, offset) -> tuple[dict, int]:
+    fmt = "BxH4x"
+    fields = "depth", "nb_visuals"
+    depth = dict(zip(fields, struct.unpack_from(fmt, data, offset), strict=True))
+    offset += struct.calcsize(fmt)
+    depth["visuals"] = visuals = []
+    for _ in range(depth["nb_visuals"]):
+        visual, offset = unpack_visual(data, offset)
+        visuals.append(visual)
+    return depth, offset
+
+
+def unpack_visual(data, offset) -> tuple[dict, int]:
+    fmt = "IBBHIII4x"
+    fields = (
+        "visual_id",
+        "visual_class",
+        "bits_per_rgb_value",
+        "colormap_entries",
+        "red_mask",
+        "green_mask",
+        "blue_mask",
+    )
+    visual = dict(zip(fields, struct.unpack_from(fmt, data, offset), strict=True))
+    offset += struct.calcsize(fmt)
+    return visual, offset
+
+
+def pack_create_window(*args, **kwargs) -> bytes:
+    from Xlib.protocol.request import CreateWindow
+
+    return CreateWindow._request.to_binary(*args, **kwargs)
+
+
+def pack_map_window(wid) -> bytes:
+    from Xlib.protocol.request import MapWindow
+
+    return MapWindow._request.to_binary(wid)
+
+
+def pack_destroy_window(wid) -> bytes:
+    from Xlib.protocol.request import DestroyWindow
+
+    return DestroyWindow._request.to_binary(wid)
+
+
+def pack_intern_atom(name, only_if_exists=False):
+    from Xlib.protocol.request import InternAtom
+
+    return InternAtom._request.to_binary(name=name, only_if_exists=only_if_exists)
+
+
+def pack_poly_fill_rectangles(wid, gc, rectangles) -> bytes:
+    from Xlib.protocol.request import PolyFillRectangle
+
+    rectangles = [
+        r if isinstance(r, dict) else dict(zip(['x', 'y', 'width', 'height'], r))
+        for r in rectangles
+    ]
+
+    return PolyFillRectangle._request.to_binary(wid, gc, rectangles)
+
+
+
+def unpack_reply_head(data: bytes, offset: int = 0) -> tuple[dict, int]:
+    fmt = "BBHI"
+    reply = struct.unpack_from(fmt, data, offset)
+    fields = "reply", "n", "sequence_number", "length"
+    return dict(zip(fields, reply, strict=True)), offset + struct.calcsize(fmt)
+
+
+def unpack_intern_atom(data: bytes, offset: int = 0) -> tuple[dict, int]:
+    result, offset = unpack_reply_head(data, offset)
+    assert result["reply"] == 1
+    fmt = "I20x"
+    (atom,) = struct.unpack_from(fmt, data, offset)
+    offset += struct.calcsize(fmt)
+    result["atom"] = atom
+    return result, offset
+
+
+def unpack_error(data: bytes, offset: int = 0):
+    fmt = "BBHIHB21x"
+    fields = "error", "code", "sequence_number", "value", "minor_opcode", "major_opcode"
+    reply = struct.unpack_from(fmt, data, offset)
+    offset += struct.calcsize(fmt)
+    result = dict(zip(fields, reply, strict=True))
+    result["code"] = ErrorCode(result["code"])
+    return result, offset
+
+
+def unpack_event(event_map, data: bytes, offset: int = 0):
+    raw_event_type = data[0]
+    # Skip bit 8, that is set if this event came from an SendEvent
+    from_send = bool(raw_event_type & 0x80)
+    event_code = raw_event_type & 0x7F
+    if handler := event_map.get(event_code):
+        result, offset = handler(data, offset)
+    else:
+        fmt = "BBHIIII12x"
+        fields = "raw_code", "detail", "sequence_number", "time", "root", "event", "child"
+        reply = struct.unpack_from(fmt, data, offset)
+        offset += struct.calcsize(fmt)
+        result = dict(zip(fields, reply, strict=True))
+        result["name"] = Event(event_code).name if event_code in Event else event_code
+    result["code"] = event_code
+    result["send_event"] = from_send
+    return result, offset
+
+
+def unpack_client_message(data, offset):
+    format = data[1]
+    fmt = "BBHII"
+    fields = "code", "format", "sequence_number", "window", "type"
+    reply = struct.unpack_from(fmt, data, offset)
+    offset += struct.calcsize(fmt)
+    result = dict(zip(fields, reply, strict=True))
+    data_fmt = "20B"
+    if format == 16:
+        data_fmt = "10H"
+    elif format == 32:
+        data_fmt = "5I"
+    result["data"] = struct.unpack_from(data_fmt, data, offset)
+    result["name"] = "ClientMessage"
+    offset += struct.calcsize(data_fmt)
+    return result, offset
+
+
+def pack_gc(cid, drawable, attrs):
+    from Xlib.protocol.request import CreateGC
+
+    return CreateGC._request.to_binary(cid=cid, drawable=drawable, attrs=attrs)
+
+
+def pack_change_property(wid, property, property_type, format, data, mode):
+    from Xlib.protocol.request import ChangeProperty
+
+    return ChangeProperty._request.to_binary(
+        mode=mode, window=wid, property=property, type=property_type, data=(format, data)
+    )
+
+
+def pack_list_extensions():
+    from Xlib.protocol.request import ListExtensions
+
+    return ListExtensions._request.to_binary()
+
+
+def unpack_list_extensions(data: bytes, offset: int = 0):
+    result, offset = unpack_reply_head(data, offset)
+    n = result["n"]
+    assert result["reply"] == 1
+    offset += 24
+    result["extensions"] = extensions = []
+    for _ in range(n):
+        (size,) = struct.unpack_from("B", data, offset)
+        offset += 1
+        (extension,) = struct.unpack_from(f"{size}s", data, offset)
+        offset += size
+        extensions.append(extension.decode())
+    return result, offset + 32 + result["length"] * 4
+
+
+def pack_query_extension(name: bytes) -> bytes:
+    from Xlib.protocol.request import QueryExtension
+
+    return QueryExtension._request.to_binary(name)
+
+
+def unpack_query_extension(data: bytes, offset: int = 0):
+    result, offset = unpack_reply_head(data, offset)
+    assert result["reply"] == 1
+    fmt = "BBBB20x"
+    fields = "present", "opcode", "base_event", "base_error"
+    result.update(zip(fields, struct.unpack_from(fmt, data, offset), strict=True))
+    offset += struct.calcsize(fmt)
+    return result, offset
+
+
+def pack_image(format, drawable, gc, w, h, x, y, left_pad, depth, data):
+    fmt = "BBHIIHHhhBB2x"
+    n = len(data)
+    p = pad(n)
+    length = 6 + (n + p) // 4
+    head = struct.pack(fmt, 72, format, length, drawable, gc, w, h, x, y, left_pad, depth)
+    return head, data, p * b"\x00"
+
+
+def get_auth_config(filename: str) -> list[dict]:
+    with open(filename, "rb") as f:
+        raw = f.read()
+
+    offset, entries = 0, []
+    while offset < len(raw):
+        family, addrlen = struct.unpack_from(">HH", raw, offset)
+        offset += 4
+        addr = raw[offset : offset + addrlen]
+        offset += addrlen
+        (numlen,) = struct.unpack_from(">H", raw, offset)
+        offset += 2
+        num = raw[offset : offset + numlen]
+        offset += numlen
+        (namelen,) = struct.unpack_from(">H", raw, offset)
+        offset += 2
+        name = raw[offset : offset + namelen]
+        offset += namelen
+        (datalen,) = struct.unpack_from(">H", raw, offset)
+        offset += 2
+        data = raw[offset : offset + datalen]
+        offset += datalen
+        entries.append({"family": family, "address": addr, "port": num, "name": name, "data": data})
+    return entries
+
+
+def get_auth_filename(filename: str | None = None) -> str:
+    if filename is None:
+        if (filename := os.getenv("XAUTHORITY")) is None:
+            filename = f"{os.getenv('HOME')}/.Xauthority"
+    return filename
+
+
+class Screen:
+    def __init__(self, display, info):
+        self.display = display
+        self.info = info
+        self.root = Window(display, info["root"])
+
+    def __getattr__(self, name):
+        return self.info[name]
+
+    async def create_window(
+        self,
+        x,
+        y,
+        width,
+        height,
+        border_width,
+        parent=None,
+        depth=None,
+        window_class=CopyFromParent,
+        visual=CopyFromParent,
+        **attrs,
+    ):
+        if parent is None:
+            parent = self.root
+        if depth is None:
+            depth = self.root_depth
+        return await parent.create_window(x, y, width, height, border_width, depth, window_class, visual, **attrs)
+
+
+class Resource:
+    def __init__(self, display, rid):
+        self.display = display
+        self.id = rid
+
+    def __int__(self):
+        return self.id
+
+
+class Drawable(Resource):
+    async def create_gc(self, **kwargs) -> "GC":
+        cid = self.display.resources.allocate()
+        payload = pack_gc(cid=cid, drawable=self.id, attrs=kwargs)
+        self.display.connection.write(payload)
+        return GC(self.display, cid, self)
+
+    async def put_image(self, gc, x, y, w, h, depth, data, format=ImageFormat.ZPixmap, left_pad=0, drawable=None):
+        if drawable is None:
+            drawable = self
+        payloads = pack_image(format, int(drawable), int(gc), w, h, x, y, left_pad, depth, data)
+        payload = b"".join(payloads)
+        self.display.connection.write(payload)
+
+    async def draw_image(self, gc, x, y, w, h, depth, data, drawable=None):
+        max_size = self.display.info["max_request_length"]
+        nb_pixels = w * h
+        n = len(data)
+        pixel_size = n // nb_pixels
+        nb_bytes_per_line = w * pixel_size
+        lines_per_packet = (max_size - 64) // nb_bytes_per_line
+        data = memoryview(data)
+        y1 = 0
+        while y1 < h:
+            start = y1 * nb_bytes_per_line
+            end = (y1 + lines_per_packet) * nb_bytes_per_line
+            d = data[start:end]
+            lines = min(lines_per_packet, h - y1)
+            await self.put_image(gc, x, y, w, lines, depth, d, drawable=drawable)
+            y1 += lines_per_packet
+            y += lines_per_packet
+
+    async def poly_fill_rectangles(self, gc, rectangles):
+        payload = pack_poly_fill_rectangles(int(self), int(gc), rectangles)
+        self.display.connection.write(payload)
+
+
+class Window(Drawable):
+    async def create_window(
+        self,
+        x,
+        y,
+        width,
+        height,
+        border_width,
+        depth,
+        window_class=CopyFromParent,
+        visual=CopyFromParent,
+        **attrs,
+    ):
+        wid = self.display.resources.allocate()
+        payload = pack_create_window(
+            depth=depth,
+            wid=wid,
+            parent=self.id,
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+            border_width=border_width,
+            window_class=window_class,
+            visual=visual,
+            attrs=attrs,
+        )
+        self.display.connection.write(payload)
+        return Window(self.display, wid)
+
+    async def set_name(self, name):
+        await self.change_text_property(Atom.WM_NAME, name)
+
+    async def change_text_property(self, property, data, property_type=Atom.STRING, mode=PropMode.Replace):
+        if not isinstance(data, bytes):
+            if property_type == Atom.STRING:
+                data = data.encode(DEFAULT_STRING_ENCODING)
+            elif property_type == self.display.get_atom("UTF8_STRING"):
+                data = data.encode()
+        await self.change_property(property, property_type, 8, data, mode)
+
+    async def map(self):
+        payload = pack_map_window(self.id)
+        self.display.connection.write(payload)
+
+    async def destroy(self):
+        payload = pack_destroy_window(self.id)
+        self.display.connection.write(payload)
+
+    async def change_property(self, property, property_type, format, data, mode=PropMode.Replace):
+        payload = pack_change_property(self.id, property, property_type, format, data, mode)
+        self.display.connection.write(payload)
+
+    async def set_wm_protocols(self, protocols):
+        id = await self.display.get_atom("WM_PROTOCOLS")
+        await self.change_property(id, Atom.ATOM, 32, protocols)
+
+
+class GC(Resource):
+    def __init__(self, display, rid, drawable):
+        super().__init__(display, rid)
+        self.drawable = drawable
+
+
+class LogBytes:
+    __slots__ = ["data"]
+    Limit = 32
+
+    def __init__(self, data):
+        self.data = data
+
+    def __str__(self):
+        if len(self.data) > self.Limit:
+            return " ".join(f"{b:02X}" for b in self.data[: self.Limit]) + " [...]"
+        return " ".join(f"{b:02X}" for b in self.data)
+
+
+class Connection:
+    def __init__(self, reader, writer, config):
+        self.reader = reader
+        self.writer = writer
+        self.config = config
+
+    def close(self):
+        self.writer.close()
+
+    async def aclose(self):
+        self.writer.close()
+        await self.writer.wait_closed()
+
+    def get_extra_info(self, item):
+        return self.writer.get_extra_info(item)
+
+    @property
+    def socket(self):
+        return self.get_extra_info("socket")
+
+    @property
+    def xfamily(self) -> Family | None:
+        family = self.socket.family
+        if family == socket.AF_UNIX:
+            return Family.Local
+        elif family == socket.AF_INET:
+            return Family.Internet
+        elif family == socket.AF_INET6:
+            return Family.InternetV6
+
+    def write(self, payload):
+        self.writer.write(payload)
+
+    def writelines(self, lines):
+        l0 = lines[0]
+        code = l0[0]
+        if code in {LITTLE_ENDIAN, BIG_ENDIAN}:
+            cmd_name = "Setup"
+        else:
+            cmd_name = Command(code).name
+        log.debug("WRITEL(%3d): %s %s", len(lines), cmd_name, LogBytes(l0))
+        self.writer.writelines(lines)
+
+    async def flush(self):
+        return await self.writer.drain()
+
+    async def read(self, n=-1):
+        return await self.reader.read(n)
+
+    async def readexactly(self, n):
+        return await self.reader.readexactly(n)
+
+
+async def open_connection(config: dict) -> Connection:
+    protocol = config["protocol"]
+    if protocol == "unix":
+        path = UNIX_PATH_TEMPLATE.format(config["port"])
+        r, w = await asyncio.open_unix_connection(path)
+    elif protocol == "tcp":
+        port = BASE_TCP_PORT + config["port"]
+        r, w = await asyncio.open_connection(config["host"], port)
+    else:
+        raise ValueError(f"Unsupported protocol {protocol!r}")
+    return Connection(r, w, config)
+
+
+class Xauthority:
+    def __init__(self, filename: str | None = None):
+        self.filename = get_auth_filename(filename)
+        self.entries = get_auth_config(self.filename)
+
+    def __call__(self, connection: Connection, types=(TYPE,)) -> dict:
+        family = connection.xfamily
+        if connection.config["protocol"] == "tcp":
+            if connection.config["host"] == "localhost":
+                family = Family.Local
+                address = socket.gethostname().encode()
+            else:
+                if family == Family.Internet:
+                    octets = connection.socket.getpeername()[0].split(".")
+                    address = bytearray(int(x) for x in octets)
+                elif family == Family.InternetV6:
+                    address = socket.gethostname().encode()
+        else:
+            address = socket.gethostname().encode()
+
+        port = connection.config["port"]
+        bport = f"{port}".encode()
+
+        matches = {}
+        for entry in self.entries:
+            ename, eport = entry["name"], entry["port"]
+            if not eport and entry["name"] not in matches:
+                eport = bport
+            if entry["family"] == family and entry["address"] == address and eport == bport:
+                matches[ename] = entry
+        for type_ in types:
+            try:
+                return matches[type_]
+            except KeyError:
+                pass
+        raise ValueError("Cannot find auth")
+
+
+class ResourceManager:
+    def __init__(self, base, mask):
+        self.base = base
+        self.mask = mask
+        self.last = 0
+        self.ids = set()
+
+    def allocate(self):
+        i = self.last
+        while i in self.ids:
+            i = i + 1
+            if i > self.mask:
+                i = 0
+            if i == self.last:
+                raise RuntimeError("out of resource ids")
+        self.ids.add(i)
+        self.last = i
+        return self.base | i
+
+
+class SharedMemoryOperation(enum.IntEnum):
+    QueryVersion = 0
+    Attach = 1
+    Detach = 2
+    PutImage = 3
+    GetImage = 4
+    CreatePixmap = 5
+    AttachFd = 6
+    CreateSegment = 7
+
+
+def pack_shm_attach(opcode, rid, shmid, read_only=True):
+    fmt = "BBHIIB3x"
+    length = struct.calcsize(fmt) // 4
+    return struct.pack(fmt, opcode, SharedMemoryOperation.Attach, length, rid, shmid, 1 if read_only else 0)
+
+
+def pack_shm_attach_fd(opcode, fd, read_only=True):
+    fmt = "BBHIB3x"
+    length = struct.calcsize(fmt) // 4
+    return struct.pack(fmt, opcode, SharedMemoryOperation.AttachFd, length, fd, 1 if read_only else 0)
+
+
+def pack_shm_version(opcode):
+    fmt = "BBH"
+    length = struct.calcsize(fmt) // 4
+    return struct.pack(fmt, opcode, SharedMemoryOperation.QueryVersion, length)
+
+
+def unpack_shm_version(data, offset=0):
+    result, offset = unpack_reply_head(data, offset)
+    fmt = "HHHHB15x"
+    fields = "major_version", "minor_version", "uid", "gid", "pixmap_format"
+    result.update(zip(fields, struct.unpack_from(fmt, data, offset), strict=True))
+    offset += struct.calcsize(fmt)
+    result["shared_pixmaps"] = bool(result.pop("n"))
+    return result, offset
+
+
+def pack_shm_put_image(
+    opcode,
+    wnd,
+    gc,
+    total_width,
+    total_height,
+    src_x,
+    src_y,
+    src_width,
+    src_height,
+    dst_x,
+    dst_y,
+    depth,
+    send_event,
+    rid,
+    offset,
+):
+    fmt = "BBHIIHHHHHHhhBBBBII"
+    length = struct.calcsize(fmt) // 4
+    return struct.pack(
+        fmt,
+        opcode,
+        SharedMemoryOperation.PutImage,
+        length,
+        wnd,
+        gc,
+        total_width,
+        total_height,
+        src_x,
+        src_y,
+        src_width,
+        src_height,
+        dst_x,
+        dst_y,
+        depth,
+        ImageFormat.ZPixmap,
+        send_event,
+        0,
+        rid,
+        offset,
+    )
+
+
+def unpack_shm_complete(data, offset=0):
+    fmt = "BxHIHBxII12x"
+    fields = "code", "sequence_number", "window", "minor", "major", "shm_id", "offset"
+    size = struct.calcsize(fmt)
+    result = dict(zip(fields, struct.unpack_from(fmt, data, offset), strict=True))
+    result["name"] = "ShmComplete"
+    return result, offset + size
+
+
+class Extension:
+    def __init__(self, display, info):
+        self.display = display
+        self.info = info
+        self.code = info["opcode"]
+        self.events = {}
+        self.errors = {}
+        self.commands = {}
+
+
+class SharedMemory(Extension):
+    BaseShmCompletion = 0
+    BaseBadShmSeg = 0
+
+    def __init__(self, display, info):
+        super().__init__(display, info)
+        self.ShmCompletion = info["base_event"] + self.BaseShmCompletion
+        self.BadShmSeg = info["base_error"] + self.BaseBadShmSeg
+        self.events = {self.ShmCompletion: unpack_shm_complete}
+        self.errors = {self.BadShmSeg: "BadShmSeg"}
+        self.commands = {self.code: "Shm"}
+
+    async def version(self):
+        payload = pack_shm_version(self.code)
+        reply = await self.display.write_read(payload, unpack_shm_version)
+        return reply
+
+    async def attach(self, shm_id, read_only=True):
+        rid = self.display.resources.allocate()
+        payload = pack_shm_attach(self.code, rid, shm_id, read_only)
+        self.display.write(payload)
+        return rid
+
+    async def attach_fd(self, fd, read_only=True):
+        rid = self.display.resources.allocate()
+        payload = pack_shm_attach_fd(self.code, rid, read_only)
+        sock = self.display.connection.socket._sock
+        socket.send_fds(sock, (payload,), (fd,))
+        return rid
+
+    async def put_image(
+        self,
+        wnd,
+        gc,
+        total_width,
+        total_height,
+        src_x,
+        src_y,
+        src_width,
+        src_height,
+        dst_x,
+        dst_y,
+        depth,
+        send_event,
+        rid,
+        offset,
+    ):
+        payload = pack_shm_put_image(
+            self.code,
+            int(wnd),
+            int(gc),
+            total_width,
+            total_height,
+            src_x,
+            src_y,
+            src_width,
+            src_height,
+            dst_x,
+            dst_y,
+            depth,
+            send_event,
+            rid,
+            offset,
+        )
+        self.display.write(payload)
+
+
+EXTENSIONS = {"MIT-SHM": SharedMemory}
+
+
+class Display:
+    def __init__(self, connection, config):
+        self.connection = connection
+        self.config = config
+        self.info = None
+        self.resources = None
+        self.screens = None
+        self.events = {Event.ClientMessage: unpack_client_message}
+        self.commands = {cmd: cmd.name for cmd in Command}
+        self.requests = asyncio.Queue()
+        self.listeners = set()
+        self._atom_cache = {}
+        self._extensions_cache = None
+        self._task = None
+
+    async def __aenter__(self):
+        await self.setup()
+        return self
+
+    async def __aexit__(self, *args):
+        await self.aclose()
+
+    def close(self):
+        if self._task:
+            self._task.cancel()
+        self.connection.close()
+
+    async def aclose(self):
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+            self._task = None
+        await self.connection.aclose()
+
+    def write(self, payload):
+        code = payload[0]
+        cmd_name = code
+        if code in {LITTLE_ENDIAN, BIG_ENDIAN}:
+            cmd_name = "Setup"
+        else:
+            cmd_name = self.commands.get(code)
+        log.debug("WRITE: %s", cmd_name)
+        self.connection.write(payload)
+
+    async def read(self, n=-1):
+        return await self.connection.read(n)
+
+    async def readexactly(self, n):
+        payload = await self.connection.readexactly(n)
+        log.debug("READ: %d", len(payload))
+        return payload
+
+    def write_read(self, payload, callback):
+        future = asyncio.Future()
+        code = payload[0]
+        cmd = Command(code).name if code in Command else code
+        self.requests.put_nowait((callback, future, cmd))
+        self.write(payload)
+        return future
+
+    async def flush(self):
+        await self.connection.flush()
+
+    async def setup(self):
+        entry = auth(self.connection)
+        req = pack_setup(entry["name"], entry["data"])
+        self.write(req)
+        await self.flush()
+        info = await read_setup(self)
+        self.info = info
+        self.resources = ResourceManager(info["resource_id_base"], info["resource_id_mask"])
+        self.screens = [Screen(self, sinfo) for sinfo in info["screens"]]
+        self._task = asyncio.create_task(self._loop())
+        return info
+
+    async def intern_atom(self, name, only_if_exists=False):
+        payload = pack_intern_atom(name, only_if_exists)
+        reply = await self.write_read(payload, unpack_intern_atom)
+        return reply["atom"]
+
+    async def _list_extensions(self):
+        payload = pack_list_extensions()
+        reply = await self.write_read(payload, unpack_list_extensions)
+        return reply["extensions"]
+
+    async def _query_extension(self, name):
+        payload = pack_query_extension(name)
+        reply = await self.write_read(payload, unpack_query_extension)
+        return reply
+
+    async def list_extensions(self):
+        if self._extensions_cache is None:
+            self._extensions_cache = dict.fromkeys(await self._list_extensions())
+        return set(self._extensions_cache)
+
+    async def query_extension(self, name):
+        extensions = await self.list_extensions()
+        if name in extensions:
+            if ext := self._extensions_cache[name]:
+                return ext
+            ext = await self._query_extension(name)
+            if klass := EXTENSIONS.get(name):
+                ext = klass(self, ext)
+                self._extensions_cache[name] = ext
+                self.events.update(ext.events)
+                self.commands.update(ext.commands)
+            return ext
+
+    async def get_atom(self, name, only_if_exists=False):
+        if name in self._atom_cache:
+            return self._atom_cache[name]
+
+        atom = await self.intern_atom(name, only_if_exists)
+        if atom != NONE:  # don't cache NONE responses in case someone creates this later
+            self._atom_cache[name] = atom
+        return atom
+
+    def default_screen(self) -> Screen:
+        return self.screens[self.config["screen"]]
+
+    async def create_window(self, *args, **kwargs) -> Window:
+        parent = self.default_screen().root
+        return await parent.create_window(*args, **kwargs)
+
+    def add_listener(self, listener):
+        self.listeners.add(listener)
+
+    async def _loop(self):
+        buffer = b""
+        while True:
+            if not (data := await self.read(16 * 1024)):
+                log.info("Connection closed")
+                return
+            buffer += data
+            packet_type = buffer[0]
+            if packet_type in PacketType:
+                if packet_type == PacketType.Reply:
+                    decode, future, cmd = await self.requests.get()
+                    reply, offset = decode(buffer, 0)
+                    log.debug("REPLY: %s", cmd)
+                    future.set_result(reply)
+                elif packet_type == PacketType.Error:
+                    error, offset = unpack_error(buffer)
+                    log.warning("ERROR: %s", error)
+            else:
+                event, offset = unpack_event(self.events, buffer)
+                for listener in self.listeners:
+                    await listener.put(event)
+                log.debug("EVENT: %s", event["name"])
+            buffer = buffer[offset:]
+
+
+def get_display_config(uri: str) -> dict:
+    if (match := DISPLAY_RE.match(uri)) is None:
+        raise ValueError(f"Invalid DISPLAY {uri!r}")
+    display = match.groupdict()
+    protocol = display.get("protocol")
+    if protocol:
+        if protocol == "unix" and display["host"]:
+            raise ValueError(f"Invalid DISPLAY {uri!r}")
+    else:
+        protocol = "tcp" if display["host"] else "unix"
+        display["protocol"] = protocol
+    display["port"] = int(display["port"])
+    display["uri"] = uri
+    display["screen"] = display["screen"] or 0
+    return display
+
+
+async def get_display(uri: str | None = None) -> Display:
+    uri = uri or os.environ["DISPLAY"]
+    config = get_display_config(uri)
+    connection = await open_connection(config)
+    display = Display(connection, config)
+    return display
+
+
+auth = Xauthority()