Files
NX2navi/launcher/winsys.py
epicmeme546 44d4095094 Add Customize Launcher: colour schemes, a background picture of the player's own, animations and sound effects.
The launcher's home screen has a Customize Launcher row. Color Scheme steps through six schemes (Kokiri Forest, the colours so far, Death Mountain, Zora's Domain, Gerudo Valley, Temple of Time and Shadow Temple): each is the first scheme with its woods, accents, backdrop and glow turned to other hues, so all keep the same light and dark steps and the same text. Background takes a picture file, cuts it to the window's shape and keeps a fitted copy in data/background.npy; Background Dimming darkens it and the panels turn a little see-through over it. Animations (on by default) make the cursor glide between rows, a new screen slide in, sparks drift over the backdrop and Navi bob in the title band; they move by the time that passed and stand still while the window is hidden. Sounds are short chimes made from sine tones, off until the player picks a loudness.

Redrawing in another scheme takes about a third of a second: the blurred masks and the noise, which no colour changes, are kept, and compositing onto a solid picture is a plain mix.

The selftest's screen capture passed window handles as plain ints, which failed for a handle above 2^31 and left some screens without their picture; its calls are typed now.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-09 23:27:02 -05:00

405 lines
17 KiB
Python

"""What the launcher needs from the operating system: crisp drawing on scaled displays, the game's fonts for this
process only, starting the game and the stub, shortcuts, the uninstall entry and a gamepad. Windows first; the
other branches exist so the window can be developed and tested on Linux."""
import ctypes
import os
import subprocess
import sys
from pathlib import Path
CREATE_NO_WINDOW = 0x08000000
DETACHED_PROCESS = 0x00000008
CREATE_NEW_PROCESS_GROUP = 0x00000200
UNINSTALL_KEY = r'Software\Microsoft\Windows\CurrentVersion\Uninstall\NX2navi'
def dpi_aware():
"""Draw at the display's real resolution instead of letting Windows stretch a 96-dpi window (blurry)."""
if os.name != 'nt':
return
try:
ctypes.windll.shcore.SetProcessDpiAwareness(1)
except (AttributeError, OSError):
try:
ctypes.windll.user32.SetProcessDPIAware()
except (AttributeError, OSError):
pass
def app_id():
"""Group the window under the launcher's own taskbar icon rather than python's."""
if os.name == 'nt':
try:
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID('NX2navi.Launcher')
except (AttributeError, OSError):
pass
GWL_STYLE, GWL_EXSTYLE = -16, -20
WS_MINIMIZEBOX, WS_SYSMENU = 0x00020000, 0x00080000
WS_EX_APPWINDOW, WS_EX_TOOLWINDOW = 0x00040000, 0x00000080
def _hwnd(root):
"""The Win32 window of a Tk toplevel (the wrapper around Tk's child window)."""
user32 = ctypes.windll.user32
user32.GetParent.restype = ctypes.c_void_p
user32.GetParent.argtypes = [ctypes.c_void_p]
return user32.GetParent(root.winfo_id()) or root.winfo_id()
def _post(hwnd, msg, wparam, lparam):
"""Queue a message for the window instead of sending it. A sent message runs the window's handler inside this
ctypes call, which has released Python's lock; when that handler dispatches Tk events (the move loop of a title
bar drag does), Tk calls back into Python without the lock and Python aborts. A posted message is handled by Tk's
own event loop, where calling back into Python is allowed."""
user32 = ctypes.windll.user32
user32.PostMessageW.restype = ctypes.c_int
user32.PostMessageW.argtypes = [ctypes.c_void_p, ctypes.c_uint, ctypes.c_size_t, ctypes.c_ssize_t]
return user32.PostMessageW(hwnd, msg, wparam, lparam)
def frameless(root):
"""Windows: drop the system title bar (the window draws its own), but keep a taskbar button, Alt+Tab, minimise
from the taskbar and Alt+F4. False elsewhere, where the window keeps its frame."""
if os.name != 'nt':
return False
try:
root.overrideredirect(True)
root.update_idletasks()
user32 = ctypes.windll.user32
get, put = user32.GetWindowLongPtrW, user32.SetWindowLongPtrW
get.restype, get.argtypes = ctypes.c_ssize_t, [ctypes.c_void_p, ctypes.c_int]
put.restype, put.argtypes = ctypes.c_ssize_t, [ctypes.c_void_p, ctypes.c_int, ctypes.c_ssize_t]
hwnd = _hwnd(root)
put(hwnd, GWL_EXSTYLE, (get(hwnd, GWL_EXSTYLE) & ~WS_EX_TOOLWINDOW) | WS_EX_APPWINDOW)
put(hwnd, GWL_STYLE, get(hwnd, GWL_STYLE) | WS_MINIMIZEBOX | WS_SYSMENU)
root.withdraw() # the taskbar takes a changed window style only when the window is shown again
root.after(10, root.deiconify)
return True
except (AttributeError, OSError, Exception):
return False
def minimize(root):
"""Tk refuses to iconify a window without a frame, so ask Windows; asynchronously, for the reason in _post."""
if os.name == 'nt':
ctypes.windll.user32.ShowWindowAsync(ctypes.c_void_p(_hwnd(root)), 6) # SW_MINIMIZE
else:
root.iconify()
def start_drag(root):
"""Windows: let the system move the window from the mouse's current press (as on a title bar, with snapping).
False elsewhere: the caller moves the window itself."""
if os.name != 'nt':
return False
try:
ctypes.windll.user32.ReleaseCapture()
return bool(_post(_hwnd(root), 0x00A1, 2, 0)) # WM_NCLBUTTONDOWN, HTCAPTION
except (AttributeError, OSError):
return False
_ICONS = []
def set_window_icon(root, ico):
"""Windows: the window's and the taskbar button's icon, straight from an .ico (the large and the small size)."""
if os.name != 'nt':
return False
try:
user32 = ctypes.windll.user32
user32.LoadImageW.restype = ctypes.c_void_p
user32.LoadImageW.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_uint, ctypes.c_int, ctypes.c_int,
ctypes.c_uint]
hwnd = _hwnd(root)
for which, (mx, my) in ((1, (11, 12)), (0, (49, 50))): # ICON_BIG: SM_CXICON; ICON_SMALL: SM_CXSMICON
h = user32.LoadImageW(None, str(ico), 1, user32.GetSystemMetrics(mx), user32.GetSystemMetrics(my),
0x10) # IMAGE_ICON, LR_LOADFROMFILE
if h:
_ICONS.append(h)
_post(hwnd, 0x0080, which, h) # WM_SETICON
return True
except (AttributeError, OSError):
return False
def register_font(path):
"""Make a font file usable by this process only (Tk then finds it by family name). True on success."""
path = str(path)
if os.name == 'nt':
try:
return ctypes.windll.gdi32.AddFontResourceExW(ctypes.c_wchar_p(path), 0x10, None) > 0 # FR_PRIVATE
except (AttributeError, OSError):
return False
try:
fc = ctypes.CDLL('libfontconfig.so.1')
fc.FcConfigAppFontAddFile.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
return bool(fc.FcConfigAppFontAddFile(None, path.encode()))
except OSError:
return False
def open_path(path):
path = str(path)
if os.name == 'nt':
os.startfile(path) # noqa: S606 — opens a folder in Explorer
else:
subprocess.Popen(['xdg-open', path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
def reveal(path):
"""Show a file in its folder, selected in Explorer (a file to drag into a bug report); elsewhere open the folder."""
path = Path(path)
if os.name == 'nt':
subprocess.Popen(['explorer', f'/select,{path}']) # noqa: S603, S607
else:
open_path(path.parent)
KNOWN_FOLDERS = {'downloads': '{374DE290-123F-4565-9164-39C4925E467B}',
'desktop': '{B4BFCC3A-DB2C-424C-B029-7FE99A87C641}',
'pictures': '{33E28130-4E1E-4676-835A-98395C3BC3BB}'}
def known_folder(name):
"""Windows: the folder the shell keeps for name ('downloads', 'desktop', 'pictures'), also when the player moved it to another
drive; None elsewhere or when the shell names none."""
if os.name != 'nt' or name not in KNOWN_FOLDERS:
return None
try:
from ctypes import wintypes
class GUID(ctypes.Structure):
_fields_ = [('d1', wintypes.DWORD), ('d2', wintypes.WORD), ('d3', wintypes.WORD),
('d4', ctypes.c_ubyte * 8)]
ole32, shell32 = ctypes.WinDLL('ole32'), ctypes.WinDLL('shell32') # private handles: argtypes stay here
ole32.CLSIDFromString.argtypes = (wintypes.LPCWSTR, ctypes.POINTER(GUID))
ole32.CoTaskMemFree.argtypes = (ctypes.c_void_p,)
shell32.SHGetKnownFolderPath.argtypes = (ctypes.POINTER(GUID), wintypes.DWORD, wintypes.HANDLE,
ctypes.POINTER(ctypes.c_void_p))
g, out = GUID(), ctypes.c_void_p()
if ole32.CLSIDFromString(KNOWN_FOLDERS[name], ctypes.byref(g)) != 0:
return None
if shell32.SHGetKnownFolderPath(ctypes.byref(g), 0, None, ctypes.byref(out)) != 0:
return None
try:
return Path(ctypes.wstring_at(out.value))
finally:
ole32.CoTaskMemFree(out)
except (AttributeError, OSError):
return None
def start_game(exe):
"""Start the game from its own folder; returns the process to watch. ocarina.exe is a console program and the
launcher has no console, so without CREATE_NO_WINDOW Windows opened an empty console window beside the game,
titled with the exe's path. With it the game still has a console (hidden), which its restarts inherit."""
exe = Path(exe)
flags = {'creationflags': CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP} if os.name == 'nt' \
else {'start_new_session': True}
return subprocess.Popen([str(exe)], cwd=str(exe.parent), stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL, close_fds=True, **flags)
def start_detached(cmd, cwd=None):
flags = {'creationflags': DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP} if os.name == 'nt' \
else {'start_new_session': True}
subprocess.Popen(cmd, cwd=cwd, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
close_fds=True, **flags)
def restart(layout, args=()):
"""Start the launcher again through its stub (which swaps in a staged Python and starts app/current.txt's
version). False in a checkout, which has no stub."""
if not layout.stub.is_file():
return False
start_detached([str(layout.stub), *args], cwd=str(layout.root))
return True
def stub_run(layout, args, timeout=30):
"""Run the stub for one of its own commands (shortcuts); True when it succeeded."""
if not layout.stub.is_file():
return False
flags = {'creationflags': CREATE_NO_WINDOW} if os.name == 'nt' else {}
try:
return subprocess.run([str(layout.stub), *args], timeout=timeout, capture_output=True, **flags).returncode == 0
except (OSError, subprocess.TimeoutExpired):
return False
def desktop_shortcut(layout, enable):
return stub_run(layout, ['--desktop-shortcut', 'on' if enable else 'off'])
def keep_awake(on):
if os.name != 'nt':
return
try:
ES_CONTINUOUS, ES_SYSTEM_REQUIRED = 0x80000000, 0x00000001
ctypes.windll.kernel32.SetThreadExecutionState(ES_CONTINUOUS | (ES_SYSTEM_REQUIRED if on else 0))
except (AttributeError, OSError):
pass
def background_thread():
"""Windows: put the calling thread in background mode (SetThreadPriority THREAD_MODE_BACKGROUND_BEGIN), which
lowers its processor, disk and memory priority, so work done beside the game takes only what the game leaves.
False where that is not possible."""
if os.name != 'nt':
return False
try:
from ctypes import wintypes
k = ctypes.WinDLL('kernel32') # a private handle: the argument types set here touch no other caller
k.GetCurrentThread.restype = wintypes.HANDLE
k.SetThreadPriority.argtypes = (wintypes.HANDLE, ctypes.c_int)
return bool(k.SetThreadPriority(k.GetCurrentThread(), 0x00010000))
except (AttributeError, OSError):
return False
# What the launcher puts in its folder (launcher/paths.py, the stub's python.next and python.old-<n>). Uninstall deletes
# only these: the default game folder is <root>\game, and a folder given to the setup with --dest may hold other things.
OWNED = ('NX2navi.exe', 'app', 'python', 'python.next', 'pydeps', 'data', 'toolchain')
def uninstall_plan(layout, remove_game=''):
"""(paths to delete with all they hold, folders to delete only when that left them empty), in order. A kept game
folder stays whether or not it lies inside the launcher's folder."""
root = Path(layout.root)
gone = [Path(remove_game)] if remove_game else []
gone += [root / n for n in OWNED]
try:
gone += sorted(p for p in root.glob('python.old-*'))
except OSError:
pass
empty = [root]
if Path(layout.toolchain).parent != root: # the toolchain went to C:\NX2navi (launcher/paths.py ansi_safe)
gone.append(Path(layout.toolchain))
empty.append(Path(layout.toolchain).parent)
return gone, empty
def uninstall_script(gone, empty):
"""The cmd.exe line that deletes them once the launcher has exited: a file with del, a folder with rmdir /s, the
folders that must be empty with a plain rmdir (which leaves a folder that still holds something). A path holding
% is left out: cmd.exe expands %NAME% even inside quotes, so a folder named C:\\%HOMEPATH% would delete another."""
steps = ['ping -n 3 127.0.0.1 >nul']
for p in gone:
if '%' not in str(p):
steps.append(f'(if exist "{p}\\*" (rmdir /s /q "{p}") else if exist "{p}" (del /f /q "{p}"))')
steps += [f'rmdir "{p}" 2>nul' for p in empty if '%' not in str(p)]
return ' & '.join(steps)
def uninstall(layout, remove_game='', log=print):
"""Remove the shortcuts, the uninstall entry and, once this process has exited, what the launcher put in its folder
(and the game folder when remove_game names it). A kept game folder and its saves stay, also when it lies inside
the launcher's folder."""
stub_run(layout, ['--shortcuts', 'off'])
gone, empty = uninstall_plan(layout, remove_game)
if os.name == 'nt':
try:
import winreg
winreg.DeleteKey(winreg.HKEY_CURRENT_USER, UNINSTALL_KEY)
except OSError:
pass
# one command line as cmd.exe reads it: a list would have its quotes escaped as \", which cmd.exe does not
# understand, and no rmdir would find its folder
kept = [str(p) for p in list(gone) + list(empty) if '%' in str(p) and os.path.exists(p)]
if kept:
log('uninstall: remove these yourself (their names hold %): ' + ', '.join(kept))
start_detached(f'cmd.exe /c "{uninstall_script(gone, empty)}"', cwd=os.environ.get('TEMP', 'C:\\'))
else:
log('uninstall: remove these yourself: ' + ', '.join(str(p) for p in gone if p.exists()))
# ---------------------------------------------------------------- gamepad (XInput)
class _XInputGamepad(ctypes.Structure):
_fields_ = [('wButtons', ctypes.c_ushort), ('bLeftTrigger', ctypes.c_ubyte), ('bRightTrigger', ctypes.c_ubyte),
('sThumbLX', ctypes.c_short), ('sThumbLY', ctypes.c_short), ('sThumbRX', ctypes.c_short),
('sThumbRY', ctypes.c_short)]
class _XInputState(ctypes.Structure):
_fields_ = [('dwPacketNumber', ctypes.c_uint), ('Gamepad', _XInputGamepad)]
BUTTONS = {0x0001: 'up', 0x0002: 'down', 0x0004: 'left', 0x0008: 'right', 0x1000: 'a', 0x2000: 'b', 0x8000: 'y',
0x4000: 'x', 0x0010: 'start'}
def in_front(root):
"""Whether the window the user is typing into belongs to this process. XInput reads the pad whichever window is in
front, so without this check the launcher, left open behind the game, took the presses meant for the game: A
activated its focused row (it started the game five times in five minutes and tried a rebuild), the stick moved
its focus and Y checked for updates. True where it cannot tell."""
if os.name != 'nt':
return True
try:
user32 = ctypes.windll.user32
user32.GetForegroundWindow.restype = ctypes.c_void_p
user32.GetWindowThreadProcessId.restype = ctypes.c_uint
user32.GetWindowThreadProcessId.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint)]
hwnd = user32.GetForegroundWindow()
if not hwnd:
return False # no window in front (the desktop is switching, a lock screen): nothing is meant for us
pid = ctypes.c_uint(0)
user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
return pid.value == os.getpid()
except (AttributeError, OSError):
return True
class Gamepad:
"""Polls the first XInput pad; poll() returns the buttons pressed since the last call (edges), the left stick
counted as the d-pad. poll(False) still reads the pad but returns nothing: a button held while another window was
in front does not count as pressed when this one comes back."""
def __init__(self):
self.dll = None
self.held = set()
if os.name == 'nt':
for name in ('xinput1_4', 'xinput1_3', 'xinput9_1_0'):
try:
self.dll = getattr(ctypes.windll, name)
break
except (AttributeError, OSError):
continue
def poll(self, active=True):
if not self.dll:
return set()
st = _XInputState()
down = set()
for pad in range(4):
try:
if self.dll.XInputGetState(pad, ctypes.byref(st)) == 0:
g = st.Gamepad
down = {name for bit, name in BUTTONS.items() if g.wButtons & bit}
if g.sThumbLY > 16000:
down.add('up')
elif g.sThumbLY < -16000:
down.add('down')
if g.sThumbLX > 16000:
down.add('right')
elif g.sThumbLX < -16000:
down.add('left')
break
except OSError:
return set()
pressed = down - self.held if active else set()
self.held = down
return pressed
def is_windows():
return os.name == 'nt'
def frozen_python():
return Path(sys.executable).parent