tfbscript 0.1.0__py3-none-any.whl

tfbscript/editor/fonts/ms-sans-serif-bold/readme.txt

@@ -0,0 +1,26 @@
+The font file in this archive was created using Fontstruct the free, online
+font-building tool.
+This font was created by “lou”.
+This font has a homepage where this archive and other versions may be found:
+https://fontstruct.com/fontstructions/show/1384862
+
+Try Fontstruct at http://fontstruct.com
+It’s easy and it’s fun.
+
+NOTE FOR FLASH USERS: Fontstruct fonts (fontstructions) are optimized for Flash.
+If the font in this archive is a pixel font, it is best displayed at a font-size
+of 11.
+
+Fontstruct is sponsored by FontShop.
+Visit them at https://fontshop.com
+FontShop is the original independent font retailer. We’ve been around since
+the dawn of digital type. Whether you need the right font or need to create the
+right font from scratch, let our 26 years of experience work for you.
+
+Fontstruct is copyright ©2017 Rob Meek
+
+LEGAL NOTICE:
+In using this font you must comply with the licensing terms described in the
+file “license.txt” included with this archive.
+If you redistribute the font file in this archive, it must be accompanied by all
+the other files from this archive, including this one.

tfbscript/editor/fonts.py

@@ -0,0 +1,98 @@
+# pyright: basic
+
+import io
+from pathlib import Path
+
+from fontTools.ttLib import TTFont
+
+from PySide6.QtGui import QFont, QFontDatabase
+
+
+def load_font(
+    path: str | Path,
+    size: int = 11,
+    weight: QFont.Weight = QFont.Weight.Normal,
+    italic: bool = False,
+    aliased: bool = True,
+) -> QFont:
+    """
+    Load a custom font from file, rendered GDI-style (grid-fitted, no AA).
+
+    Args:
+        path: Path to the font file (.ttf, .otf, etc.), or a Qt resource path
+        size: Size in PIXELS (not points) — 11px == XP's default 8pt Tahoma
+        weight: Font weight (e.g. QFont.Weight.Normal, QFont.Weight.Bold)
+        italic: Whether the font should be italic
+        aliased: True for crisp XP "standard" text, False for soft ClearType-ish text
+
+    Returns:
+        The QFont instance.
+
+    Raises:
+        ValueError: if the font file could not be loaded.
+    """
+    font_id = QFontDatabase.addApplicationFont(str(path))
+
+    if font_id == -1:
+        raise ValueError(f"Failed to load font from: {path}")
+
+    families = QFontDatabase.applicationFontFamilies(font_id)
+    if not families:
+        raise ValueError(f"No font families found in: {path}")
+
+    font = QFont(families[0])
+    font.setPixelSize(size)  # pixel size, so DPI can't rescale us into mush
+    font.setWeight(weight)
+    font.setItalic(italic)
+
+    if aliased:
+        # Hard pixel edges + snap stems to the pixel grid == comctl32 look
+        font.setStyleStrategy(
+            QFont.StyleStrategy(
+                QFont.StyleStrategy.NoAntialias | QFont.StyleStrategy.PreferMatch
+            )
+        )
+        font.setHintingPreference(QFont.HintingPreference.PreferFullHinting)
+    else:
+        # Soft, slightly smeared — closer to ClearType on a non-LCD display
+        font.setStyleStrategy(QFont.StyleStrategy.PreferAntialias)
+        font.setHintingPreference(QFont.HintingPreference.PreferNoHinting)
+
+    return font
+
+
+def register_bold_variant(regular_family: str, bold_path: str | Path) -> None:
+    """
+    Load `bold_path` as the Bold weight of `regular_family`.
+
+    The bold TTF's own name/OS2 tables declare it as an unrelated Regular-weight
+    family (e.g. "MS Sans Serif Bold" @ weight 400), so Qt registers it as a
+    separate font family and `font-weight: bold` on the regular family just
+    synthesizes a fake bold instead of using the real hinted glyphs. Patch the
+    tables in memory so Qt sees it as `regular_family`'s Bold style.
+    """
+    font = TTFont(str(bold_path))
+
+    name = font["name"]
+    for name_id, value in (
+        (1, regular_family),
+        (2, "Bold"),
+        (4, f"{regular_family} Bold"),
+        (16, regular_family),
+        (17, "Bold"),
+    ):
+        name.setName(value, name_id, 3, 1, 0x409)
+        name.setName(value, name_id, 1, 0, 0)
+
+    os2 = font["OS/2"]
+    os2.usWeightClass = 700  # pyright: ignore[reportAttributeAccessIssue]
+    os2.fsSelection = (  # pyright: ignore[reportAttributeAccessIssue]
+        os2.fsSelection & ~0x40  # pyright: ignore[reportAttributeAccessIssue]
+    ) | 0x20  # clear REGULAR, set BOLD
+    font["head"].macStyle |= 0x1  # pyright: ignore[reportAttributeAccessIssue]
+
+    buf = io.BytesIO()
+    font.save(buf)
+
+    if QFontDatabase.addApplicationFontFromData(buf.getvalue()) == -1:
+        raise ValueError(f"Failed to register bold variant from: {bold_path}")

