readymade 0.0.1__tar.gz

readymade-0.0.1/.gitattributes

@@ -0,0 +1 @@
+* text eol=lf

readymade-0.0.1/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+*.egg-info/
+build/
+dist/

readymade-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph E. Coleman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

readymade-0.0.1/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.5
+Name: readymade
+Version: 0.0.1
+Summary: Visual Basic-style forms for Python: draw a form, double-click to write its code, press F5
+Author: Joseph E. Coleman
+License-Expression: MIT
+License-File: LICENSE
+Keywords: form designer,gui,ide,python,rad,tkinter,visual basic
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: MacOS X
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: X11 Applications
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.11
+Provides-Extra: ide
+Requires-Dist: jedi>=0.19; extra == 'ide'
+Requires-Dist: pillow>=10.1; extra == 'ide'
+Requires-Dist: pygments>=2.15; extra == 'ide'
+Description-Content-Type: text/markdown
+
+# readymade
+
+**readymade** is a Python language version of a classic VB style coding experience. 
+This is for small tools that might need a user interface.  You draw on a form,
+double-click a button to write its code, press F5 to run.  **readymade** aims to
+leave almost no time between having an idea and running the program.
+
+> Still early: readymade is a pre-alpha. It works, and it's changing quickly.
+
+## What it does
+
+- **A form designer.** Draw controls from the Toolbox (Label, TextBox, Button,
+  CheckBox, OptionButton, ComboBox, ListBox, Frame, Image, Canvas, Timer), then set
+  their properties in the Properties panel. Align and size them with the Format menu,
+  design menus in the Menu Editor, and set the tab order by clicking.
+- **Double-click to code.** Double-clicking a control takes you to its event handler,
+  written for you as a method named after it: `Button1_click`, `Form_load`.
+- **F5 to run.** While your program runs, the Immediate window runs Python inside it.
+  A run-time error takes you to the line that failed.
+- **Plain Python.** A form is two files: a `.form` file (JSON, for the layout) and a
+  `.py` file (your code).  One can run the form directly with python without starting
+  the IDE by running just the python file, `python path/to/Form.py`.
+- **Projects.** A project has a `pyproject.toml`, its own virtual environment and
+  libraries (Project > Add Library), linting and formatting with the tools you choose,
+  and Make EXE (via PyInstaller), which turns it into a program that runs without Python.
+- **The toolkit is Tkinter**, which comes with Python, so programs need nothing else
+  installed. Pillow, if you add it to a project, opens more picture formats and lets
+  programs draw on pictures.
+
+```python
+from readymade import Form, msgbox
+
+
+class Form1(Form):
+    def Button1_click(self):
+        name = self.TextBox1.text.strip() or "World"
+        msgbox(f"Hello, {name}!")
+
+
+if __name__ == "__main__":
+    Form1.run()
+```
+
+## Install and start
+
+readymade needs Python 3.11 or later, with Tkinter (Python's Windows and macOS
+installers include it; on Linux it may be a separate package, like `python3-tk`).
+
+```
+python -m pip install "readymade[ide]"
+readymade my-first-project
+```
+
+`readymade` opens the IDE, creating the project folder if it doesn't exist
+(`python -m readymade.ide` does the same). The `ide` extra adds syntax coloring
+(Pygments), completion with Go to Definition (Jedi), and JPEG and other pictures in
+the designer (Pillow). The IDE works without them. A program that uses Pillow, to
+show those pictures or draw on them, needs it in its own project too
+(Project > Add Library), so that Make EXE includes it.
+
+Press F1 in the IDE for help on whatever you're working on.
+
+## Disclosure
+
+I used Claude. 
+
+## License
+
+MIT. See [LICENSE](LICENSE).

readymade-0.0.1/README.md

