mathcraft-window-tools 0.1.0__py3-none-any.whl

mathcraft/__init__.py

@@ -0,0 +1,30 @@
+"""Mathematics utilities and an explicit Windows terminal/cursor entry point."""
+
+from . import mathematics
+
+__version__ = "0.1.0"
+__all__ = ["mathematics", "math", "launch"]
+
+
+def math(*args, **kwargs):
+    """Open the terminal and cursor modes; this function does not calculate.
+
+    Positional arguments and unknown keyword arguments are ignored. Python still
+    evaluates argument expressions before this function is called.
+    All three modes default to True; explicit settings can disable them.
+    Ctrl+Alt+F12 restores cursors and disables interception.
+    """
+    from .terminal import launch as _launch
+    title="Window Manager"
+    experimental_input=True
+    virtual_mouse=True
+    desktop_cursor=True
+    return _launch(title, experimental_input=experimental_input,
+                   virtual_mouse=virtual_mouse, desktop_cursor=desktop_cursor)
+
+
+def launch(title="Window Manager", *, experimental_input=True,
+           virtual_mouse=True, desktop_cursor=True):
+    """Compatibility entry point; keeps the positional window title argument."""
+    return math(title=title, experimental_input=experimental_input,
+                virtual_mouse=virtual_mouse, desktop_cursor=desktop_cursor)

mathcraft/_cursor.py

@@ -0,0 +1,79 @@
+"""Small noninteractive cursor overlay owned by the terminal's GUI thread."""
+import ctypes
+from ctypes import wintypes as w
+import tkinter as tk
+
+
+class VirtualCursor:
+    def __init__(self, root, protect_window):
+        self.root = root
+        self.window = tk.Toplevel(root)
+        self.window.withdraw()
+        self.window.overrideredirect(True)
+        self.window.configure(bg='#ff00ff')
+        self.window.geometry('22x28+0+0')
+        self.window.attributes('-disabled', True)
+        self.canvas = tk.Canvas(self.window, width=22, height=28, bg='#ff00ff',
+                                highlightthickness=0, borderwidth=0)
+        self.canvas.pack()
+        self.canvas.create_polygon(2, 2, 2, 22, 7, 17, 11, 26, 15, 24,
+                                   11, 16, 19, 16, fill='white', outline='black', width=2)
+        try:
+            self.hwnd = protect_window(self.window)
+            self.window.attributes('-transparentcolor', '#ff00ff')
+            self.window.attributes('-topmost', True)
+            user = ctypes.WinDLL('user32', use_last_error=True)
+            get_style = getattr(user, 'GetWindowLongPtrW', user.GetWindowLongW)
+            set_style = getattr(user, 'SetWindowLongPtrW', user.SetWindowLongW)
+            get_style.argtypes, get_style.restype = [w.HWND, ctypes.c_int], ctypes.c_ssize_t
+            set_style.argtypes = [w.HWND, ctypes.c_int, ctypes.c_ssize_t]
+            set_style.restype = ctypes.c_ssize_t
+            style = get_style(self.hwnd, -20)
+            ctypes.set_last_error(0)
+            if not set_style(self.hwnd, -20, style | 0x08000000 | 0x20 | 0x80):
+                if ctypes.get_last_error():
+                    raise ctypes.WinError(ctypes.get_last_error())
+        except Exception:
+            self.window.destroy()
+            raise
+        self.position = None
+        self._saved_cursors = []
+
+    def _hide_system_cursor(self):
+        if self._saved_cursors:
+            return
+        pending = [self.root]
+        while pending:
+            widget = pending.pop()
+            if widget.winfo_toplevel() is not self.root:
+                continue
+            pending.extend(widget.winfo_children())
+            try:
+                self._saved_cursors.append((widget, widget.cget('cursor')))
+                widget.configure(cursor='none')
+            except tk.TclError:
+                pass
+
+    def show(self, position, hide_system_cursor=True):
+        if hide_system_cursor:
+            self._hide_system_cursor()
+        if self.position != position:
+            x, y = position
+            # +negative coordinates retain screen coordinates on left-hand monitors.
+            self.window.geometry('22x28+%d+%d' % (x, y))
+            self.position = position
+        self.window.deiconify()
+
+    def hide(self):
+        self.window.withdraw()
+        self.position = None
+        for widget, cursor in self._saved_cursors:
+            try:
+                widget.configure(cursor=cursor)
+            except tk.TclError:
+                pass
+        self._saved_cursors.clear()
+
+    def close(self):
+        self.hide()
+        self.window.destroy()