tfbscript/editor/search.py

@@ -0,0 +1,200 @@
+# pyright: basic
+
+from dataclasses import dataclass, field
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QKeySequence, QShortcut
+from PySide6.QtWidgets import (
+    QAbstractItemView,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QPushButton,
+    QTreeWidget,
+    QTreeWidgetItem,
+    QWidget,
+)
+
+ROW_OBJECT_NAME = "tfbRow"
+
+MATCH_BG = "#FFF2A8"
+CURRENT_MATCH_BG = "#FFC63F"
+
+# Space kept around a row's fields so a highlight doesn't hug the text
+ROW_PADDING = 3
+
+
+def row_text(layout: QHBoxLayout) -> str:
+    """Flattens a rendered row into one searchable string.
+
+    Reads the already-built widgets rather than the opcode itself: rendering a
+    reference needs the enclosing-op stack, which only exists while the tree is
+    being populated.
+    """
+    parts: list[str] = []
+    for i in range(layout.count()):
+        item = layout.itemAt(i)
+        if item is None:
+            continue
+        widget = item.widget()
+        if isinstance(widget, (QLabel, QPushButton)):
+            parts.append(widget.text())
+    return " ".join(parts)
+
+
+@dataclass
+class SearchEntry:
+    item: QTreeWidgetItem
+    content: QWidget
+    _text: str = field(default="", repr=False)
+
+    def text(self) -> str:
+        return self._text
+
+    def set_text(self, text: str) -> None:
+        self._text = text.lower()
+
+
+class SearchBar(QWidget):
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(6, 3, 6, 3)
+        layout.setSpacing(4)
+
+        self.edit = QLineEdit()
+        self.edit.setPlaceholderText("Find")
+        self.edit.setClearButtonEnabled(False)
+
+        self.status = QLabel("")
+        self.status.setMinimumWidth(90)
+        self.status.setAlignment(
+            Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter
+        )
+
+        self.prev_button = QPushButton("Previous")
+        self.next_button = QPushButton("Next")
+        self.close_button = QPushButton("Close")
+
+        layout.addWidget(QLabel("Find:"))
+        layout.addWidget(self.edit, 1)
+        layout.addWidget(self.status)
+        layout.addWidget(self.prev_button)
+        layout.addWidget(self.next_button)
+        layout.addWidget(self.close_button)
+
+
+class TreeSearch:
+    """Incremental find over the rows of the opcode tree.
+
+    Rows are custom item widgets, so matching runs against the flattened text of
+    each opcode and the hit is shown by tinting the row's container widget.
+    """
+
+    def __init__(self, tree: QTreeWidget, bar: SearchBar, entries: list[SearchEntry]):
+        self.tree = tree
+        self.bar = bar
+        self.entries = entries
+        self.matches: list[int] = []
+        self.current = -1
+
+        for entry in entries:
+            entry.content.setObjectName(ROW_OBJECT_NAME)
+            entry.content.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+
+        bar.edit.textChanged.connect(self._on_query_changed)
+        bar.edit.returnPressed.connect(self.next_match)
+        bar.next_button.clicked.connect(self.next_match)
+        bar.prev_button.clicked.connect(self.previous_match)
+        bar.close_button.clicked.connect(self.close)
+
+        shift_return = QShortcut(
+            QKeySequence(Qt.KeyboardModifier.ShiftModifier | Qt.Key.Key_Return), bar.edit
+        )
+        shift_return.setContext(Qt.ShortcutContext.WidgetShortcut)
+        shift_return.activated.connect(self.previous_match)
+
+        escape = QShortcut(QKeySequence(Qt.Key.Key_Escape), bar)
+        escape.setContext(Qt.ShortcutContext.WidgetWithChildrenShortcut)
+        escape.activated.connect(self.close)
+
+        bar.hide()
+
+    def open(self) -> None:
+        self.bar.show()
+        self.bar.edit.setFocus()
+        self.bar.edit.selectAll()
+        self._search(self.bar.edit.text())
+
+    def close(self) -> None:
+        self._clear_highlights()
+        self.matches = []
+        self.current = -1
+        self.bar.hide()
+
+    def next_match(self) -> None:
+        self._step(1)
+
+    def previous_match(self) -> None:
+        self._step(-1)
+
+    def _on_query_changed(self, query: str) -> None:
+        self._search(query)
+
+    def _search(self, query: str) -> None:
+        self._clear_highlights()
+
+        needle = query.strip().lower()
+        if not needle:
+            self.matches = []
+            self.current = -1
+            self.bar.status.setText("")
+            return
+
+        self.matches = [
+            i for i, entry in enumerate(self.entries) if needle in entry.text()
+        ]
+        self.current = 0 if self.matches else -1
+        self._apply_highlights()
+        self._reveal_current()
+        self._update_status()
+
+    def _step(self, delta: int) -> None:
+        if not self.matches:
+            return
+        self.current = (self.current + delta) % len(self.matches)
+        self._apply_highlights()
+        self._reveal_current()
+        self._update_status()
+
+    def _clear_highlights(self) -> None:
+        for index in self.matches:
+            self.entries[index].content.setStyleSheet("")
+
+    def _apply_highlights(self) -> None:
+        for position, index in enumerate(self.matches):
+            color = CURRENT_MATCH_BG if position == self.current else MATCH_BG
+            self.entries[index].content.setStyleSheet(
+                f"#{ROW_OBJECT_NAME} {{ background-color: {color}; }}"
+            )
+
+    def _reveal_current(self) -> None:
+        if self.current < 0:
+            return
+        item = self.entries[self.matches[self.current]].item
+
+        parent = item.parent()
+        while parent is not None:
+            parent.setExpanded(True)
+            parent = parent.parent()
+
+        self.tree.scrollToItem(
+            item, QAbstractItemView.ScrollHint.PositionAtCenter
+        )
+
+    def _update_status(self) -> None:
+        if not self.matches:
+            self.bar.status.setText("No results")
+        else:
+            self.bar.status.setText(f"{self.current + 1} of {len(self.matches)}")