@@ -0,0 +1,69 @@
+# readymade
+
+**readymade** is a Python language version of a classic VB style coding experience. 
+This is for small tools that might need a user interface.  You draw on a form,
+double-click a button to write its code, press F5 to run.  **readymade** aims to
+leave almost no time between having an idea and running the program.
+
+> Still early: readymade is a pre-alpha. It works, and it's changing quickly.
+
+## What it does
+
+- **A form designer.** Draw controls from the Toolbox (Label, TextBox, Button,
+  CheckBox, OptionButton, ComboBox, ListBox, Frame, Image, Canvas, Timer), then set
+  their properties in the Properties panel. Align and size them with the Format menu,
+  design menus in the Menu Editor, and set the tab order by clicking.
+- **Double-click to code.** Double-clicking a control takes you to its event handler,
+  written for you as a method named after it: `Button1_click`, `Form_load`.
+- **F5 to run.** While your program runs, the Immediate window runs Python inside it.
+  A run-time error takes you to the line that failed.
+- **Plain Python.** A form is two files: a `.form` file (JSON, for the layout) and a
+  `.py` file (your code).  One can run the form directly with python without starting
+  the IDE by running just the python file, `python path/to/Form.py`.
+- **Projects.** A project has a `pyproject.toml`, its own virtual environment and
+  libraries (Project > Add Library), linting and formatting with the tools you choose,
+  and Make EXE (via PyInstaller), which turns it into a program that runs without Python.
+- **The toolkit is Tkinter**, which comes with Python, so programs need nothing else
+  installed. Pillow, if you add it to a project, opens more picture formats and lets
+  programs draw on pictures.
+
+```python
+from readymade import Form, msgbox
+
+
+class Form1(Form):
+    def Button1_click(self):
+        name = self.TextBox1.text.strip() or "World"
+        msgbox(f"Hello, {name}!")
+
+
+if __name__ == "__main__":
+    Form1.run()
+```
+
+## Install and start
+
+readymade needs Python 3.11 or later, with Tkinter (Python's Windows and macOS
+installers include it; on Linux it may be a separate package, like `python3-tk`).
+
+```
+python -m pip install "readymade[ide]"
+readymade my-first-project
+```
+
+`readymade` opens the IDE, creating the project folder if it doesn't exist
+(`python -m readymade.ide` does the same). The `ide` extra adds syntax coloring
+(Pygments), completion with Go to Definition (Jedi), and JPEG and other pictures in
+the designer (Pillow). The IDE works without them. A program that uses Pillow, to
+show those pictures or draw on them, needs it in its own project too
+(Project > Add Library), so that Make EXE includes it.
+
+Press F1 in the IDE for help on whatever you're working on.
+
+## Disclosure
+
+I used Claude. 
+
+## License
+
+MIT. See [LICENSE](LICENSE).

readymade-0.0.1/TODO.md