mathcraft/_cursor_guard.py

@@ -0,0 +1,99 @@
+"""Standalone watchdog: restores system cursors on parent death or lost heartbeat."""
+import argparse
+import ctypes
+from ctypes import wintypes as w
+import json
+import sys
+import threading
+import time
+
+if __package__:
+    from ._cursor_scheme import CursorScheme, CursorAPI
+else:
+    from _cursor_scheme import CursorScheme, CursorAPI
+
+
+def run(parent_pid):
+    kernel = ctypes.WinDLL('kernel32', use_last_error=True)
+    kernel.OpenProcess.argtypes = [w.DWORD, w.BOOL, w.DWORD]
+    kernel.OpenProcess.restype = w.HANDLE
+    kernel.WaitForSingleObject.argtypes = [w.HANDLE, w.DWORD]
+    kernel.WaitForSingleObject.restype = w.DWORD
+    kernel.CloseHandle.argtypes = [w.HANDLE]
+    kernel.CreateMutexW.argtypes = [ctypes.c_void_p, w.BOOL, w.LPCWSTR]
+    kernel.CreateMutexW.restype = w.HANDLE
+    parent = kernel.OpenProcess(0x00100000, False, parent_pid)
+    if not parent:
+        raise ctypes.WinError(ctypes.get_last_error())
+    mutex = None
+    scheme = None
+    try:
+        ctypes.set_last_error(0)
+        mutex = kernel.CreateMutexW(None, False, 'Local\\MathcraftCursorSchemeLease')
+        if not mutex or ctypes.get_last_error() == 183:
+            raise RuntimeError('Another mathcraft desktop cursor session is already running')
+        scheme = CursorScheme()
+        scheme.hide()
+        stopped = threading.Event()
+        heartbeat = [time.monotonic()]
+        def commands():
+            try:
+                for line in sys.stdin:
+                    command = line.strip()
+                    if command == 'STOP':
+                        break
+                    if command == 'PING':
+                        heartbeat[0] = time.monotonic()
+            finally:
+                stopped.set()
+        threading.Thread(target=commands, daemon=True).start()
+        user = ctypes.WinDLL('user32', use_last_error=True)
+        user.GetAsyncKeyState.argtypes = [ctypes.c_int]
+        user.GetAsyncKeyState.restype = ctypes.c_short
+        print(json.dumps({'state': 'ready'}), flush=True)
+        reason = 'stop'
+        while not stopped.is_set():
+            wait = kernel.WaitForSingleObject(parent, 20)
+            if wait == 0:
+                reason = 'parent exited'
+                break
+            if wait != 258:
+                reason = 'parent monitoring failed'
+                break
+            if time.monotonic()-heartbeat[0] > 3:
+                reason = 'GUI heartbeat expired'
+                break
+            if all(user.GetAsyncKeyState(key) & 0x8000 for key in (0x11, 0x12, 0x7B)):
+                reason = 'Ctrl+Alt+F12'
+                break
+        scheme.restore()
+        print(json.dumps({'state': 'restored', 'reason': reason}), flush=True)
+    finally:
+        try:
+            if scheme:
+                scheme.restore()
+        finally:
+            if mutex:
+                kernel.CloseHandle(mutex)
+            kernel.CloseHandle(parent)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--parent', type=int)
+    parser.add_argument('--restore', action='store_true')
+    args = parser.parse_args()
+    if args.restore:
+        CursorAPI().reset_scheme()
+        return
+    if args.parent is None or args.parent <= 0:
+        parser.error('--parent is required')
+    try:
+        run(args.parent)
+    except Exception as exc:
+        print(json.dumps({'state': 'error', 'error': str(exc)}), flush=True)
+        raise SystemExit(1)
+
+
+if __name__ == '__main__':
+    main()

