"""The installer window: MainWindow.xaml / MainWindow.xaml.cs of the WPF builder in Qt, the same 960x600 window, pages and logic. It opens with the hookshot in the middle while it looks for the game files (and, at the first start or after an update, gets the build tools), then walks through Game files > Build > Play. The game's update offer opens it on its update screen, and the game folder's launcher (Hookshot.lnk, --launch ) on the launcher page.""" import ctypes import math import os import re import sys import time import winreg from PySide6.QtCore import (QEasingCurve, QObject, QPointF, QPropertyAnimation, QRectF, QSize, Qt, QTimer, QUrl, Signal) from PySide6.QtGui import (QColor, QDesktopServices, QGuiApplication, QIcon, QLinearGradient, QPainter, QPainterPath, QPen, QPixmap, QRadialGradient) from PySide6.QtWidgets import (QAbstractButton, QApplication, QFileDialog, QFrame, QGraphicsOpacityEffect, QGridLayout, QHBoxLayout, QLabel, QMessageBox, QPlainTextEdit, QScrollArea, QSizePolicy, QStackedLayout, QVBoxLayout, QWidget) from . import core, paths, setup_parts, strings, updater from .theme import (C, MONO, W_BOLD, W_MEDIUM, W_SEMIBOLD, Bar, Button, Card, Chip, Choice, PathEdit, Ring, Tick, argb, css, faint, font, glow, heading, label, note, rounded, section, set_color, sub, tick_path) NEEDED_BYTES = 45 << 30 # (the game data 24.4 GB, the shader caches ~8 GB, the game 0.4 GB, the build files ~5 GB at their peak) STAGES = [("download", "", "Download the update"), ("read", "Read your game files", "Read the game files kept in the folder"), ("lift", "Translate the game to PC code", "Translate the game to PC code"), ("compile", "Compile", "Compile changed files"), ("finish", "Put the game together", "Swap in the new game"), ("shaders", "Prepare the shaders", "Prepare the shaders")] WITHOUT_SHADERS = {"download": (0, 0.04), "read": (0.04, 0.04), "lift": (0.08, 0.14), "compile": (0.22, 0.74), "finish": (0.96, 0.04)} # (the game's --prepare-shaders run, make_game.py's last step: minutes on some GPUs, the first start's wait moved here) WITH_SHADERS = {"download": (0, 0.04), "read": (0.04, 0.04), "lift": (0.08, 0.14), "compile": (0.22, 0.68), "finish": (0.90, 0.02), "shaders": (0.92, 0.08)} SHADERS_LATER = "--no-prepare-shaders" NOT_PREPARED = re.compile(r"^the shaders were not prepared now \((.*)\): ") # (make_game.py NOT_PREPARED) DLSS_LICENSE = ( "NVIDIA DLSS is NVIDIA's, not Hookshot's. With it ticked, the build downloads NVIDIA's DLSS SDK (release v310.9.16) from " "github.com/NVIDIA/DLSS, under NVIDIA's own license, the NVIDIA RTX SDKs license:\n\n" "https://github.com/NVIDIA/DLSS/blob/9981c6350dc58c0ce21f024fd65e31e851c31689/LICENSE.txt\n\n" "Its files stay on this PC (in the builder's ngx-sdk folder, and nvngx_dlss.dll in the game folder's ngx folder). " "Hookshot never includes or shares them: never share a game folder built with them.\n\nDo you accept NVIDIA's license?") class Poster(QObject): """Calls from worker threads run on the window's thread""" call = Signal(object, object) def __init__(self): super().__init__() self.call.connect(lambda fn, args: fn(*args)) def clock(secs): return "%d:%02d" % (int(secs) // 60, int(secs) % 60) def span(secs): secs = int(secs) if secs >= 3600: return "%d h %d min" % (secs // 3600, secs % 3600 // 60) if secs >= 60: return "%d minutes" % (secs // 60) return "%d seconds" % secs def time_left(seconds): if seconds < 45: return "Less than a minute left" if seconds < 90: return "About a minute left" m = int(round(seconds / 60)) return "About %d h %d min left" % (m // 60, m % 60) if m >= 60 else "About %d minutes left" % m # ================= small pieces drawn as the XAML draws them ================= class Splash(QWidget): """The start: the hookshot (178 wide) over its pulsing halo, bobbing; "Hookshot", the status, and the sweeping bar""" def __init__(self, hook): super().__init__() self.hook, self.t0, self.text, self.scale = hook, time.monotonic(), "Starting…", 1.0 self.timer = QTimer(self, timeout=self.update) self.timer.start(16) def stop(self): self.timer.stop() def paintEvent(self, e): p = QPainter(self) p.setRenderHints(QPainter.RenderHint.Antialiasing | QPainter.RenderHint.SmoothPixmapTransform | QPainter.RenderHint.TextAntialiasing) t = time.monotonic() - self.t0 ping = (1 - math.cos(math.pi * ((t / 1.2) % 2 if (t / 1.2) % 2 <= 1 else 2 - (t / 1.2) % 2))) / 2 # (sine in-out, auto-reverse) cx, cy = self.width() / 2, self.height() / 2 p.translate(cx, cy) p.scale(self.scale, self.scale) top = -(260 + 16 + 27 + 6 + 20 + 16 + 3) / 2 # (the stack: 260 hook area, the title, the status, the bar) hc = QPointF(0, top + 130) r = (260 - 48) / 2 * (0.94 + 0.10 * ping) # (the halo: Margin 24, scale 0.94..1.04, opacity 0.6..1) g = QRadialGradient(hc, r) g.setColorAt(0, argb("#663D63E6")) g.setColorAt(0.68, argb("#003D63E6")) g.setColorAt(1, argb("#003D63E6")) p.setOpacity(0.6 + 0.4 * ping) p.setBrush(g) p.setPen(Qt.PenStyle.NoPen) p.drawEllipse(hc, r, r) p.setOpacity(1) w = 178 h = self.hook.height() * w / self.hook.width() p.save() p.translate(hc.x(), hc.y() - 6 * ping) # (BobLift 0..-6, BobTurn -4..2) p.rotate(-4 + 6 * ping) shadow = QRectF(-w / 2, -h / 2 + 14, w, h) # (DropShadow 24 blur, 14 down, 0.6: the image's own, softened) p.setOpacity(0.35) p.drawPixmap(shadow, self.shadow_pixmap(), QRectF(self.shadow_pixmap().rect())) p.setOpacity(1) p.drawPixmap(QRectF(-w / 2, -h / 2, w, h), self.hook, QRectF(self.hook.rect())) p.restore() y = top + 260 + 16 p.setPen(C["Ink"]) p.setFont(font(22, W_SEMIBOLD)) p.drawText(QRectF(-200, y, 400, 28), Qt.AlignmentFlag.AlignCenter, "Hookshot") y += 28 + 6 p.setPen(argb("#A6FFFFFF")) p.setFont(font(13)) p.drawText(QRectF(-300, y, 600, 20), Qt.AlignmentFlag.AlignCenter, self.text) y += 20 + 16 track = QRectF(-100, y, 200, 3) p.setClipPath(rounded(track, 1.5)) p.fillPath(rounded(track, 1.5), argb("#14FFFFFF")) f = (t / 1.2) % 1 f = (1 - math.cos(math.pi * f)) / 2 x = -100 - 88 + 296 * f # (Sweep -88..208, sine in-out, repeating) lg = QLinearGradient(x, 0, x + 80, 0) lg.setColorAt(0, argb("#007F9BFF")) lg.setColorAt(0.5, argb("#FF7F9BFF")) lg.setColorAt(1, argb("#007F9BFF")) p.fillRect(QRectF(x, y, 80, 3), lg) _shadow = None def shadow_pixmap(self): if Splash._shadow is None: img = self.hook.toImage().convertToFormat(self.hook.toImage().Format.Format_ARGB32_Premultiplied) sp = QPixmap(img.size()) sp.fill(Qt.GlobalColor.transparent) q = QPainter(sp) q.drawImage(0, 0, img) q.setCompositionMode(QPainter.CompositionMode.CompositionMode_SourceIn) q.fillRect(sp.rect(), QColor(0, 0, 0)) q.end() Splash._shadow = sp.scaled(sp.width() // 6, sp.height() // 6, Qt.AspectRatioMode.IgnoreAspectRatio, Qt.TransformationMode.SmoothTransformation) return Splash._shadow class StepPill(QWidget): """The head's pill: Game files > Build > Play (done: a green tick disc; now: the blue pill with its glow)""" def __init__(self): super().__init__() self.on = 0 self.setFixedHeight(40) self.names = ["Game files", "Build", "Play"] self._layout() def set(self, on): self.on = on self._layout() self.update() def _layout(self): self.items = [] x = 4 + 1 for i, n in enumerate(self.names): if i: x += 5 + 4 + 5 # (the chevron, 5 each side) fw = W_SEMIBOLD if i == self.on else W_MEDIUM from PySide6.QtGui import QFontMetricsF tw = QFontMetricsF(font(13, fw)).horizontalAdvance(n) done = i < self.on w = (4 + 22 + 8 + tw + 14) if done else (14 + tw + 14) self.items.append((x, w, n, done, fw)) x += w self.setFixedWidth(int(x + 4 + 1 + 0.5)) def paintEvent(self, e): p = QPainter(self) p.setRenderHints(QPainter.RenderHint.Antialiasing | QPainter.RenderHint.TextAntialiasing) r = QRectF(self.rect()).adjusted(0.5, 0.5, -0.5, -0.5) p.fillPath(rounded(r, 20), argb("#0BFFFFFF")) p.setPen(QPen(argb("#17FFFFFF"), 1)) p.drawPath(rounded(r, 20)) for i, (x, w, n, done, fw) in enumerate(self.items): if i: cx = x - 5 - 2 p.setPen(QPen(QColor(C["InkSoft"].red(), C["InkSoft"].green(), C["InkSoft"].blue(), int(255 * 0.45)), 1.6)) path = QPainterPath(QPointF(cx - 2, 16)) path.lineTo(cx + 2, 20) path.lineTo(cx - 2, 24) p.drawPath(path) pill = QRectF(x, 5, w, 30) if i == self.on: # (LinearGradient #4B70F0 -> #3557D6 at 90 deg, and its glow) for k in range(8, 0, -1): gc = QColor(0x3D, 0x63, 0xE6, int(0.6 * 255 / 8 / k * 2)) p.fillPath(rounded(pill.adjusted(-k, -k + 6, k, k + 6), 15 + k), gc) lg = QLinearGradient(pill.topLeft(), pill.bottomLeft()) lg.setColorAt(0, argb("#4B70F0")) lg.setColorAt(1, argb("#3557D6")) p.fillPath(rounded(pill, 15), lg) tx = x + 14 if done: d = QRectF(x + 4, 9, 22, 22) p.setBrush(C["GoSoft"]) p.setPen(Qt.PenStyle.NoPen) p.drawEllipse(d) p.setPen(QPen(C["Go"], 1.8)) p.setBrush(Qt.BrushStyle.NoBrush) p.drawPath(tick_path(d.center().x(), d.center().y() + 0.25)) tx = x + 4 + 22 + 8 p.setFont(font(13, fw)) p.setPen(C["White"] if i == self.on else C["InkSoft"] if done else C["InkFaint"]) p.drawText(QRectF(tx, 5, w, 30), Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft, n) class Mark(QWidget): """A build step's mark: waiting (a ring), now (the number on Brand with its halo), done (a tick on GoSoft), stopped (! on BadSoft)""" def __init__(self, n): super().__init__() self.n, self.state = n, "wait" self.setFixedSize(34, 34) def paintEvent(self, e): p = QPainter(self) p.setRenderHints(QPainter.RenderHint.Antialiasing | QPainter.RenderHint.TextAntialiasing) c = QPointF(11, 12) s = self.state if s == "now": p.setPen(Qt.PenStyle.NoPen) p.setBrush(C["BrandSoft"]) p.drawEllipse(c, 16, 16) p.setBrush(C["Brand"]) p.drawEllipse(c, 11, 11) p.setPen(C["White"]) p.setFont(font(12, W_SEMIBOLD)) p.drawText(QRectF(c.x() - 11, c.y() - 11, 22, 22), Qt.AlignmentFlag.AlignCenter, str(self.n)) elif s == "done": p.setPen(Qt.PenStyle.NoPen) p.setBrush(C["GoSoft"]) p.drawEllipse(c, 11, 11) p.setPen(QPen(C["Go"], 1.8)) p.setBrush(Qt.BrushStyle.NoBrush) p.drawPath(tick_path(c.x(), c.y() + 0.25)) elif s == "stopped": p.setPen(Qt.PenStyle.NoPen) p.setBrush(C["BadSoft"]) p.drawEllipse(c, 11, 11) p.setPen(C["Bad"]) p.setFont(font(12, W_SEMIBOLD)) p.drawText(QRectF(c.x() - 11, c.y() - 11, 22, 22), Qt.AlignmentFlag.AlignCenter, "!") else: p.setPen(QPen(C["GlassLineStrong"], 1.5)) p.setBrush(Qt.BrushStyle.NoBrush) p.drawEllipse(c, 10.25, 10.25) if s == "skipped": p.setPen(C["InkFaint"]) p.setFont(font(12, W_SEMIBOLD)) p.drawText(QRectF(c.x() - 11, c.y() - 11, 22, 22), Qt.AlignmentFlag.AlignCenter, "–") class StepRow(QWidget): """One step of the build: its mark (done, now, waiting), its name, a line under it and its time""" def __init__(self, n, text, last): super().__init__() self.running, self.start = False, 0.0 self.last = last g = QGridLayout(self) g.setContentsMargins(0, 10, 0, 10) g.setHorizontalSpacing(0) g.setVerticalSpacing(0) self.mark = Mark(n) g.addWidget(self.mark, 0, 0, 2, 1, Qt.AlignmentFlag.AlignTop) self.name = label(text, 14, W_SEMIBOLD) self.small = label("", 12) self.small.hide() g.addWidget(self.name, 0, 1) g.addWidget(self.small, 1, 1) self.time = label("—", 12, mono=True) g.addWidget(self.time, 0, 2, Qt.AlignmentFlag.AlignTop) g.setColumnStretch(1, 1) self.wait() def paintEvent(self, e): if self.last: return p = QPainter(self) # (the link down to the next mark: 1 wide at 10.5, from 28 below the top to 19 past the bottom) p.fillRect(QRectF(10.5, 10 + 28, 1, self.height() - 38 + 10), C["GlassLine"]) def small_text(self, t): self.small.setText(t) self.small.show() def wait(self): self.mark.state = "wait" self.mark.update() self.name.setFont(font(14, W_MEDIUM)) set_color(self.name, "InkFaint") set_color(self.small, "InkFaint") set_color(self.time, "InkFaint") def begin(self): self.running, self.start = True, time.monotonic() self.mark.state = "now" self.mark.update() self.name.setFont(font(14, W_SEMIBOLD)) set_color(self.name, "Ink") set_color(self.time, "Ink") self.tick() def tick(self): if self.running: self.time.setText(clock(time.monotonic() - self.start)) def done(self): if self.running: self.tick() self.running = False self.mark.state = "done" self.mark.update() self.name.setFont(font(14, W_SEMIBOLD)) set_color(self.name, "Ink") set_color(self.time, "InkFaint") def stopped(self): self.running = False self.mark.state = "stopped" self.mark.update() def skipped(self): """(not done: left to later, the shaders' step when they were not prepared now)""" if self.running: self.tick() self.running = False self.mark.state = "skipped" self.mark.update() self.name.setFont(font(14, W_MEDIUM)) set_color(self.name, "InkFaint") set_color(self.time, "InkFaint") class DumpRow(QAbstractButton): """A found .nup: the whole row is the choice (RadioButton DumpRow: 16/13 padding, the ring and its Brand dot, #08FFFFFF hover)""" def __init__(self, dump, chip, why=None): super().__init__() self.setCheckable(True) self.setAutoExclusive(True) self.setCursor(Qt.CursorShape.PointingHandCursor) self.setToolTip(dump.path) self.hover = False lay = QHBoxLayout(self) lay.setContentsMargins(16 + 18 + 14, 13, 16, 13) texts = QVBoxLayout() texts.setSpacing(0) name = label(os.path.basename(dump.path), 14, W_SEMIBOLD) name.setTextFormat(Qt.TextFormat.PlainText) name.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred) texts.addWidget(name) texts.addWidget(faint("%s · %s · %s" % (dump.where, core.size_text(dump.size), core.ago(dump.modified)))) if why: w = faint(why) w.setWordWrap(True) set_color(w, "Bad") w.setContentsMargins(0, 4, 0, 0) texts.addWidget(w) lay.addLayout(texts, 1) lay.addSpacing(12) lay.addWidget(chip, 0, Qt.AlignmentFlag.AlignVCenter) def enterEvent(self, e): self.hover = True self.update() def leaveEvent(self, e): self.hover = False self.update() def paintEvent(self, e): p = QPainter(self) p.setRenderHint(QPainter.RenderHint.Antialiasing) if self.hover: p.fillRect(self.rect(), argb("#08FFFFFF")) c = QPointF(16 + 9, self.height() / 2) p.setPen(QPen(C["Brand"] if self.isChecked() else C["InkFaint"], 2)) p.setBrush(Qt.BrushStyle.NoBrush) p.drawEllipse(c, 8, 8) if self.isChecked(): p.setPen(Qt.PenStyle.NoPen) p.setBrush(C["Brand"]) p.drawEllipse(c, 4, 4) class Hline(QWidget): def __init__(self): super().__init__() self.setFixedHeight(1) def paintEvent(self, e): QPainter(self).fillRect(self.rect(), C["GlassLine"]) class Glyph(QWidget): """The small round badges: the "i" before the tools note, the "!" of a problem, the ready page's tick""" def __init__(self, kind): super().__init__() self.kind = kind self.setFixedSize({"info": QSize(16, 16), "bad": QSize(28, 28), "ready": QSize(124, 124)}[kind]) def paintEvent(self, e): p = QPainter(self) p.setRenderHints(QPainter.RenderHint.Antialiasing | QPainter.RenderHint.TextAntialiasing) r = QRectF(self.rect()) if self.kind == "info": p.setPen(Qt.PenStyle.NoPen) p.setBrush(C["BrandSoft"]) p.drawEllipse(r) p.setPen(argb("#B9C8FF")) p.setFont(font(10, W_BOLD)) p.drawText(r, Qt.AlignmentFlag.AlignCenter, "i") elif self.kind == "bad": p.setPen(Qt.PenStyle.NoPen) p.setBrush(C["BadSoft"]) p.drawEllipse(r) p.setPen(C["Bad"]) p.setFont(font(14, W_BOLD)) p.drawText(r, Qt.AlignmentFlag.AlignCenter, "!") else: # (84 wide: GoSoft with its 60-blur green glow, a ring of 10 at -10, the tick) c = r.center() for k in range(30, 0, -2): p.setPen(Qt.PenStyle.NoPen) p.setBrush(QColor(0x5F, 0xB0, 0x8A, int(255 * 0.55 * 0.06 * (1 - k / 30)))) p.drawEllipse(c, 42 + k, 42 + k) p.setBrush(C["GoSoft"]) p.drawEllipse(c, 42, 42) p.setBrush(Qt.BrushStyle.NoBrush) p.setPen(QPen(argb("#125FB08A"), 10)) p.drawEllipse(c, 47, 47) pen = QPen(C["Go"], 4) pen.setCapStyle(Qt.PenCapStyle.RoundCap) pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin) p.setPen(pen) path = QPainterPath(QPointF(c.x() - 14, c.y())) path.lineTo(c.x() - 4, c.y() + 10) path.lineTo(c.x() + 14, c.y() - 10) p.drawPath(path) class LogBox(QPlainTextEdit): """The details: mono 11 in InkSoft on #33000000, GlassLine border, 10 padding, no wrapping""" def __init__(self, border=True): super().__init__() self.setReadOnly(True) self.setFont(font(11, family=MONO)) self.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap) self.setStyleSheet("QPlainTextEdit { color: %s; background: rgba(0,0,0,51); border: %s; border-radius: 0; padding: 10px; }" % (css(C["InkSoft"]), "1px solid " + css(C["GlassLine"]) if border else "none") + SCROLLBARS) SCROLLBARS = ("QScrollBar:vertical { background: transparent; width: 10px; margin: 2px; }" "QScrollBar::handle:vertical { background: rgba(255,255,255,40); border-radius: 3px; min-height: 24px; }" "QScrollBar::handle:vertical:hover { background: rgba(255,255,255,70); }" "QScrollBar:horizontal { background: transparent; height: 10px; margin: 2px; }" "QScrollBar::handle:horizontal { background: rgba(255,255,255,40); border-radius: 3px; min-width: 24px; }" "QScrollBar::add-line, QScrollBar::sub-line { width: 0; height: 0; }" "QScrollBar::add-page, QScrollBar::sub-page { background: transparent; }") def scroll(widget, max_h=None): s = QScrollArea() s.setWidget(widget) s.setWidgetResizable(True) s.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff) s.setFrameShape(QFrame.Shape.NoFrame) s.setStyleSheet("QScrollArea { background: transparent; } QScrollArea > QWidget > QWidget { background: transparent; }" + SCROLLBARS) s.viewport().setAutoFillBackground(False) widget.setAutoFillBackground(False) if max_h: s.setMaximumHeight(max_h) return s def hbox(*items, spacing=0, margins=(0, 0, 0, 0)): l = QHBoxLayout() l.setSpacing(spacing) l.setContentsMargins(*margins) for it in items: if it is None: l.addStretch(1) elif isinstance(it, int): l.addSpacing(it) elif isinstance(it, QWidget): l.addWidget(it) else: l.addLayout(it) return l def vbox(*items, spacing=0, margins=(0, 0, 0, 0)): l = QVBoxLayout() l.setSpacing(spacing) l.setContentsMargins(*margins) for it in items: if it is None: l.addStretch(1) elif isinstance(it, int): l.addSpacing(it) elif isinstance(it, QWidget): l.addWidget(it) else: l.addLayout(it) return l def holder(layout): w = QWidget() w.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground) w.setLayout(layout) return w # ================= the window ================= class Window(QWidget): def __init__(self, args): super().__init__() self.args = args self.poster = Poster() self.lang = strings.default_language() self.glass = False self.download = None self.runner = None self.rows = {} self.checks = {} self.dumps = [] self.log_lines = [] self.current = None self.finished = "" self.chosen_nup = self.romfs = self.exefs = None self.folders_note = None self.updating = self.checking = self.source_picked = False self.compiled = 0.0 self.files_done = self.files_of = 0 self.files_changed, self.files_compiled = -1, 0 self.compile_eta, self.this_compile, self.previous_total = -1.0, 0, -1 self.last_failure = "" self.mode = "build" self.latest_tag = self.update_target = None self.launch_folder = "" self.problem_is_tools = False self.elapsed0 = self.compile0 = None self.prepare_now, self.shaders_began, self.shaders_later, self.built_in = True, False, None, None self.weight = WITHOUT_SHADERS self.setWindowTitle("Hookshot") self.setWindowIcon(QIcon(os.path.join(paths.ASSETS, "hookshot.ico"))) self.setFixedSize(960, 600) self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground) self.setAcceptDrops(True) self.hook = QPixmap(os.path.join(paths.ASSETS, "hookshot.png")) self.clock = QTimer(self, interval=1000, timeout=self.tick) self._build_ui() self.out_path.setText(os.path.join(os.path.expanduser("~"), "Games", "Hookshot")) self.out_path.textChanged.connect(self.refresh) tools = core.Tools.find() self.tools_note.setText("Nothing else to install: Hookshot's own build tools are here, downloaded and checked by its setup." if tools else "Hookshot's build tools are missing from its folder. Press Build and Hookshot downloads " "them again.") self.set_step(0) self.refresh() def post(self, fn, *args): self.poster.call.emit(fn, args) def T(self, key): return strings.text(self.lang, key) # ---------------- the native window: Windows 11's acrylic behind it (Glass.cs), our own caption ---------------- def showEvent(self, e): super().showEvent(e) if not getattr(self, "_native", False): self._native = True self.glass = apply_glass(int(self.winId())) self.update() QTimer.singleShot(0, self.start) def nativeEvent(self, kind, message): if kind == b"windows_generic_MSG": msg = ctypes.wintypes.MSG.from_address(int(message)) if msg.message == 0x0083 and msg.wParam: # WM_NCCALCSIZE: the whole window is the client area (no title bar) return True, 0 if msg.message == 0x0084: # WM_NCHITTEST: the top 64 px (but the buttons in it) moves the window x, y = ctypes.c_short(msg.lParam & 0xFFFF).value, ctypes.c_short((msg.lParam >> 16) & 0xFFFF).value pos = self.mapFromGlobal(self.screen_point(x, y)) if 0 <= pos.y() < 64: w = self.childAt(pos) if w is None or not isinstance(w, (QAbstractButton,)) and w.parent() is not None and not isinstance( w.parent(), QAbstractButton): return True, 2 # HTCAPTION return super().nativeEvent(kind, message) def screen_point(self, x, y): from PySide6.QtCore import QPoint dpr = self.devicePixelRatioF() return QPoint(int(x / dpr), int(y / dpr)) def paintEvent(self, e): p = QPainter(self) r = QRectF(self.rect()) if not self.glass: # (Windows 10, a light Windows, or no acrylic: the plain Slate page) p.fillRect(r, C["Page"]) lg = QLinearGradient(0, 0, 0, r.height()) lg.setColorAt(0, argb("#401A1D24")) lg.setColorAt(1, argb("#3312141A")) p.fillRect(r, lg) # ---------------- the layout (MainWindow.xaml) ---------------- def _build_ui(self): stack = QStackedLayout(self) stack.setStackingMode(QStackedLayout.StackingMode.StackAll) self.splash = Splash(self.hook) self.main = QWidget() self.main.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground) self.main.hide() # (shown as the splash fades: a fade of its own would hide the glows inside it, Qt draws one effect deep) self.main.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, True) stack.addWidget(self.main) stack.addWidget(self.splash) self.splash.raise_() # the head: the hookshot, and the steps (or the update's versions) head = QWidget(self.main) head.setGeometry(0, 0, 960, 64) icon = QLabel(head) icon.setPixmap(self.hook.scaledToWidth(56, Qt.TransformationMode.SmoothTransformation)) icon.setScaledContents(True) icon.setGeometry(28, 32 - int(28 * self.hook.height() / self.hook.width() / 2), 28, int(28 * self.hook.height() / self.hook.width())) glow(icon, "#000000", 6, 2, 0.5) title = label("Hookshot", 15, W_BOLD) title.setParent(head) title.move(28 + 28 + 10, 32 - title.sizeHint().height() // 2) self.version_chip = label("", 12, color="InkSoft") self.version_chip.setParent(head) self.version_chip.move(title.x() + title.sizeHint().width() + 12, 32 - 8) self.version_chip.hide() self.step_pill = StepPill() self.step_pill.setParent(head) self.step_pill.move((960 - self.step_pill.width()) // 2, 12) body = QWidget(self.main) body.setGeometry(64, 64 + 16, 960 - 128, 600 - 64 - 16 - 34) self.pages = QStackedLayout(body) self.files_page = self._files_page() self.build_page = self._build_page() self.ready_page = self._ready_page() self.launch_page = self._launch_page() self.problem_page = self._problem_page() for pg in (self.files_page, self.build_page, self.ready_page, self.launch_page, self.problem_page): self.pages.addWidget(pg) # the window's own buttons, over everything self.caption = QWidget(self) self.caption.setGeometry(960 - 6 - 92, 6, 92, 36) mn, cl = Button(kind="caption", icon="min"), Button(kind="caption", icon="close") mn.setToolTip("Minimize") cl.setToolTip("Close") mn.clicked.connect(self.showMinimized) cl.clicked.connect(self.close_window) self.caption.setLayout(hbox(mn, cl)) self.caption.raise_() def _files_page(self): self.files_title, self.files_sub = heading("Build your game"), sub("Pick your game files and where the game goes. Hookshot does " "the rest, once.") self.dump_list = QVBoxLayout() self.dump_list.setSpacing(0) dump_holder = holder(self.dump_list) card = Card() self.dump_scroll = scroll(dump_holder, 128) card.setLayout(vbox(self.dump_scroll)) browse = Button("Browse…", "link") browse.clicked.connect(self.browse_nup) other = Button("romfs and exefs folders", "link", color=C["InkSoft"]) other.clicked.connect(self.browse_folders) drop = faint(" · or drop the file on this window · ", 13) links = hbox(note("Not listed?"), 8, browse, drop, other, None) self.out_path = PathEdit() change = Button("Change", "quiet") change.clicked.connect(self.browse_out) self.work_note = note("", 12) self.work_change = Button("Change", "link", size=12) self.work_change.clicked.connect(self.browse_work) self.work_reset = Button("Default", "link", size=12) self.work_reset.clicked.connect(lambda: self.change_work(None)) left = vbox(section("INSTALL THE GAME TO"), hbox(self.out_path, 10, change), 8, hbox(self.work_note, 12, self.work_change, 12, self.work_reset)) self.language_box = Choice() for code, name, _t in strings.LANGUAGES: self.language_box.addItem(name) self.language_box.setCurrentIndex(strings.LANGUAGES.index(self.lang)) self.language_box.currentIndexChanged.connect(self.language_changed) lang_col = holder(vbox(section("GAME LANGUAGE"), self.language_box)) lang_col.setFixedWidth(200) row3 = hbox(left, 20) row3.addWidget(lang_col, 0, Qt.AlignmentFlag.AlignTop) self.tools_note = note("", 12) self.worker_box = Choice() for c in core.worker_choices(): self.worker_box.addItem(str(c)) self.worker_box.setProperty("focus_ring", True) self.worker_box.setToolTip("Automatic uses available memory and any existing worker override. More workers need more memory and " "may not be faster.") self.prepare_tick = Tick("Prepare shaders now", True) self.prepare_tick.setToolTip("Prepares the game's shaders at the end of the build, a few minutes (longer on some GPUs). Unticked, " "the game prepares them at its first start, behind a black window.") self.prepare_tick.clicked.connect(self.save_settings) work_col = holder(vbox(section("BUILD WORKERS"), self.worker_box, 12, self.prepare_tick)) work_col.setFixedWidth(160) row4 = hbox(hbox(Glyph("info"), 8, self.tools_note), 20) row4.addWidget(work_col, 0, Qt.AlignmentFlag.AlignTop) self.dlss_tick = Tick("NVIDIA DLSS (downloads NVIDIA's SDK under NVIDIA's license)") self.dlss_tick.clicked.connect(self.dlss_changed) dnote = note("For NVIDIA RTX graphics cards. NVIDIA's files stay on this PC: never share a game folder built with them.", 12) dnote.setContentsMargins(26, 4, 0, 0) found = section("FOUND ON THIS PC") content = holder(vbox(self.files_title, self.files_sub, found, card, 10, links, row3, 12, row4, 14, self.dlss_tick, dnote, None)) self.space_bar = Bar("Go", 160) self.space_text = note("", 12) self.space_text.setWordWrap(False) self.about_text = faint("About 45 min") self.build_button = Button("Build the game", "primary") self.build_button.setEnabled(False) self.build_button.clicked.connect(self.start_build) foot = hbox(self.space_bar, 10, self.space_text, None, self.about_text, 14, self.build_button) page = holder(vbox(scroll(content), 12, foot)) return page def _build_page(self): self.ring = Ring() self.build_title, self.build_note = heading("Building your game"), sub("") self.update_bar = Bar("Brand") self.update_bar.setContentsMargins(0, 18, 0, 0) self.update_bar.hide() self.ring_box = holder(hbox(self.ring, 28)) # (collapsed with its gap in the update) top = hbox(self.ring_box, vbox(None, self.build_title, self.build_note, 18, self.update_bar, None)) self.stage_list = QVBoxLayout() self.stage_list.setSpacing(0) self.step_card = Card() self.step_card.setLayout(vbox(self.stage_list, margins=(18, 6, 18, 6))) self.log_box = LogBox() self.log_box.hide() mid = vbox(self.step_card, self.log_box, None) self.show_log = Button(self.T("ShowDetails"), "toggle") self.show_log.setCheckable(True) self.show_log.toggled.connect(self.log_toggled) self.cancel_button = Button(self.T("Cancel"), "quiet") self.cancel_button.clicked.connect(self.cancel_build) return holder(vbox(top, 22, mid, 14, hbox(self.show_log, None, self.cancel_button))) def _ready_page(self): self.ready_title = heading("Your game is ready") self.ready_note = sub("") self.ready_note.setAlignment(Qt.AlignmentFlag.AlignCenter) self.ready_note.setWordWrap(False) self.play_button = Button(self.T("Play"), "go", icon="play") self.play_button.clicked.connect(self.play) self.open_button = Button(self.T("OpenFolder"), "quiet") self.open_button.setFixedHeight(50) self.open_button.fixed_h = 50 self.open_button.clicked.connect(lambda: core.open_folder(self.finished)) self.desktop_tick = Tick("Desktop shortcut", True) self.start_tick = Tick("Start menu entry", True) self.desktop_tick.clicked.connect(self.shortcuts_changed) self.start_tick.clicked.connect(self.shortcuts_changed) self.storage_note = note("") self.storage_note.setAlignment(Qt.AlignmentFlag.AlignCenter) self.storage_note.setMaximumWidth(560) self.free_button = Button("Free up space", "link") self.free_button.clicked.connect(self.free_space) show = Button("Show folder", "link") show.clicked.connect(lambda: core.open_folder(core.work() if core.work_chosen() else paths.base())) self.storage_row = holder(vbox(hbox(None, self.storage_note, None), 8, hbox(None, self.free_button, 18, show, None))) self.storage_row.hide() col = vbox(None, hbox(None, Glyph("ready"), None), 24 - 20, hbox(None, self.ready_title, None), hbox(None, self.ready_note, None), 28, hbox(None, self.play_button, 12, self.open_button, None), 22, hbox(None, self.desktop_tick, 18, self.start_tick, None), 26, self.storage_row, None) return holder(col) def _launch_page(self): z = section("THE LEGEND OF ZELDA") z.setContentsMargins(0, 0, 0, 0) t = heading("Ocarina of Time") t.setFont(font(34, W_BOLD)) self.launch_version = sub("") self.launch_version.setContentsMargins(0, 8, 0, 0) self.launch_version.setWordWrap(False) self.launch_status = label("Checking for updates…", 13, color="InkSoft") self.launch_update = Button("Update", "primary") self.launch_update.setFixedHeight(50) self.launch_update.fixed_h, self.launch_update.padx = 50, 26 self.launch_update.hide() self.launch_update.clicked.connect(lambda: updater.update_folder(self, self.launch_folder, self.update_target, False)) self.launch_play = Button(self.T("Play"), "go", icon="play") self.launch_play.clicked.connect(self.launch_play_click) fold = Button("Open the game folder", "link", color=C["InkFaint"]) fold.clicked.connect(lambda: core.open_folder(self.launch_folder)) return holder(vbox(None, hbox(None, z, None), 4, hbox(None, t, None), hbox(None, self.launch_version, None), 16, hbox(None, self.launch_status, None), 28, hbox(None, self.launch_update, 12, self.launch_play, None), 22, hbox(None, fold, None), None)) def _problem_page(self): self.problem_title, self.problem_sub = heading("The build stopped"), sub("Nothing was changed in your game folder.") self.problem_head = label("", 16, W_SEMIBOLD, wrap=True) self.problem_head.setMaximumWidth(740) self.problem_text = note("", 14) self.problem_steps = QVBoxLayout() self.problem_steps.setSpacing(0) self.problem_steps.setContentsMargins(0, 8, 0, 0) box = ProblemCard() head = hbox(Glyph("bad"), 12) head.addWidget(self.problem_head, 1) self.problem_scroll = scroll(holder(vbox(self.problem_text, self.problem_steps)), 190) box.setLayout(vbox(head, 10, self.problem_scroll, margins=(24, 22, 24, 22))) self.problem_details = Button("Show details", "link", color=C["InkSoft"]) self.problem_details.clicked.connect(self.problem_show_details) self.copy_report = Button("Copy for a bug report", "link", color=C["InkSoft"]) self.copy_report.clicked.connect(self.copy_for_report) self.back_button = Button(self.T("Back"), "quiet") self.back_button.clicked.connect(self.back) self.repair_button = Button("Repair", "primary") self.repair_button.clicked.connect(self.repair) foot = hbox(self.problem_details, faint(" · ", 13), self.copy_report, None, self.back_button, 10, self.repair_button) return holder(vbox(self.problem_title, self.problem_sub, 22, box, None, 14, foot)) # ================= the start ================= def start(self): if os.environ.get("HOOKSHOT_TEST_SHORTCUTS"): # (development: both shortcuts made for it, the result beside the app) folder = os.environ["HOOKSHOT_TEST_SHORTCUTS"] core.shortcuts(folder, True, True) paths.write_small(os.path.join(paths.APP_DIR, "shortcut-test.txt"), "desktop %s start %s error %s" % ( os.path.isfile(core.desktop_link()), os.path.isfile(core.start_link()), core.shortcut_error)) QApplication.quit() return self.t_start = time.monotonic() a = self.args if a.update: self.splash.text = "Getting the update…" QTimer.singleShot(900, lambda: (self.show_main(), updater.update_folder(self, a.update, a.tag, a.fetched))) return if a.launch: self.splash.text = "Starting Hookshot…" QTimer.singleShot(700, lambda: (self.show_main(), self.show_launcher(a.launch.rstrip("\\/")))) return if a.repair or not core.Tools.find(): # (the first start, or Repair: the build tools, as the setup got them) self.splash.text = "Getting the build tools…" self.get_tools(a.repair) return self.find_files() def get_tools(self, repair): def status(s): self.splash.text = s def run(): try: setup_parts.install(lambda s: self.post(status, s), tag=None, repair=repair) self.post(self.find_files) except setup_parts.SetupError as e: self.post(self.tools_failed, str(e)) import threading threading.Thread(target=run, daemon=True).start() def tools_failed(self, why): self.show_main() self.show_problem(why, tools=False) self.problem_title.setText("The build tools could not be downloaded") self.problem_sub.setText("Nothing was changed on this PC.") self.repair_button.show() self.repair_button.setText("Try again") def find_files(self): self.splash.text = "Looking for your game files…" import threading def run(): found = core.find_dumps() self.post(self.found_files, found) threading.Thread(target=run, daemon=True).start() def found_files(self, found): self.dumps.extend(found) n = len(found) self.splash.text = "No game files found yet" if n == 0 else "Found 1 game file" if n == 1 else "Found %d game files" % n wait = 1.7 - (time.monotonic() - self.t_start) QTimer.singleShot(max(0, int(wait * 1000)), self.found_go) def found_go(self): self.apply_settings() self.fill_dumps() self.show_main() if os.environ.get("HOOKSHOT_UI_PREVIEW"): self.preview(os.environ["HOOKSHOT_UI_PREVIEW"]) return self.check_all() import threading def run(): tag = updater.latest_tag() self.post(self.got_latest, tag) threading.Thread(target=run, daemon=True).start() def got_latest(self, tag): self.latest_tag = tag self.refresh_mode() def show_main(self): """The hookshot fades out and the first step fades in, in the same window""" if getattr(self, "_shown_main", False): return self._shown_main = True fx = QGraphicsOpacityEffect(self.splash) self.splash.setGraphicsEffect(fx) a = QPropertyAnimation(fx, b"opacity", self) a.setDuration(450) a.setStartValue(1.0) a.setEndValue(0.0) a.finished.connect(lambda: (self.splash.hide(), self.splash.stop())) a.start() self._splash_anim = a t0 = time.monotonic() def grow(): f = min(1.0, (time.monotonic() - t0) / 0.5) self.splash.scale = 1 + 0.04 * f if f < 1: QTimer.singleShot(16, grow) grow() self.main.move(0, 10) lift = QPropertyAnimation(self.main, b"pos", self) lift.setDuration(600) lift.setStartValue(self.main.pos()) from PySide6.QtCore import QPoint lift.setEndValue(QPoint(0, 0)) lift.setEasingCurve(QEasingCurve.Type.OutCubic) self._lift_anim = lift QTimer.singleShot(150, lambda: (self.main.show(), self.splash.raise_(), self.caption.raise_(), lift.start())) self.main.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, False) def show_page(self, page): self.pages.setCurrentWidget(page) def set_step(self, on): self.step_pill.set(on) self.step_pill.move((960 - self.step_pill.width()) // 2, 12) self.step_pill.show() self.version_chip.hide() # ================= what the button does: build, update the game, play it, or get the newer builder ================= def refresh_mode(self): if self.updating or self.runner: return out = self.out_path.text() game = core.game_version(out) if len(out) > 2 else None tools = core.Tools.find() builder = tools.version if tools else None self.update_target = self.latest_tag or builder if game and self.update_target and game != self.update_target and not self.source_picked: self.mode = "update_game" elif game and not self.source_picked: self.mode = "up_to_date" elif self.latest_tag and builder and builder != self.latest_tag: self.mode = "update_builder" else: self.mode = "build" if self.mode == "update_game": self.files_title.setText("Update available") self.files_sub.setText("Hookshot %s is available. Your game is %s: Update builds it again from the game files kept in its " "folder, compiling only what changed." % (self.update_target, game)) self.build_button.setText("Update") elif self.mode == "up_to_date": self.files_title.setText("Your game is up to date") self.files_sub.setText("Your game is %s, as this builder. GitHub did not answer, so newer versions could not be checked." % game if not self.latest_tag else "%s is the latest version. Pick game files below only to build it again from scratch." % game) self.build_button.setText("Play") elif self.mode == "update_builder": self.files_title.setText("Build your game") self.files_sub.setText("Hookshot Builder %s is available (this one is %s): update it first, then build." % (self.latest_tag, builder)) self.build_button.setText("Update builder") else: self.files_title.setText("Build your game") self.files_sub.setText("Pick your game files and where the game goes. Hookshot does the rest, once.") self.build_button.setText("Build the game") self.build_button.setEnabled(self.mode != "build" or (self.source_ready() and len(out) > 2)) self.about_text.setVisible(self.mode == "build") # ---- the launcher: the game folder's Hookshot.lnk starts this with --launch ---- def show_launcher(self, folder): self.launch_folder = folder self.out_path.setText(folder) self.step_pill.hide() game = core.game_version(folder) or core.read_version(folder) self.launch_version.setText(("Hookshot %s" % game if game else "Hookshot") + " · " + folder) self.launch_play.setEnabled(os.path.isfile(core.game_exe(folder))) self.show_page(self.launch_page) import threading def run(): tag = updater.latest_tag() self.post(self.launcher_latest, folder, game, tag) threading.Thread(target=run, daemon=True).start() def launcher_latest(self, folder, game, tag): self.latest_tag = tag tools = core.Tools.find() self.update_target = tag or (tools.version if tools else None) if not self.update_target: self.launch_status.setText("Could not check for updates (GitHub did not answer)") elif game and game != self.update_target and core.game_version(folder): self.launch_status.setText("Update available: %s" % self.update_target) self.launch_status.setFont(font(13, W_SEMIBOLD)) set_color(self.launch_status, argb("#B9C8FF")) self.launch_update.show() elif game and game != self.update_target: self.launch_status.setText("%s is out: build this folder again with the Hookshot Builder to get it" % self.update_target) else: self.launch_status.setText("Up to date with this builder (GitHub did not answer)" if not tag else "Up to date") def launch_play_click(self): core.start_game(self.launch_folder) QApplication.quit() # ---- what the player chose last time ---- def apply_settings(self): s = core.load_settings() if not s: return if s.get("Out"): self.out_path.setText(s["Out"]) self.dlss_tick.setChecked(bool(s.get("Dlss"))) self.prepare_tick.setChecked(not s.get("PrepareLater")) r, x, n = s.get("Romfs"), s.get("Exefs"), s.get("Nup") if r and x and os.path.isdir(r) and os.path.isfile(os.path.join(x, "main")): self.romfs, self.exefs = r, x self.folders_note = "Using the folders %s and %s (as last time)" % (r, x) elif n and os.path.isfile(n): if not any(os.path.normcase(d.path) == os.path.normcase(n) for d in self.dumps): st = os.stat(n) self.dumps.insert(0, core.Dump(os.path.abspath(n), "Last time", st.st_size, st.st_mtime)) self.chosen_nup = n def save_settings(self): core.save_settings({"Out": self.out_path.text(), "Nup": None if self.romfs else self.chosen_nup, "Romfs": self.romfs, "Exefs": self.exefs, "Dlss": self.dlss_tick.isChecked(), "PrepareLater": not self.prepare_tick.isChecked()}) def preview(self, what): """(development) HOOKSHOT_UI_PREVIEW=build|ready|problem|update|launch: one screen with made-up progress, nothing run""" if what == "build": self.make_rows(False) self.set_step(1) self.show_page(self.build_page) self.rows["read"].begin(), self.rows["read"].done(), self.rows["read"].small_text("Version checked") self.rows["lift"].begin(), self.rows["lift"].done() self.rows["compile"].begin(), self.rows["compile"].small_text("31 of 58 files") self.set_progress(0.54) self.build_note.setText("About 19 minutes left · your PC stays usable") elif what == "ready": self.finished = self.out_path.text() self.elapsed0 = time.monotonic() - 2700 self.show_ready() elif what == "problem": self.show_problem("Files of the builder's own compiler are missing (clang.exe in tools\\llvm-mingw\\bin).", tools=True) elif what == "update": self.begin_update(self.out_path.text(), "honest-eta") self.rows["download"].done(), self.rows["download"].small_text("3 MB · build tools unchanged") self.rows["read"].begin(), self.rows["read"].done() self.rows["lift"].begin(), self.rows["lift"].done() self.rows["compile"].begin(), self.rows["compile"].small_text("7 of 516 files") self.set_progress(0.62) self.build_note.setText("About 3 minutes left. Your current game stays as it is until the new one is complete.") elif what == "launch": self.show_launcher(self.out_path.text()) # ================= 1: game files ================= def fill_dumps(self): while self.dump_list.count(): it = self.dump_list.takeAt(0) if it.widget(): it.widget().deleteLater() self.folders_label = None if self.romfs and self.exefs and self.folders_note: l = note(self.folders_note) l.setContentsMargins(16, 12, 16, 12) self.folders_label = l self.dump_list.addWidget(l) if not self.dumps: l = note("No .nup files in Downloads, Desktop, Documents or the top folders of your drives. Browse to yours, or drop it on " "this window.") l.setContentsMargins(16, 14, 16, 14) self.dump_list.addWidget(l) self.fit_dumps() return for i, d in enumerate(self.dumps): if i: self.dump_list.addWidget(Hline()) c = self.checks.get(d.path, "missing") why = c[1] if isinstance(c, tuple) and not c[0] and not c[1].startswith("This is build") else None row = DumpRow(d, self.chip(d.path), why) row.setChecked(self.chosen_nup is not None and os.path.normcase(d.path) == os.path.normcase(self.chosen_nup)) row.clicked.connect(lambda _=False, p=d.path: self.choose(p)) self.dump_list.addWidget(row) self.fit_dumps() def fit_dumps(self): """The list as tall as its rows, at most 128 (then it scrolls)""" def fit(): self.dump_list.activate() h = sum(self.dump_list.itemAt(i).widget().sizeHint().height() for i in range(self.dump_list.count()) if self.dump_list.itemAt(i).widget() is not None and not self.dump_list.itemAt(i).widget().isHidden()) self.dump_scroll.setFixedHeight(max(1, min(128, h + 1))) self.dump_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded if h > 128 else Qt.ScrollBarPolicy.ScrollBarAlwaysOff) fit() QTimer.singleShot(0, fit) def chip(self, path): c = self.checks.get(path) if c is None: ch = Chip("Checking…", "InkFaint") elif c[0]: ch = Chip("✓ Supported version", "Go", "GoSoft") elif c[1].startswith("This is build"): ch = Chip("Not the supported version", "Warn") else: ch = Chip("Can't be read", "Bad") if c is not None and not c[0]: ch.setToolTip(c[1]) return ch def check_all(self): """Each found file's version, one at a time; the first good one is chosen""" if self.checking: return tools = core.Tools.find() nxt = next((d for d in self.dumps if d.path not in self.checks), None) if tools else None if nxt is None: if self.chosen_nup is None and self.romfs is None and self.dumps and tools: self.chosen_nup = self.dumps[0].path self.fill_dumps() self.refresh() return self.checking = True self.checks[nxt.path] = None self.fill_dumps() import threading def run(): r = core.check(tools, ["--check", "--nup", nxt.path]) self.post(self.checked, nxt.path, r) threading.Thread(target=run, daemon=True).start() def checked(self, path, r): self.checking = False self.checks[path] = r if not r[0] and "antivirus" in r[1].lower(): self.show_problem(r[1], tools=True) return if self.chosen_nup is None and self.romfs is None and r[0]: self.chosen_nup = path self.fill_dumps() self.refresh() self.check_all() def choose(self, path): self.source_picked = True self.chosen_nup = path self.romfs = self.exefs = None if self.folders_label is not None: self.folders_label.deleteLater() self.folders_label = None self.refresh() def add_dump(self, path, where): path = os.path.abspath(path) if not any(os.path.normcase(d.path) == os.path.normcase(path) for d in self.dumps): st = os.stat(path) self.dumps.insert(0, core.Dump(path, where, st.st_size, st.st_mtime)) self.source_picked = True self.chosen_nup = path self.romfs = self.exefs = None self.fill_dumps() self.check_all() self.refresh() def source_ready(self): if self.romfs and self.exefs: return True c = self.checks.get(self.chosen_nup) if self.chosen_nup else None return bool(c and c[0]) def refresh(self, *_): self.build_button.setEnabled(self.source_ready() and len(self.out_path.text()) > 2) self.show_work() root, freeb = core.free_space(self.out_path.text()) if freeb is not None: self.space_bar.set(min(1.0, NEEDED_BYTES / max(1, freeb)), "Go" if freeb >= NEEDED_BYTES else "Bad") self.space_text.setText("Needs 45 GB · %s has %d GB free" % (root.rstrip("\\"), freeb >> 30)) set_color(self.space_text, "InkSoft" if freeb >= NEEDED_BYTES else "Bad") else: self.space_text.setText("Needs 45 GB") self.refresh_mode() def dragEnterEvent(self, e): if e.mimeData().hasUrls() and not self.runner: e.acceptProposedAction() def dropEvent(self, e): for u in e.mimeData().urls(): p = u.toLocalFile() if p.lower().endswith(".nup") and os.path.isfile(p): self.add_dump(p, "Dropped") elif os.path.isdir(os.path.join(p, "romfs")) and os.path.isdir(os.path.join(p, "exefs")): self.use_folders(os.path.join(p, "romfs"), os.path.join(p, "exefs")) def browse_nup(self): f, _ = QFileDialog.getOpenFileName(self, "Choose your game file", "", "Game file (*.nup)") if f: self.add_dump(os.path.normpath(f), "Chosen") def browse_folders(self): both = QFileDialog.getExistingDirectory(self, "Choose the folder with romfs and exefs (or the romfs folder)") if not both: return both = os.path.normpath(both) if os.path.isdir(os.path.join(both, "romfs")) and os.path.isdir(os.path.join(both, "exefs")): self.use_folders(os.path.join(both, "romfs"), os.path.join(both, "exefs")) return ex = QFileDialog.getExistingDirectory(self, "Now choose the exefs folder") if ex: self.use_folders(both, os.path.normpath(ex)) def use_folders(self, r, x): if not os.path.isfile(os.path.join(x, "main")): QMessageBox.information(self, "Hookshot", "That exefs folder has no file named main.") return self.source_picked = True self.romfs, self.exefs, self.chosen_nup = r, x, None self.folders_note = "Using the folders %s and %s" % (r, x) self.fill_dumps() self.refresh() def browse_out(self): d = QFileDialog.getExistingDirectory(self, "Choose where the game goes") if d: self.out_path.setText(os.path.normpath(d)) def browse_work(self): d = QFileDialog.getExistingDirectory(self, "Choose where Hookshot keeps its build files") if d: self.change_work(os.path.normpath(d)) def change_work(self, picked): try: core.move_work(picked) except OSError as e: QMessageBox.information(self, "Hookshot", "Hookshot cannot keep its build files there: %s" % e) self.refresh() def show_work(self): w = core.work() self.work_reset.setVisible(core.work_chosen()) self.work_note.setText( "Build files: about %s, kept in %s so that updates are quick (HOOKSHOT_KEEP_BUILD_FILES)." % (core.gb(core.BUILD_FILES_BYTES), w) if core.keep_build_files() else "Build files: about %s in %s while it builds; when the game is ready about 1 GB stays (the compiled code) so that updates " "compile only what changed." % (core.gb(core.BUILD_FILES_BYTES), w)) set_color(self.work_note, "InkSoft") root, freeb = core.free_space(w) if freeb is not None and freeb < core.BUILD_FILES_BYTES: self.work_note.setText(self.work_note.text() + " %s has only %s free." % (root.rstrip("\\"), core.gb(freeb))) set_color(self.work_note, "Bad") def language_changed(self, i): self.lang = strings.LANGUAGES[i] self.cancel_button.setText(self.T("Cancel")) self.back_button.setText(self.T("Back")) self.open_button.setText(self.T("OpenFolder")) self.play_button.setText(self.T("Play")) self.show_log.setText(self.T("HideDetails" if self.show_log.isChecked() else "ShowDetails")) # ================= 2: the build ================= def start_build(self): if self.mode == "update_game": self.save_settings() updater.update_folder(self, self.out_path.text(), self.update_target, False) return if self.mode == "up_to_date": self.finished = self.out_path.text() self.play() return if self.mode == "update_builder": self.save_settings() self.build_button.setEnabled(False) self.build_button.setText("Getting the new builder…") self.begin_update(self.out_path.text(), self.latest_tag) updater.run_latest_setup(self) return self.save_settings() tools = core.Tools.find() if not tools: self.show_problem("The build tools are not in Hookshot's folder.", tools=True) return if self.romfs and self.exefs: args = ["--romfs", self.romfs, "--exefs", self.exefs] elif self.chosen_nup: args = ["--nup", self.chosen_nup] else: return args += ["--out", self.out_path.text(), "--language", self.lang[0]] self.prepare_now = self.prepare_tick.isChecked() if not self.prepare_now: args.append(SHADERS_LATER) self.run(tools, args, dlss=self.dlss_tick.isChecked()) def dlss_changed(self): if self.dlss_tick.isChecked(): b = QMessageBox.question(self, "NVIDIA DLSS", DLSS_LICENSE, QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No) if b != QMessageBox.StandardButton.Yes: self.dlss_tick.setChecked(False) self.save_settings() # (kept at once: ticked and closed, it is still ticked next time) def make_rows(self, update, shaders=False): while self.stage_list.count(): it = self.stage_list.takeAt(0) if it.widget(): it.widget().deleteLater() self.rows = {} self.weight = WITH_SHADERS if shaders else WITHOUT_SHADERS lst = [s for s in STAGES if (update or s[0] != "download") and (shaders or s[0] != "shaders")] for i, (sid, b, u) in enumerate(lst): row = StepRow(i + 1, u if update else b, i == len(lst) - 1) self.rows[sid] = row self.stage_list.addWidget(row) if update: self.rows["read"].small_text("Your game files are kept: the .nup isn't needed") def hard_drive_warning(self): """The game folder or the build files folder on a hard drive: the build works, but much more slowly than on an SSD. None when both are on an SSD (or their drive cannot be told, as on a network share)""" for what, folder in (("game folder", self.out_path.text()), ("build files folder", core.work())): if core.spinning(folder) is not True: continue root = os.path.splitdrive(os.path.abspath(folder))[0] or folder return ("The %s is on a hard drive (%s). An SSD builds the game much faster: build there if you can.\n\n" "Choose OK to build here anyway, or Cancel to choose another folder." % (what, root)) return None def run(self, tools, args, keep_rows=False, dlss=False): # (a warning, not a stop: the player may have no other folder with the room. An update keeps its own flow) slow = None if keep_rows else self.hard_drive_warning() if slow and QMessageBox.question(self, "Hookshot", slow, QMessageBox.StandardButton.Ok | QMessageBox.StandardButton.Cancel) != QMessageBox.StandardButton.Ok: return sel = self.worker_box.currentText() workers = None if sel == core.AUTOMATIC else int(sel) if not keep_rows: self.updating = False self.make_rows(False, self.prepare_now) self.set_step(1) self.build_title.setText("Building your game") self.update_bar.hide() self.ring_box.show() self.log_lines = [] self.log_box.clear() self.current, self.finished = None, "" self.compiled, self.files_done, self.files_of = 0.0, 0, 0 self.files_changed, self.files_compiled, self.compile_eta = -1, 0, -1.0 self.this_compile, self.previous_total = 0, -1 self.shaders_began, self.shaders_later, self.built_in = False, None, None self.show_page(self.build_page) self.cancel_button.show() self.set_progress(self.weight["read"][0] if self.updating else 0) self.elapsed0, self.compile0 = time.monotonic(), None self.clock.start() self.tick() if core.work_chosen() and "--work" not in args: args += ["--work", core.work()] if dlss and "--fetch-ngx-sdk" not in args: args += ["--fetch-ngx-sdk", "--accept-nvidia-license"] self.runner = core.Runner(tools, args, workers, core.ngx_sdk() if dlss else None, on_line=lambda l: self.post(self.line, l), on_finished=lambda f: self.post(self.ended, f)) self.runner.start() FILES_LINE = re.compile(r"^(\d+) files, ") FILE_LINE = re.compile(r"^\s+\S+\s+\d+ MB\s+\d+s") def line(self, line): if line.startswith("@@stage "): sid = line.split(" ")[1] if self.current in self.rows: self.rows[self.current].done() self.current = sid if sid in self.rows: self.rows[sid].begin() if sid == "compile": self.compile0 = time.monotonic() if sid == "shaders": self.shaders_began = True if sid in self.weight: self.set_progress(self.weight[sid][0]) elif line.startswith("@@progress "): try: f = float(line[11:]) except ValueError: return if self.current in self.weight: if self.current == "compile": self.compiled = f w = self.weight[self.current] self.set_progress(w[0] + w[1] * max(0.0, min(1.0, f))) return elif line.startswith(("@@plan ", "@@file ", "@@eta ", "@@times ")): self.number(line) return elif line.startswith("@@done "): self.finished = line[7:] elif NOT_PREPARED.match(line): self.shaders_later = NOT_PREPARED.match(line).group(1) elif self.FILES_LINE.match(line): self.files_of = int(self.FILES_LINE.match(line).group(1)) elif self.FILE_LINE.match(line): self.files_done += 1 if self.current == "compile" and self.files_changed < 0 and self.files_of > 0 and "compile" in self.rows: self.rows["compile"].small_text("%d of %d files" % (self.files_done, self.files_of)) self.add_log(line) def number(self, line): p = line.split(" ") if p[0] == "@@plan" and len(p) == 3 and p[1].isdigit() and p[2].isdigit(): self.files_changed, self.files_of, self.files_compiled = int(p[1]), int(p[2]), 0 self.changed_files() elif p[0] == "@@file" and len(p) == 4 and p[3] in ("new", "again"): self.files_compiled += 1 self.changed_files() elif p[0] == "@@eta" and len(p) == 2: try: self.compile_eta = float(p[1]) except ValueError: pass elif p[0] == "@@times" and len(p) == 4: try: self.this_compile, self.previous_total = int(p[2]), int(p[3]) self.built_in = time.monotonic() - (self.elapsed0 or time.monotonic()) # (without the shaders' minutes) except ValueError: pass def changed_files(self): if self.files_changed < 0 or "compile" not in self.rows: return self.rows["compile"].small_text("Everything is already built" if self.files_changed == 0 else "%d of %d files" % (self.files_compiled, self.files_changed) if self.files_changed >= self.files_of else "%d of %d changed files" % (self.files_compiled, self.files_changed)) def add_log(self, line): self.log_lines.append(line) if len(self.log_lines) > 12000: del self.log_lines[:4000] if self.log_box.isVisible(): self.log_box.appendPlainText(line) def set_progress(self, f): f = max(0.0, min(1.0, f)) self.ring.set(f) self.update_bar.set(f) def tick(self): for r in self.rows.values(): r.tick() if not self.runner: return tail = ". Your current game stays as it is until the new one is complete." if self.updating else " · your PC stays usable" if self.current == "compile" and self.compile0: el = time.monotonic() - self.compile0 left = (time_left(self.compile_eta) if self.compile_eta >= 0 else time_left(el / self.compiled * (1 - self.compiled) + 60) if self.compiled > 0.03 else "Estimating…") self.build_note.setText("Compiling %s · %s%s" % (clock(el), left, tail)) return self.build_note.setText(("Working…" if self.updating else "Usually about 45 minutes") + tail) def ended(self, failure): self.clock.stop() self.runner = None if self.finished: for sid, r in self.rows.items(): why = None if sid != "shaders" else ("Left to the game's first start: %s" % self.shaders_later if self.shaders_later else None if self.shaders_began else "Left to the game's first start") if why: r.skipped() r.small_text(why) else: r.done() self.set_progress(1) self.show_ready() return if failure == "cancelled": self.set_step(0) self.show_page(self.files_page) return if self.current in self.rows: self.rows[self.current].stopped() self.show_problem(failure or "The build tools stopped without saying why.", tools=bool(failure and "antivirus" in failure.lower())) def log_toggled(self, show): self.log_box.setVisible(show) self.step_card.setVisible(not show) self.show_log.setText(self.T("HideDetails" if show else "ShowDetails")) if show: self.log_box.setPlainText("\n".join(self.log_lines)) self.log_box.verticalScrollBar().setValue(self.log_box.verticalScrollBar().maximum()) def cancel_build(self): if self.download: self.download.cancel() if self.runner: self.runner.cancel() # ================= 3: play ================= def show_ready(self): self.set_step(2) self.ready_title.setText("Your game is updated" if self.updating else "Your game is ready") took = time.monotonic() - (self.elapsed0 or time.monotonic()) compiled = " (compiled in %s)" % span(self.this_compile) if self.this_compile > 0 else "" self.ready_note.setText("%s in %s%s%s · %s" % ("Updated" if self.updating else "Built", span(took), compiled, self.against(self.built_in or took), self.finished)) if not os.environ.get("HOOKSHOT_UI_PREVIEW"): if not self.updating: core.shortcuts(self.finished, self.desktop_tick.isChecked(), self.start_tick.isChecked()) else: # (the ones the player has, onto the folder's launcher; the ticks say which there are) self.desktop_tick.setChecked(os.path.isfile(core.desktop_link())) self.start_tick.setChecked(os.path.isfile(core.start_link())) core.refresh_shortcuts(self.finished) if core.shortcut_error: self.add_log("shortcut not made: " + core.shortcut_error) self.show_page(self.ready_page) import threading def run(): if not core.keep_build_files(): left = core.free(after_build=True) if left >= 100 << 20: self.post(self.add_log, "build files: %s could not be deleted (a file in use); they go after the next build" % core.gb(left)) self.post(self.show_storage_use, *core.measure()) threading.Thread(target=run, daemon=True).start() def show_storage_use(self, total, freeable, extra=""): self.storage_row.hide() if total < 100 << 20: return where = "%s and %s" % (paths.base(), core.work()) if core.work_chosen() else paths.base() self.storage_note.setText( "Hookshot Builder keeps %s on this PC (%s). %s of it only makes the next update quicker and can be freed: your game keeps " "playing, and the next update then takes about as long as this build." % (core.gb(total), where, core.gb(freeable)) if freeable >= 100 << 20 else "Hookshot Builder keeps %s on this PC (%s): the builder itself." % (core.gb(total), where)) self.storage_note.setText(self.storage_note.text() + extra) self.free_button.setVisible(freeable >= 100 << 20) self.free_button.setEnabled(True) self.free_button.setText("Free up space") self.storage_row.show() def free_space(self): self.free_button.setEnabled(False) self.free_button.setText("Freeing…") import threading def run(): left = core.free() extra = (" (%s could not be deleted: a file is in use. Close the game and the builder, and delete the folder's contents by " "hand.)" % core.gb(left)) if left >= 100 << 20 else "" self.post(self.show_storage_use, *core.measure(), extra) threading.Thread(target=run, daemon=True).start() def shortcuts_changed(self): if self.finished: core.shortcuts(self.finished, self.desktop_tick.isChecked(), self.start_tick.isChecked()) def against(self, now): if self.previous_total <= 0: return "" diff = self.previous_total - now how = "about the same" if abs(diff) < 30 else "%s faster" % span(diff) if diff > 0 else "%s slower" % span(-diff) return " · last time %s (%s)" % (span(self.previous_total), how) def play(self): core.start_game(self.finished) self.showMinimized() # ================= when something goes wrong ================= def show_problem(self, why, tools): self.last_failure, self.problem_is_tools = why, tools while self.problem_steps.count(): it = self.problem_steps.takeAt(0) if it.widget(): it.widget().deleteLater() self.problem_sub.setText("Your current game is unchanged and still plays." if self.updating else "Nothing was changed in your game folder.") if tools: self.problem_title.setText("The build tools need repairing") self.problem_head.setText("Your antivirus removed part of the build tools") self.problem_text.setText(why + "\n\nAntivirus programs sometimes flag unsigned developer tools by mistake.") for n, s in ((1, "Open Windows Security → Protection history, and restore the removed files."), (2, "Or add %s to its exclusions." % paths.base()), (3, "Then press Repair: Hookshot downloads the tools again from their official releases and checks each one.")): l = note("%d. %s" % (n, s), 14) l.setContentsMargins(0, 6, 0, 0) self.problem_steps.addWidget(l) else: self.problem_title.setText("The update stopped" if self.updating else "The build stopped") self.problem_head.setText("What went wrong") self.problem_text.setText(why) self.repair_button.setText("Repair") self.repair_button.setVisible(tools) self.problem_details.setText("Show details") if not self.updating: self.set_step(1) self.show_page(self.problem_page) QTimer.singleShot(0, self.fit_problem) def fit_problem(self): w = self.problem_scroll.widget() w.adjustSize() h = w.layout().sizeHint().height() if w.layout() else w.sizeHint().height() h = w.layout().heightForWidth(self.problem_scroll.viewport().width()) if w.layout() and w.layout().hasHeightForWidth() else h self.problem_scroll.setFixedHeight(max(20, min(190, h + 2))) def problem_show_details(self): while self.problem_steps.count(): it = self.problem_steps.takeAt(0) if it.widget(): it.widget().deleteLater() box = LogBox(border=False) box.setPlainText("\n".join(self.log_lines[-80:])) box.setMinimumHeight(160) self.problem_steps.addWidget(box) self.problem_scroll.setFixedHeight(190) def copy_for_report(self): tools = core.Tools.find() import platform text = "Hookshot Builder %s on Windows %s\n%s: %s\n\n%s" % (tools.version if tools and tools.version else "(source)", platform.version(), self.problem_title.text(), self.last_failure, "\n".join(self.log_lines[-200:])) QGuiApplication.clipboard().setText(text) self.copy_report.setText("Copied") def back(self): self.set_step(0) self.show_page(self.files_page) def repair(self): """The build tools checked against their checksums and downloaded again, after this window closes""" updater.restart(["--repair"]) QApplication.quit() # ================= the update (updater.py) ================= def begin_update(self, folder, tag): self.updating = True self.out_path.setText(folder) self.finished = "" to = tag or "the latest version" tools = core.Tools.find() frm = core.game_version(folder) or (tools.version if tools else None) self.step_pill.hide() self.version_chip.setText("%s → %s" % (frm, to) if frm and frm != to else to) self.version_chip.adjustSize() self.version_chip.show() self.prepare_now = not core.load_settings().get("PrepareLater") # (the saved choice: an update never shows the tick) self.make_rows(True, self.prepare_now) self.build_title.setText("Updating your game") self.build_note.setText("Getting the update…") self.ring_box.hide() self.update_bar.show() self.set_progress(0) self.rows["download"].begin() self.cancel_button.show() self.show_page(self.build_page) def download_progress(self, f): if "download" in self.rows: self.rows["download"].small_text("%d%%" % int(f * 100)) self.set_progress(self.weight["download"][1] * f) def note(self, line): self.add_log(line) if "download" in self.rows: self.rows["download"].small_text(line) def download_failed(self, why): self.download = None if "download" in self.rows: self.rows["download"].stopped() self.show_problem(why, tools=False) self.problem_title.setText("The update could not be downloaded") def update_build(self, tools, folder): """The new tools are here: the folder built again with them (only what changed is compiled)""" self.download = None if "download" in self.rows: self.rows["download"].done() self.rows["download"].small_text("Build tools checked") dlss = os.path.isfile(os.path.join(folder, "ngx", "nvngx_dlss.dll")) and os.path.isfile(os.path.join(core.ngx_sdk(), "LICENSE.txt")) self.run(tools, ["--update", folder] + ([] if self.prepare_now else [SHADERS_LATER]), keep_rows=True, dlss=dlss) def quit_app(self): QApplication.quit() # ================= the window ================= def close_window(self): if self.runner and QMessageBox.question(self, "Hookshot", self.T("CloseQuestion"), QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No) != QMessageBox.StandardButton.Yes: return if self.runner: self.runner.cancel() self.close() class ProblemCard(QFrame): """The problem's box: radius 10, #55E2776B border, #14E2776B fading to clear by 70%""" def paintEvent(self, e): p = QPainter(self) p.setRenderHint(QPainter.RenderHint.Antialiasing) r = QRectF(self.rect()).adjusted(0.5, 0.5, -0.5, -0.5) lg = QLinearGradient(r.topLeft(), r.bottomLeft()) lg.setColorAt(0, argb("#14E2776B")) lg.setColorAt(0.7, argb("#00E2776B")) lg.setColorAt(1, argb("#00E2776B")) p.fillPath(rounded(r, 10), lg) p.setPen(QPen(argb("#55E2776B"), 1)) p.drawPath(rounded(r, 10)) # ================= Glass.cs: Windows 11's acrylic, dark title colours and round corners (DWM) ================= def light_backdrop(): try: with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize") as k: for name in ("SystemUsesLightTheme", "AppsUseLightTheme"): try: return winreg.QueryValueEx(k, name)[0] != 0 except OSError: continue except OSError: pass return False class MARGINS(ctypes.Structure): _fields_ = [("l", ctypes.c_int), ("r", ctypes.c_int), ("t", ctypes.c_int), ("b", ctypes.c_int)] def apply_glass(hwnd): """true: acrylic is on (the window's background stays see-through)""" import ctypes.wintypes dwm, user = ctypes.windll.dwmapi, ctypes.windll.user32 GWL_STYLE = -16 style = user.GetWindowLongPtrW(ctypes.c_void_p(hwnd), GWL_STYLE) # (a framed window: Windows draws the backdrop only behind one; without the system menu it draws no caption buttons of its own) style = (style | 0x00C00000 | 0x00040000) & ~0x00080000 # (WS_CAPTION | WS_THICKFRAME, no WS_SYSMENU) style &= ~0x00040000 # (no resizing border: the window is always 960x600) user.SetWindowLongPtrW(ctypes.c_void_p(hwnd), GWL_STYLE, ctypes.c_void_p(style)) user.SetWindowPos(ctypes.c_void_p(hwnd), None, 0, 0, 0, 0, 0x0027) # (SWP_FRAMECHANGED | NOMOVE | NOSIZE | NOZORDER) on = ctypes.c_int(1) dwm.DwmSetWindowAttribute(ctypes.c_void_p(hwnd), 20, ctypes.byref(on), 4) # dark mode corner = ctypes.c_int(2) dwm.DwmSetWindowAttribute(ctypes.c_void_p(hwnd), 33, ctypes.byref(corner), 4) # round corners if light_backdrop(): return False if sys.getwindowsversion().build < 22621: # (22H2: the backdrop attribute) return False hc = ctypes.wintypes.BOOL() m = MARGINS(-1, -1, -1, -1) dwm.DwmExtendFrameIntoClientArea(ctypes.c_void_p(hwnd), ctypes.byref(m)) backdrop = ctypes.c_int(3) # acrylic return dwm.DwmSetWindowAttribute(ctypes.c_void_p(hwnd), 38, ctypes.byref(backdrop), 4) == 0