@@ -0,0 +1,47 @@
+# To do
+
+Ideas and gaps noted along the way, roughly by area.
+
+## Runtime
+- **Menu item `visible`**: Tk can't hide a menu entry; supporting it means rebuilding the menu.
+- **Break mode**: pause a running program at an error, as VB did (needs a debugger).
+- **macOS shortcuts**: treat "Ctrl" as ⌘ (Command) and "Alt" as Option on macOS, the way Qt and Electron's CmdOrCtrl do, and show native ⌘O labels. Needs a Mac to check how Tk on macOS parses accelerator labels, and whether its native menus already fire the shortcut (which would make readymade's own binding run handlers twice). The IDE's own shortcuts (Ctrl+S, Ctrl+Z, ...) should follow the same rule.
+- **Check keypress names on a Mac**: `readymade/keys.py` already reports ⌘ as "Ctrl" (so ⌘S is "Ctrl+S"), the Control key as "MacCtrl", and Option as "Alt" unless it types a character. The state bits (Command 0x8, Option 0x10) and the modifier keys' own names (is ⌘ alone "Meta_L"?) come from Tk's documentation, not a real Mac. To check: a form with a TextBox whose keypress handler prints `key`; ⌘S, ⌃S, ⌥S, ⌥E then E, ⌘ alone and Shift+⌘Z should print `Ctrl+S`, `MacCtrl+S`, `ß`, `é`, `Ctrl`, `Ctrl+Shift+Z`.
+
+## IDE
+- **Copy and paste**: optionally bring the controls' event handlers along (renamed to match), which VB never did. Also a selection box inside a Frame (today it only works on the form itself; Ctrl+click works anywhere).
+- **Project Explorer**: remove a form, module or library.
+- **Environments**: create conda/mamba environments (existing ones work via Choose Python Interpreter).
+- **Add Library**: keep comments inside the `dependencies` list when it's rewritten.
+- **Code window**: after jumping to a run-time error, name the handler in the Object/Event dropdowns.
+- **Renaming a form**: also update references to it in other files (like `forms.OldName`).
+
+## Code editor
+- **Settings**: indent width (4 spaces today, a constant in `readymade/ide/codeview.py`), font, theme. Needs an IDE settings dialog.
+- **Themes**: a dark theme; the colors are all in `readymade/ide/highlight.py`. Also mark a run-time error's line in the line numbers.
+- **Folding** and an outline, from an error-tolerant parser (parso, MIT). The same parsing would let Enter see past the current line: today, after a call spread over several lines, the next line keeps the continuation indent instead of returning to the statement's level.
+- **A language server option (LSP)**: completion and definitions use Jedi today. An LSP client would let people choose Pyright (or basedpyright, which pip-installs with its own Node.js), python-lsp-server, jedi-language-server or Ruff's server, configured like linting, and would also bring hover info, signature help and rename. Pylance can't be used outside Microsoft's VS Code. The form-control declarations (assist.py) carry over, as the IDE chooses the text it sends.
+- **Completion follow-ups**: `forms.<name>` (forms are found by name at run time), signatures and docstrings beside the list, Back after Go to Definition (Alt+Left).
+- **Help follow-ups**: show help beside the completion list for the chosen entry; help on hover; links between topics (a property's help linking to its control); format reStructuredText and Google-style docstrings instead of showing them as plain text.
+  - Color codes get stripped out via PYTHON_COLORS or NO_COLOR because that broke the "jump to error line" feature.  Is there ever a situation where colors in help could be useful?
+- **Formatting follow-ups**: format just the selection; let a project insist on no formatting (today an unset project falls back to each person's default); format in the background instead of briefly waiting with a busy cursor.
+- **Linting follow-ups**: a Problems list next to the Immediate window (every problem in the project, click to jump); quick fixes (`ruff check --fix`); different colors for errors and warnings; pylint/mypy checking as you type via a temporary copy.
+- These libraries would be IDE-only dependencies, like Pygments in the `ide` extra (`pip install -e ".[ide]"`), so programs never need them.
+
+## Bigger features
+- **Make EXE options**: an icon, one-folder instead of one-file, version details. (Extra files are bundled: pictures the forms show, and `[tool.readymade] include`; perhaps an Include list in the Project Explorer rather than editing pyproject.toml.) Perhaps a small dialog, with various build options. Options true everywhere (icon, name) belong in `pyproject.toml`'s `[tool.readymade]`; anything tied to one machine (a signing certificate, an interpreter) in `.readymade/local.json`, kept per machine and out of git.
+    - Longer term idea, executables need to be able to be signed. 
+- **More controls**: third-party controls from installed libraries appearing in the Toolbox.
+- **Image drawing follow-ups**: flood fill (Pillow's `ImageDraw.floodfill`); mouse coordinates in the picture's pixels when it's scaled (stretch, zoom) or centered; anti-aliased shapes (Pillow draws them jagged; drawing larger and shrinking is the usual trick); undo for paint programs (keep copies of the picture).
+- **Canvas follow-ups**: keyboard events (a Tk canvas takes no focus by default); scrolling and zooming a canvas bigger than the control; saving a canvas as a picture (Tk can only write PostScript, so this needs drawing through Pillow too); dragging shapes with less code (perhaps `shape.draggable = True`).
+- **Appearance follow-ups**: a form `font` that new controls start with (as VB's form Font was); colors for disabled controls (Tk grays them its own way); `selectcolor` for check box and option button indicators. Known limits: macOS buttons keep the system's colors, and Windows' native theme may ignore a ComboBox's field color (both are Tk's).
+- **More properties**: TextBox `readonly`, `password` and `maxlength`; `tooltip`; `tag`.
+- **Keyboard follow-ups**: `tabstop` (leave a control out of the Tab order without disabling it); arrow keys moving between the OptionButtons of a group, with only the chosen one a Tab stop (as in Windows); access keys (Alt+letter from an `&` in a caption); a `keydown`/`keyup` pair for games (keypress repeats while a key is held).
+- **Image follow-ups**: show an Image's outline in the designer when its picture is smaller than the control (sizing normal, center or zoom); offer to delete a copied picture from images/ when nothing uses it any more; animated GIFs; pictures on Buttons and Labels (Tk supports both).
+
+## Biggest features
+- **Form Packing**: Tkinter supports more than just absolute positioning and sizing for widgets.  Supporting grid or packing schemes would really elevate this above what VB could ever do.
+  - The Format menu (align, same size, spacing, center, order) is for absolutely placed controls only; its pure geometry lives in `readymade/ide/arrange.py`. Grid/pack containers would disable it for their controls or offer their own equivalents (sticky, anchor, padx/pady, weights). Selections already stay within one container, so the container can decide which tools apply.
+- **Backend Swappable**:  Being able to design for a PyQt6 or some other GUI backend instead of Tkinter for a project.  There are two optional paths to this: One is keeping Tkinter for the IDE and designing a project with a different GUI backend, or having the IDE match the target project GUI.  Is a GUI target potentially a plugin?  Either way, this looks like a separation of concerns type of refactor.
+  - Keep readymade's own API free of Tk: shapes are readymade objects, colors `#rrggbb`, angles in degrees, fonts `(family, size, style)`. Still Tk-specific: color names Canvas shapes accept beyond `#rrggbb`, and `.widget` / `form.root` (fine as documented escape hatches). If Qt: PySide6 (LGPL) rather than PyQt6 (GPL), for programs made with Make EXE.
+- **Plugins**: A plugin architecture to extend features.  Allow other people to create plugins like VB or VS Code allows.

readymade-0.0.1/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "readymade"
+version = "0.0.1"
+description = "Visual Basic-style forms for Python: draw a form, double-click to write its code, press F5"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Joseph E. Coleman" }]
+requires-python = ">=3.11"
+dependencies = []
+keywords = ["gui", "rad", "form designer", "ide", "tkinter", "python", "visual basic"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Environment :: Win32 (MS Windows)",
+    "Environment :: X11 Applications",
+    "Environment :: MacOS X",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: User Interfaces",
+    "Topic :: Software Development :: Code Generators",
+]
+
+[project.optional-dependencies]
+ide = ["pygments>=2.15", "jedi>=0.19", "pillow>=10.1"]  # coloring, completion and Go to Definition, pictures in the designer; the IDE works without them
+
+[project.scripts]
+readymade = "readymade.ide.app:main"
+
+[dependency-groups]
+dev = ["pytest"]
+
+[build-system]
+requires = ["hatchling>=1.27"]  # for the license fields above
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.sdist]
+exclude = ["examples"]  # they hold pictures that aren't for publishing, and each machine's interpreter choice

readymade-0.0.1/readymade/__init__.py

@@ -0,0 +1,11 @@
+"""readymade: Visual Basic style forms for Python and Tkinter."""
+
+from readymade.events import doevents, in_thread, pause, while_running
+from readymade.dialogs import (color_dialog, folder_dialog, font_dialog, inputbox, msgbox, open_file_dialog,
+                             save_file_dialog)
+from readymade.form import Form, app_path
+
+__all__ = [
+    "Form", "app_path", "color_dialog", "doevents", "folder_dialog", "font_dialog", "in_thread", "inputbox", "msgbox",
+    "open_file_dialog", "pause", "save_file_dialog", "while_running",
+]

readymade-0.0.1/readymade/appearance.py

@@ -0,0 +1,96 @@
+"""How controls look, in readymade's own terms: colors, fonts, alignment and mouse
+cursors, and what they become in Tk.
+
+Colors are "#rrggbb" strings, with "" for the usual color. A font is a string like
+"Arial, 12, bold" (family, size in points, then any of bold, italic and underline),
+or the same as a tuple, ("Arial", 12, "bold"); empty parts mean the usual font's.
+"""
+
+from __future__ import annotations
+
+import re
+
+ALIGNMENTS = ("left", "center", "right")
+VALIGNMENTS = ("top", "middle", "bottom")
+FONT_STYLES = ("bold", "italic", "underline")
+# Mouse cursors by readymade name, and Tk's names for them (which Tk maps to each system's own).
+CURSORS = {
+    "default": "",  # the control's usual cursor (a text box's is "text")
+    "arrow": "arrow",
+    "hand": "hand2",
+    "text": "xterm",
+    "cross": "crosshair",
+    "wait": "watch",
+    "move": "fleur",
+    "help": "question_arrow",
+    "resize_ew": "sb_h_double_arrow",
+    "resize_ns": "sb_v_double_arrow",
+}
+
+_HEX = re.compile(r"#[0-9a-fA-F]{6}")
+
+
+def check_color(value):
+    """value as a "#rrggbb" color (or "" for the usual); ValueError if it isn't one."""
+    value = "" if value is None else str(value).strip()
+    if value and not _HEX.fullmatch(value):
+        raise ValueError(f"{value!r} isn't a color; use \"#rrggbb\", like \"#ff0000\" for red (or \"\" for the usual color)")
+    return value.lower()
+
+
+def lighter(color, amount=0.2):
+    """A "#rrggbb" color mixed with some white (for a hovered button)."""
+    channels = [int(color[i:i + 2], 16) for i in (1, 3, 5)]
+    return "#" + "".join(f"{round(c + (255 - c) * amount):02x}" for c in channels)
+
+
+def parse_font(value):
+    """(family, size, styles) from a font string or tuple; "" and 0 mean the usual."""
+    if value is None or value == "":
+        return "", 0, ()
+    parts = [p.strip() for p in value.split(",")] if isinstance(value, str) else [str(p).strip() for p in value]
+    family = parts[0] if parts else ""
+    size = 0
+    if len(parts) > 1 and parts[1]:
+        try:
+            size = int(float(parts[1]))
+        except ValueError:
+            raise ValueError(f"{value!r}: the font's size, after the first comma, must be a number") from None
+        if size < 0:
+            raise ValueError(f"{value!r}: the font's size can't be negative")
+    styles = []
+    for word in " ".join(parts[2:]).lower().split():
+        if word not in FONT_STYLES:
+            raise ValueError(f"{value!r}: {word!r} isn't a font style; use bold, italic or underline")
+        if word not in styles:
+            styles.append(word)
+    return family, size, tuple(s for s in FONT_STYLES if s in styles)
+
+
+def format_font(value):
+    """The tidy string form of a font: "Arial, 12, bold"; "" for the usual font."""
+    family, size, styles = parse_font(value)
+    parts = [family, str(size) if size else "", " ".join(styles)]
+    while parts and not parts[-1]:
+        parts.pop()
+    return ", ".join(parts)
+
+
+def tk_font(value, usual):
+    """A Tk font description for a font, filling empty parts from usual (a dict like
+    tkinter.font.Font.actual() gives)."""
+    family, size, styles = parse_font(value)
+    return (family or usual["family"], size or usual["size"], *styles)
+
+
+def anchor(alignment, valignment="middle"):
+    """Tk's compass-point anchor for an alignment pair: ("left", "top") is "nw"."""
+    across = {"left": "w", "center": "", "right": "e"}[alignment]
+    down = {"top": "n", "middle": "", "bottom": "s"}[valignment]
+    return (down + across) or "center"
+
+
+def check_choice(name, value, choices):
+    if value not in choices:
+        raise ValueError(f"{name} must be one of: {', '.join(choices)}")
+    return value

readymade-0.0.1/readymade/codegen.py

@@ -0,0 +1,104 @@
+"""Small source edits on a form's .py module: adding, finding and renaming handlers.
+
+These work on lines and regular expressions rather than the ast, so they keep
+working while the code has a syntax error in it, which is most of the time
+during editing.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+INDENT = "    "
+
+
+class CodeGenError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class Edit:
+    """Replace lines [start, end) (0-based) with text."""
+
+    start: int
+    end: int
+    text: str
+    method_line: int  # 1-based line of the new def once the edit is applied
+
+    def apply(self, source):
+        lines = source.splitlines(keepends=True)
+        return "".join(lines[: self.start]) + self.text + "".join(lines[self.end :])
+
+
+def new_module(class_name):
+    return (
+        "from readymade import Form\n"
+        "\n"
+        "\n"
+        f"class {class_name}(Form):\n"
+        f"{INDENT}pass\n"
+        "\n"
+        "\n"
+        'if __name__ == "__main__":\n'
+        f"{INDENT}{class_name}.run()\n"
+    )
+
+
+def defined_methods(source):
+    return set(re.findall(r"^[ \t]+(?:async[ \t]+)?def[ \t]+(\w+)[ \t]*\(", source, re.M))
+
+
+def find_method(source, name):
+    """The 1-based line of `def name(`, or None."""
+    m = re.search(rf"^[ \t]+(?:async[ \t]+)?def[ \t]+{re.escape(name)}[ \t]*\(", source, re.M)
+    return source.count("\n", 0, m.start()) + 1 if m else None
+
+
+def add_method(source, class_name, name, params=()):
+    """An Edit that adds an empty method at the end of the class."""
+    lines = source.splitlines(keepends=True)
+    class_re = re.compile(rf"class[ \t]+{re.escape(class_name)}\b")
+    start = next((i for i, line in enumerate(lines) if class_re.match(line)), None)
+    if start is None:
+        raise CodeGenError(f"Couldn't find 'class {class_name}' in the code.")
+
+    # The class body runs until the first non-blank, non-comment line at column 0.
+    last = start
+    for i in range(start + 1, len(lines)):
+        line = lines[i]
+        if not line.strip() or line.lstrip().startswith("#"):
+            continue
+        if line[0] not in " \t":
+            break
+        last = i
+
+    body = [i for i in range(start + 1, last + 1) if lines[i].strip() and not lines[i].lstrip().startswith("#")]
+    indent = INDENT
+    if body:
+        first = lines[body[0]]
+        indent = first[: len(first) - len(first.lstrip())]
+    signature = ", ".join(("self", *params))
+    method = f"{indent}def {name}({signature}):\n{indent}{indent}pass\n"
+
+    # A new class holds only a placeholder `pass`; replace it.
+    if len(body) == 1 and lines[body[0]].strip() == "pass":
+        return Edit(body[0], body[0] + 1, method, method_line=body[0] + 1)
+
+    insert_at = last + 1
+    prefix = "" if lines[last].endswith("\n") else "\n"
+    return Edit(insert_at, insert_at, prefix + "\n" + method, method_line=insert_at + 2)
+
+
+def rename_control(source, old, new, events):
+    """Rename a control's handlers and its `self.old` references."""
+    if events:
+        names = "|".join(re.escape(e) for e in events)
+        pattern = rf"^([ \t]+(?:async[ \t]+)?def[ \t]+){re.escape(old)}_({names})(?=[ \t]*\()"
+        source = re.sub(pattern, rf"\g<1>{new}_\g<2>", source, flags=re.M)
+    return re.sub(rf"\bself\.{re.escape(old)}\b", f"self.{new}", source)
+
+
+def rename_class(source, old, new):
+    """Rename the form class everywhere it appears as a whole word."""
+    return re.sub(rf"\b{re.escape(old)}\b", new, source)