tfbscript/editor/style.py

@@ -0,0 +1,141 @@
+# pyright: basic
+
+from PySide6.QtCore import Qt, QRect
+from PySide6.QtGui import QColor, QPainter, QPalette, QPen
+from PySide6.QtWidgets import QProxyStyle, QStyle, QStyleOption, QWidget
+
+BG = QColor("#DCDCDC")
+TEXT = QColor("#101010")
+
+
+def tfb_colored_box(element: QWidget, color: str):
+    element.setStyleSheet(
+        f"background-color: {color}; color: #FFFFFF; padding: 0px 4px;"
+    )
+
+
+def build_palette() -> QPalette:
+    palette = QPalette()
+    palette.setColor(QPalette.ColorRole.Window, BG)
+    palette.setColor(QPalette.ColorRole.WindowText, TEXT)
+    palette.setColor(QPalette.ColorRole.Base, BG)
+    palette.setColor(QPalette.ColorRole.AlternateBase, BG.lighter(105))
+    palette.setColor(QPalette.ColorRole.ToolTipBase, BG)
+    palette.setColor(QPalette.ColorRole.ToolTipText, TEXT)
+    palette.setColor(QPalette.ColorRole.Text, TEXT)
+    palette.setColor(QPalette.ColorRole.Button, BG)
+    palette.setColor(QPalette.ColorRole.ButtonText, TEXT)
+    palette.setColor(QPalette.ColorRole.BrightText, QColor("red"))
+    palette.setColor(QPalette.ColorRole.Link, QColor(42, 130, 218))
+    palette.setColor(QPalette.ColorRole.Highlight, QColor(42, 130, 218))
+    palette.setColor(QPalette.ColorRole.HighlightedText, QColor("white"))
+
+    # Disabled state, so grayed-out buttons/labels don't go invisible
+    palette.setColor(
+        QPalette.ColorGroup.Disabled, QPalette.ColorRole.WindowText, QColor("#707070")
+    )
+    palette.setColor(
+        QPalette.ColorGroup.Disabled, QPalette.ColorRole.Text, QColor("#707070")
+    )
+    palette.setColor(
+        QPalette.ColorGroup.Disabled, QPalette.ColorRole.ButtonText, QColor("#707070")
+    )
+
+    return palette
+
+
+class Win98TreeStyle(QProxyStyle):
+    """Redraws QTreeView branch connectors as classic Win98/comctl32-style
+    dotted lines and a dotted-bordered +/- box, instead of Fusion's arrows."""
+
+    LINE_COLOR = QColor("#97A1AD")
+    BOX_SIZE = 11
+
+    CONTENT_OFFSET = 0
+
+    BOX_INSET = 20
+
+    def drawPrimitive(
+        self,
+        element: QStyle.PrimitiveElement,
+        option: QStyleOption,
+        painter: QPainter,
+        widget: QWidget | None = None,
+    ) -> None:
+        if element == QStyle.PrimitiveElement.PE_IndicatorBranch:
+            self._draw_branch(option, painter)
+            return
+        super().drawPrimitive(element, option, painter, widget)
+
+    def _draw_branch(self, option: QStyleOption, painter: QPainter) -> None:
+        rect = option.rect
+        mid_x = max(rect.left(), rect.right() - self.BOX_INSET)
+        mid_y = rect.center().y()
+        state = option.state
+
+        has_children = bool(state & QStyle.StateFlag.State_Children)
+        has_sibling = bool(state & QStyle.StateFlag.State_Sibling)
+        is_item = bool(state & QStyle.StateFlag.State_Item)
+        is_open = bool(state & QStyle.StateFlag.State_Open)
+
+        painter.save()
+        pen = QPen(self.LINE_COLOR)
+        pen.setWidth(1)
+        pen.setStyle(Qt.PenStyle.DotLine)
+        painter.setPen(pen)
+
+        if has_sibling:
+            painter.drawLine(
+                mid_x + self.CONTENT_OFFSET,
+                rect.top(),
+                mid_x + self.CONTENT_OFFSET,
+                rect.bottom(),
+            )
+        elif is_item:
+            painter.drawLine(
+                mid_x + self.CONTENT_OFFSET,
+                rect.top(),
+                mid_x + self.CONTENT_OFFSET,
+                mid_y,
+            )
+
+        # Horizontal line
+        if is_item:
+            painter.drawLine(
+                mid_x + self.CONTENT_OFFSET,
+                mid_y,
+                rect.right() + self.CONTENT_OFFSET,
+                mid_y,
+            )
+
+        painter.restore()
+
+        if has_children:
+            box_size = max(7, min(self.BOX_SIZE, rect.width() - 2, rect.height() - 2))
+            if box_size % 2 == 0:
+                box_size -= 1
+            half = box_size // 2
+
+            box_x = mid_x - half
+            box_y = mid_y - half
+            box = QRect(box_x, box_y, box_size, box_size)
+
+            painter.save()
+            painter.setPen(QPen(QColor("#788897"))) # BOX BORDER COLOR
+            painter.setBrush(QColor("#DCDCDC")) # BOX BG COLOR
+            painter.drawRect(box)
+
+            painter.setPen(QPen(QColor("#3F3F3F"))) # SIGN COLOR
+
+            # + or - sign
+            sign_x = mid_x + self.CONTENT_OFFSET
+            painter.drawLine(box.left() + 2, box_y + half, box.right() - 2, box_y + half) # -
+            if not is_open: # |  (| + - = +)
+                painter.drawLine(
+                    sign_x,
+                    box.top() + 2,
+                    sign_x,
+                    box.bottom() - 2,
+                )
+
+            painter.restore()