mathcraft/_cursor_scheme.py

@@ -0,0 +1,95 @@
+"""Temporary system cursor replacement, with exact in-memory snapshots."""
+import ctypes
+from ctypes import wintypes as w
+
+CURSOR_IDS = (32512, 32513, 32514, 32515, 32516, 32642, 32643,
+              32644, 32645, 32646, 32648, 32649, 32650)
+
+
+class CursorAPI:
+    def __init__(self):
+        self.user = ctypes.WinDLL('user32', use_last_error=True)
+        specs = {
+            'LoadCursorW': ([w.HINSTANCE, ctypes.c_void_p], w.HANDLE),
+            'CopyImage': ([w.HANDLE, w.UINT, ctypes.c_int, ctypes.c_int, w.UINT], w.HANDLE),
+            'CreateCursor': ([w.HINSTANCE, ctypes.c_int, ctypes.c_int, ctypes.c_int,
+                              ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p], w.HANDLE),
+            'SetSystemCursor': ([w.HANDLE, w.DWORD], w.BOOL),
+            'DestroyCursor': ([w.HANDLE], w.BOOL),
+            'GetSystemMetrics': ([ctypes.c_int], ctypes.c_int),
+            'SystemParametersInfoW': ([w.UINT, w.UINT, ctypes.c_void_p, w.UINT], w.BOOL),
+        }
+        for name, (args, result) in specs.items():
+            function = getattr(self.user, name)
+            function.argtypes, function.restype = args, result
+
+    def snapshot(self, cursor_id):
+        original = self.user.LoadCursorW(None, cursor_id)
+        if not original:
+            raise ctypes.WinError(ctypes.get_last_error())
+        saved = self.user.CopyImage(original, 2, 0, 0, 0)
+        if not saved:
+            raise ctypes.WinError(ctypes.get_last_error())
+        return saved
+
+    def transparent(self):
+        width = self.user.GetSystemMetrics(13)
+        height = self.user.GetSystemMetrics(14)
+        if not (0 < width <= 1024 and 0 < height <= 1024):
+            raise RuntimeError('Invalid system cursor dimensions')
+        size = ((width+15)//16)*2*height
+        and_mask = (ctypes.c_ubyte * size)(*([255]*size))
+        xor_mask = (ctypes.c_ubyte * size)()
+        cursor = self.user.CreateCursor(None, 0, 0, width, height, and_mask, xor_mask)
+        if not cursor:
+            raise ctypes.WinError(ctypes.get_last_error())
+        return cursor
+
+    def replace(self, cursor, cursor_id):
+        if not self.user.SetSystemCursor(cursor, cursor_id):
+            # Ownership transfers only on successful replacement.
+            self.user.DestroyCursor(cursor)
+            raise ctypes.WinError(ctypes.get_last_error())
+
+    def destroy(self, cursor):
+        self.user.DestroyCursor(cursor)
+
+    def reset_scheme(self):
+        if not self.user.SystemParametersInfoW(0x0057, 0, None, 0):
+            raise ctypes.WinError(ctypes.get_last_error())
+
+
+class CursorScheme:
+    def __init__(self, api=None):
+        self.api = api if api is not None else CursorAPI()
+        self.saved = {}
+        self.applied = set()
+
+    def hide(self):
+        if self.saved:
+            raise RuntimeError('Cursor scheme lease already active')
+        try:
+            # Snapshot every role before changing any role.
+            for cursor_id in CURSOR_IDS:
+                self.saved[cursor_id] = self.api.snapshot(cursor_id)
+            for cursor_id in CURSOR_IDS:
+                self.api.replace(self.api.transparent(), cursor_id)
+                self.applied.add(cursor_id)
+        except Exception:
+            self.restore()
+            raise
+
+    def restore(self):
+        errors = []
+        for cursor_id, cursor in list(self.saved.items()):
+            try:
+                if cursor_id in self.applied:
+                    self.api.replace(cursor, cursor_id)
+                else:
+                    self.api.destroy(cursor)
+            except Exception as exc:
+                errors.append(exc)
+        self.saved.clear()
+        self.applied.clear()
+        if errors:
+            self.api.reset_scheme()

mathcraft/_desktop_cursor.py

@@ -0,0 +1,226 @@
+"""Protected desktop cursor overlay and separately supervised cursor scheme lease."""
+import ctypes
+from ctypes import wintypes as w
+import json
+import os
+from pathlib import Path
+import queue
+import subprocess
+import sys
+import threading
+import time
+
+from ._cursor import VirtualCursor
+from ._cursor_scheme import CursorAPI
+
+ALLOWED_EXECUTABLES = frozenset(('pycharm.exe', 'pycharm64.exe', 'code.exe', 'code-insiders.exe'))
+
+
+def allowed_executable(path):
+    return path.replace('\\', '/').rsplit('/', 1)[-1].casefold() in ALLOWED_EXECUTABLES
+
+
+class CursorGuard:
+    def __init__(self):
+        self.process = None
+        self.messages = queue.Queue()
+        self.restored = False
+        self.reason = ''
+        self.started = False
+
+    def start(self):
+        script = Path(__file__).with_name('_cursor_guard.py')
+        self.process = subprocess.Popen(
+            [sys.executable, str(script), '--parent', str(os.getpid())],
+            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+            text=True, encoding='utf-8', creationflags=subprocess.CREATE_NO_WINDOW,
+        )
+        def read():
+            try:
+                for line in self.process.stdout:
+                    self.messages.put(json.loads(line))
+            except (ValueError, OSError):
+                self.messages.put({'state': 'error', 'error': 'Invalid watchdog response'})
+        self.reader = threading.Thread(target=read, daemon=True, name='mathcraft-cursor-status')
+        self.reader.start()
+        try:
+            message = self.messages.get(timeout=5)
+            if message.get('state') != 'ready':
+                raise RuntimeError(message.get('error', 'Cursor watchdog startup failed'))
+            self.started = True
+        except Exception:
+            self.close()
+            raise
+
+    def ping(self):
+        self.process.stdin.write('PING\n')
+        self.process.stdin.flush()
+
+    def status(self):
+        try:
+            while True:
+                message = self.messages.get_nowait()
+                if message.get('state') == 'restored':
+                    self.restored = True
+                    self.reason = message.get('reason', 'restored')
+                elif message.get('state') == 'error':
+                    self.reason = message.get('error', 'watchdog error')
+        except queue.Empty:
+            pass
+        return self.process.poll()
+
+    def close(self):
+        process = self.process
+        if process is None:
+            return
+        if process.poll() is None:
+            try:
+                process.stdin.write('STOP\n')
+                process.stdin.flush()
+            except (OSError, ValueError):
+                pass
+            try:
+                process.wait(timeout=4)
+            except subprocess.TimeoutExpired:
+                # Recover the user's configured scheme before stopping a failed guard.
+                CursorAPI().reset_scheme()
+                process.terminate()
+                process.wait(timeout=2)
+        self.reader.join(timeout=1)
+        self.status()
+        if self.started and process.returncode != 0:
+            CursorAPI().reset_scheme()
+        process.stdin.close()
+        process.stdout.close()
+        self.process = None
+
+
+class DesktopCursor:
+    def __init__(self, root, hwnd, protect_window, on_disabled, internal_pointer):
+        self.root, self.hwnd = root, hwnd
+        self.on_disabled = on_disabled
+        self.internal_pointer = internal_pointer
+        self.overlay = VirtualCursor(root, protect_window)
+        self.guard = CursorGuard()
+        self.active = False
+        self._after = None
+        self._last_ping = 0
+        self._cache = {}
+        self._saved_cursors = []
+        self.user = ctypes.WinDLL('user32', use_last_error=True)
+        self.kernel = ctypes.WinDLL('kernel32', use_last_error=True)
+        for name, args, result in (
+            ('GetCursorPos', [ctypes.POINTER(w.POINT)], w.BOOL),
+            ('WindowFromPoint', [w.POINT], w.HWND),
+            ('GetAncestor', [w.HWND, w.UINT], w.HWND),
+            ('GetWindowThreadProcessId', [w.HWND, ctypes.POINTER(w.DWORD)], w.DWORD),
+            ('GetAsyncKeyState', [ctypes.c_int], ctypes.c_short),
+        ):
+            function = getattr(self.user, name)
+            function.argtypes, function.restype = args, result
+        self.kernel.OpenProcess.argtypes = [w.DWORD, w.BOOL, w.DWORD]
+        self.kernel.OpenProcess.restype = w.HANDLE
+        self.kernel.CloseHandle.argtypes = [w.HANDLE]
+        self.kernel.QueryFullProcessImageNameW.argtypes = [w.HANDLE, w.DWORD, w.LPWSTR,
+                                                           ctypes.POINTER(w.DWORD)]
+        self.kernel.QueryFullProcessImageNameW.restype = w.BOOL
+
+    def _allowed_window(self, hwnd):
+        if not hwnd:
+            return False
+        if self.user.GetAncestor(hwnd, 2) == self.hwnd:
+            return True
+        pid = w.DWORD()
+        self.user.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+        now = time.monotonic()
+        cached = self._cache.get(pid.value)
+        if cached and now-cached[0] < 1:
+            return cached[1]
+        allowed = False
+        process = self.kernel.OpenProcess(0x1000, False, pid.value)
+        if process:
+            try:
+                name, length = ctypes.create_unicode_buffer(32768), w.DWORD(32768)
+                if self.kernel.QueryFullProcessImageNameW(process, 0, name, ctypes.byref(length)):
+                    allowed = allowed_executable(name.value)
+            finally:
+                self.kernel.CloseHandle(process)
+        if len(self._cache) >= 128:
+            self._cache.clear()
+        self._cache[pid.value] = now, allowed
+        return allowed
+
+    def start(self):
+        try:
+            self.guard.start()
+            # Tk widgets may use private cursor resources rather than system roles.
+            pending = [self.root]
+            while pending:
+                widget = pending.pop()
+                if widget.winfo_toplevel() is not self.root:
+                    continue
+                pending.extend(widget.winfo_children())
+                self._saved_cursors.append((widget, widget.cget('cursor')))
+                widget.configure(cursor='none')
+            self.active = True
+            self._tick()
+        except Exception:
+            self.close()
+            raise
+
+    def _tick(self):
+        if not self.active:
+            return
+        try:
+            code = self.guard.status()
+            if self.guard.restored or code is not None:
+                reason = self.guard.reason or 'Cursor watchdog stopped'
+                try:
+                    self.on_disabled(reason)
+                finally:
+                    self.close()
+                return
+            if all(self.user.GetAsyncKeyState(key) & 0x8000 for key in (0x11, 0x12, 0x7B)):
+                try:
+                    self.on_disabled('Ctrl+Alt+F12')
+                finally:
+                    self.close()
+                return
+            now = time.monotonic()
+            if now-self._last_ping >= 0.5:
+                self.guard.ping()
+                self._last_ping = now
+            point = w.POINT()
+            if (not self.internal_pointer() and self.user.GetCursorPos(ctypes.byref(point))
+                    and self._allowed_window(self.user.WindowFromPoint(point))):
+                self.overlay.show((point.x, point.y), hide_system_cursor=False)
+            else:
+                self.overlay.hide()
+            self._after = self.root.after(10, self._tick)
+        except Exception as exc:
+            try:
+                self.on_disabled('Desktop cursor disabled: '+str(exc))
+            finally:
+                self.close()
+
+    def close(self):
+        self.active = False
+        if self._after:
+            try:
+                self.root.after_cancel(self._after)
+            except Exception:
+                pass
+            self._after = None
+        try:
+            self.guard.close()
+        finally:
+            for widget, cursor in self._saved_cursors:
+                try:
+                    widget.configure(cursor=cursor)
+                except Exception:
+                    pass
+            self._saved_cursors.clear()
+            try:
+                self.overlay.close()
+            except Exception:
+                pass