cmdgui 0.1.0__py3-none-any.whl

cmdgui/__init__.py

@@ -0,0 +1,14 @@
+from .view import View, Popup
+from .widgets import (
+    Widget, Text, Label, Button, TextInput, ProgressBar, Checkbox, Toggle,
+    Menu, Table, Stdout, DrawMouse, DEFAULT_THEME, field,
+)
+from .inputs import Input, mouse
+from .layout import LayoutError
+from .shorts import Canvas, style
+
+__all__ = [
+    "View", "Popup", "Widget", "Text", "Label", "Button", "TextInput", "ProgressBar",
+    "Checkbox", "Toggle", "Menu", "Table", "Stdout", "DrawMouse", "DEFAULT_THEME", "field",
+    "Input", "mouse", "LayoutError", "Canvas", "style",
+]

cmdgui/_platform.py

@@ -0,0 +1,126 @@
+"""The OS-specific bits: raw keyboard mode, reading input with a timeout, and
+waking a blocked read from another thread. Everything else is shared."""
+import codecs
+import os
+import sys
+
+WINDOWS = os.name == "nt"
+
+
+if not WINDOWS:
+    import select
+    import termios
+
+    class Terminal:
+        def __init__(self):
+            self._saved = None
+            self._decoder = codecs.getincrementaldecoder("utf-8")(errors="replace")
+            self._wake_r, self._wake_w = os.pipe()
+            os.set_blocking(self._wake_w, False)
+
+        def enable(self):
+            fd = sys.stdin.fileno()
+            self._saved = termios.tcgetattr(fd)
+            attrs = termios.tcgetattr(fd)
+            # No line buffering, no echo. ISIG stays on so Ctrl+C still raises KeyboardInterrupt.
+            attrs[3] &= ~(termios.ICANON | termios.ECHO)
+            termios.tcsetattr(fd, termios.TCSANOW, attrs)
+
+        def disable(self):
+            if self._saved is not None:
+                termios.tcsetattr(sys.stdin.fileno(), termios.TCSANOW, self._saved)
+                self._saved = None
+
+        def read(self, timeout):
+            """Wait up to timeout seconds, return whatever was typed ("" if nothing)."""
+            fd = sys.stdin.fileno()
+            ready, _, _ = select.select([fd, self._wake_r], [], [], timeout)
+            text = ""
+            if fd in ready:
+                text = self._decoder.decode(os.read(fd, 1024))  # handles characters split across reads
+            if self._wake_r in ready:
+                os.read(self._wake_r, 4096)
+            return text
+
+        def wake(self):
+            """Make a read() that's waiting return straight away. Safe from any thread."""
+            try:
+                os.write(self._wake_w, b"x")
+            except BlockingIOError:
+                pass  # pipe full, it's already going to wake up
+
+
+else:
+    import ctypes
+    from ctypes import wintypes
+
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+
+    STD_INPUT_HANDLE, STD_OUTPUT_HANDLE = -10, -11
+    ENABLE_PROCESSED_INPUT = 0x0001
+    ENABLE_LINE_INPUT = 0x0002
+    ENABLE_ECHO_INPUT = 0x0004
+    ENABLE_QUICK_EDIT_MODE = 0x0040
+    ENABLE_EXTENDED_FLAGS = 0x0080
+    ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+    ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+    KEY_EVENT = 0x0001
+    WAIT_TIMEOUT = 0x102
+
+    class KEY_EVENT_RECORD(ctypes.Structure):
+        _fields_ = [("bKeyDown", wintypes.BOOL), ("wRepeatCount", wintypes.WORD),
+                    ("wVirtualKeyCode", wintypes.WORD), ("wVirtualScanCode", wintypes.WORD),
+                    ("UnicodeChar", wintypes.WCHAR), ("dwControlKeyState", wintypes.DWORD)]
+
+    class _EVENT(ctypes.Union):
+        # KEY_EVENT_RECORD is the largest member we read; pad to the real union size (16 bytes)
+        _fields_ = [("KeyEvent", KEY_EVENT_RECORD), ("_pad", ctypes.c_byte * 16)]
+
+    class INPUT_RECORD(ctypes.Structure):
+        _fields_ = [("EventType", wintypes.WORD), ("Event", _EVENT)]
+
+    class Terminal:
+        """Windows console. With virtual terminal input on, keys and the mouse
+        arrive as the same escape sequences Unix terminals send."""
+        def __init__(self):
+            self._in = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+            self._out = kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+            self._saved = None
+            self._wake_event = kernel32.CreateEventW(None, False, False, None)
+
+        def enable(self):
+            in_mode, out_mode = wintypes.DWORD(), wintypes.DWORD()
+            kernel32.GetConsoleMode(self._in, ctypes.byref(in_mode))
+            kernel32.GetConsoleMode(self._out, ctypes.byref(out_mode))
+            self._saved = (in_mode.value, out_mode.value)
+            new_in = (in_mode.value | ENABLE_VIRTUAL_TERMINAL_INPUT | ENABLE_EXTENDED_FLAGS | ENABLE_PROCESSED_INPUT) \
+                & ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_QUICK_EDIT_MODE)
+            kernel32.SetConsoleMode(self._in, new_in)
+            kernel32.SetConsoleMode(self._out, out_mode.value | ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+
+        def disable(self):
+            if self._saved is not None:
+                kernel32.SetConsoleMode(self._in, self._saved[0])
+                kernel32.SetConsoleMode(self._out, self._saved[1])
+                self._saved = None
+
+        def read(self, timeout):
+            handles = (wintypes.HANDLE * 2)(self._in, self._wake_event)
+            result = kernel32.WaitForMultipleObjects(2, handles, False, int(timeout * 1000))
+            if result != 0:  # timed out, or woken
+                return ""
+            text = []
+            count = wintypes.DWORD()
+            kernel32.GetNumberOfConsoleInputEvents(self._in, ctypes.byref(count))
+            if count.value:
+                records = (INPUT_RECORD * count.value)()
+                read = wintypes.DWORD()
+                kernel32.ReadConsoleInputW(self._in, records, count.value, ctypes.byref(read))
+                for record in records[:read.value]:
+                    key = record.Event.KeyEvent
+                    if record.EventType == KEY_EVENT and key.bKeyDown and key.UnicodeChar != "\0":
+                        text.append(key.UnicodeChar * max(1, key.wRepeatCount))
+            return "".join(text)
+
+        def wake(self):
+            kernel32.SetEvent(self._wake_event)

cmdgui/inputs.py

@@ -0,0 +1,214 @@
+import queue
+import re
+import sys
+
+from .shorts import ESC, write
+from ._platform import Terminal
+
+
+class Input():
+    def __init__(self, type, details):
+        self.type:str = type
+        self.details:dict = details
+
+    def __repr__(self):
+        return f"Input({self.type!r}, {self.details!r})"
+
+
+class Mouse():
+    """Current mouse state, kept up to date by the view before each input is
+    handed to widgets. Coordinates are 0-based screen positions."""
+    def __init__(self):
+        self.x = 0
+        self.y = 0
+        self.prev_x = 0 # position before the current input
+        self.prev_y = 0
+        self.buttons = set() # held buttons: 0 left, 1 middle, 2 right
+
+    def pos(self):
+        return self.x, self.y
+
+    def is_down(self, button=0):
+        return button in self.buttons
+
+    @property
+    def moved(self):
+        """True if the current input moved the mouse to a different cell."""
+        return (self.x, self.y) != (self.prev_x, self.prev_y)
+
+mouse = Mouse()
+
+
+def update_state(input):
+    """Apply an input to the shared state (mouse position and buttons)."""
+    if not input.type.startswith("mouse"):
+        return
+    mouse.prev_x, mouse.prev_y = mouse.x, mouse.y
+    mouse.x, mouse.y = input.details["x"], input.details["y"]
+    if input.type == "mouse_down":
+        mouse.buttons.add(input.details["button"])
+    elif input.type == "mouse_up":
+        mouse.buttons.discard(input.details["button"])
+    elif input.type == "mouse_move" and "button" not in input.details:
+        mouse.buttons.clear() # no button held; fixes a release we missed (e.g. outside the window)
+
+
+# Mouse tracking: 1003 = report all motion (not just while a button is held),
+# 1006 = SGR encoding, which gives readable decimal coordinates with no size limit
+MOUSE_ON = ESC + "?1003h" + ESC + "?1006h"
+MOUSE_OFF = ESC + "?1003l" + ESC + "?1006l"
+
+# SGR mouse report: ESC [ < button ; x ; y  then M (press/move) or m (release)
+SGR_MOUSE = re.compile(r"\x1b\[<(\d+);(\d+);(\d+)([Mm])")
+# Other escape sequences: ESC [ params final, or ESC O final (some terminals' arrow keys)
+CSI = re.compile(r"\x1b\[([0-9;]*)([A-Za-z~])")
+SS3 = re.compile(r"\x1bO([A-Za-z])")
+
+KEY_NAMES = {
+    "A": "up", "B": "down", "C": "right", "D": "left", "H": "home", "F": "end", "Z": "shift_tab",
+    "1~": "home", "2~": "insert", "3~": "delete", "4~": "end", "5~": "page_up", "6~": "page_down",
+    "7~": "home", "8~": "end",
+}
+CHAR_NAMES = {"\r": "enter", "\n": "enter", "\t": "tab", "\x7f": "backspace", "\x08": "backspace",
+              "\x1b": "escape", " ": "space"}
+MODIFIERS = {"2": "shift", "3": "alt", "4": "alt+shift", "5": "ctrl", "6": "ctrl+shift", "7": "ctrl+alt"}
+
+_terminal = Terminal()
+_buffer = ""
+
+# Text written to sys.stdout / sys.stderr while intercepted
+_text_queue = queue.SimpleQueue()
+_stderr_log = [] # everything written to stderr, shown again after the view closes
+
+
+class StreamInterceptor:
+    """Stands in for sys.stdout or sys.stderr and turns everything written
+    into "stdout" / "stderr" inputs."""
+    def __init__(self, real, kind):
+        self.real = real
+        self.kind = kind
+    def write(self, s):
+        if s:
+            _text_queue.put((self.kind, s))
+            if self.kind == "stderr":
+                _stderr_log.append(s)
+            _terminal.wake()
+        return len(s)
+    def flush(self):
+        pass
+    def __getattr__(self, name):
+        # Anything else (encoding, fileno, isatty...) comes from the real stream
+        return getattr(self.real, name)
+
+
+def enable():
+    """Raw keyboard mode, mouse reporting, and capture print output."""
+    _stderr_log.clear()
+    _terminal.enable()
+    write(MOUSE_ON)
+    sys.stdout = StreamInterceptor(sys.stdout, "stdout")
+    sys.stderr = StreamInterceptor(sys.stderr, "stderr")
+
+
+def disable():
+    """Undo enable(). Safe to call more than once."""
+    if isinstance(sys.stdout, StreamInterceptor):
+        sys.stdout = sys.stdout.real
+    if isinstance(sys.stderr, StreamInterceptor):
+        sys.stderr = sys.stderr.real
+    write(MOUSE_OFF)
+    _terminal.disable()
+
+
+def captured_stderr():
+    """Everything written to stderr since enable(), e.g. tracebacks."""
+    return "".join(_stderr_log)
+
+
+def wake():
+    """Make read_inputs() return straight away. Safe from any thread."""
+    _terminal.wake()
+
+
+def read_inputs(timeout=0.1):
+    """Wait up to timeout seconds for input, and return it as a list of Inputs."""
+    global _buffer
+    _buffer += _terminal.read(timeout)
+
+    inputs = []
+
+    # print() does several writes per call, so merge queued text into one input per stream
+    while not _text_queue.empty():
+        kind, text = _text_queue.get()
+        if inputs and inputs[-1].type == kind:
+            inputs[-1].details["text"] += text
+        else:
+            inputs.append(Input(kind, {"text": text}))
+
+    while _buffer:
+        if _buffer.startswith("\x1b[<"):
+            match = SGR_MOUSE.match(_buffer)
+            if not match:
+                break  # incomplete mouse report, wait for the rest
+            inputs.append(_mouse_input(*match.groups()))
+            _buffer = _buffer[match.end():]
+        elif _buffer.startswith("\x1b[") or _buffer.startswith("\x1bO"):
+            match = CSI.match(_buffer) or SS3.match(_buffer)
+            if not match:
+                if len(_buffer) < 8:
+                    break  # incomplete, wait for the rest
+                match = re.match(r"\x1b.", _buffer) # garbage, skip it
+            inputs.append(_sequence_key(match))
+            _buffer = _buffer[match.end():]
+        elif _buffer.startswith("\x1b") and len(_buffer) > 1:
+            inputs.append(_key("alt+" + _char_name(_buffer[1])))
+            _buffer = _buffer[2:]
+        else:
+            inputs.append(_key(_char_name(_buffer[0]), _buffer[0]))
+            _buffer = _buffer[1:]
+    return inputs
+
+
+def _key(name, char=None):
+    """A key input. char is the printable character typed, if any."""
+    printable = char is not None and (char == " " or char.isprintable())
+    return Input("key", {"key": name, "char": char if printable else None})
+
+
+def _char_name(char):
+    if char in CHAR_NAMES:
+        return CHAR_NAMES[char]
+    if "\x01" <= char <= "\x1a":
+        return "ctrl+" + chr(ord(char) + 96)
+    return char
+
+
+def _sequence_key(match):
+    groups = match.groups()
+    if len(groups) == 1:  # ESC O x
+        return _key(KEY_NAMES.get(groups[0], match.group()))
+    if len(groups) == 0:  # skipped garbage
+        return _key(match.group())
+    params, final = groups
+    parts = params.split(";") if params else []
+    if final == "~":
+        name = KEY_NAMES.get((parts[0] if parts else "") + "~", match.group())
+    else:
+        name = KEY_NAMES.get(final, match.group())
+    if len(parts) == 2 and parts[1] in MODIFIERS:  # e.g. ESC [1;5A is ctrl+up
+        name = MODIFIERS[parts[1]] + "+" + name
+    return _key(name)
+
+
+def _mouse_input(button, x, y, final):
+    button, x, y = int(button), int(x) - 1, int(y) - 1  # to 0-based screen coords
+    details = {"x": x, "y": y}
+    if button & 64:
+        details["direction"] = "up" if button & 1 == 0 else "down"
+        return Input("mouse_scroll", details)
+    if button & 32:
+        if button & 3 != 3:
+            details["button"] = button & 3
+        return Input("mouse_move", details)
+    details["button"] = button & 3  # 0 left, 1 middle, 2 right
+    return Input("mouse_down" if final == "M" else "mouse_up", details)

cmdgui/layout.py

@@ -0,0 +1,249 @@
+import re
+from dataclasses import dataclass
+
+# type, type[name], with an optional {b} (border) or {nb} (no border) on the end
+TOKEN = re.compile(r"^([A-Za-z_]\w*)(?:\[([A-Za-z_]\w*)\])?(?:\{(b|nb)\})?$")
+# a size: "5" exactly, "5+" at least, "5-10" between
+SIZE = re.compile(r"^(\d+)(?:(\+)|-(\d+))?$")
+
+EMPTY = "."
+SPAN_LEFT = "-"
+SPAN_UP = "|"
+
+
+class LayoutError(ValueError):
+    pass
+
+
+@dataclass
+class Slot:
+    name: str
+    type: str  # None when the layout just names a widget that was passed in
+    row: int
+    col: int
+    rowspan: int = 1
+    colspan: int = 1
+    border: bool = None  # True/False from {b}/{nb}, None to use the widget's default
+
+
+@dataclass
+class Layout:
+    rows: int
+    cols: int
+    slots: dict  # name -> Slot, in the order they were declared
+
+
+def parse_layout(text, types=None, names=()):
+    """Parse a layout string into a Layout.
+
+    types is an optional collection of known type names; if given, unknown
+    types are an error. names are widgets provided by the caller: a bare word
+    matching one of them refers to that widget instead of a type."""
+    lines = [line.split() for line in text.splitlines() if line.strip()]
+    if not lines: raise LayoutError("layout is empty")
+
+    cols = len(lines[0])
+    for r, cells in enumerate(lines):
+        if len(cells) != cols:
+            raise LayoutError(f"row {r + 1} has {len(cells)} cells, but row 1 has {cols}")
+
+    slot_types = {}  # name -> type, in declaration order
+    slot_borders = {}  # name -> True/False/None
+    grid = [[None] * cols for _ in lines]  # name in each cell, None for empty
+
+    for r, cells in enumerate(lines):
+        for c, token in enumerate(cells):
+            where = f"row {r + 1}, column {c + 1}"
+
+            if token == EMPTY: continue
+
+            if token == SPAN_LEFT:
+                if c == 0: raise LayoutError(f"{where}: '-' has nothing to its left")
+                if grid[r][c - 1] is None: raise LayoutError(f"{where}: '-' can't extend an empty cell")
+                grid[r][c] = grid[r][c - 1]
+                continue
+
+            if token == SPAN_UP:
+                if r == 0: raise LayoutError(f"{where}: '|' has nothing above it")
+                if grid[r - 1][c] is None: raise LayoutError(f"{where}: '|' can't extend an empty cell")
+                grid[r][c] = grid[r - 1][c]
+                continue
+
+            match = TOKEN.match(token)
+            if not match:
+                raise LayoutError(f"{where}: can't understand '{token}'")
+            type_, name, flag = match.groups()
+            if name is None and type_ in slot_types:  # repeat of an existing name: span
+                if flag:
+                    raise LayoutError(f"{where}: put {{{flag}}} on the first '{type_}' cell, not a repeat")
+                grid[r][c] = type_
+                continue
+            if name is None:
+                name = type_
+                if name in names:
+                    type_ = None # a provided widget, no type needed
+            elif name in slot_types:
+                raise LayoutError(f"{where}: '{name}' is already declared; repeat it as just '{name}' to span")
+
+            if types is not None and type_ is not None and type_ not in types:
+                known = ", ".join(sorted(types))
+                raise LayoutError(f"{where}: unknown widget type '{type_}' (known: {known})")
+            slot_types[name] = type_
+            slot_borders[name] = {"b": True, "nb": False, None: None}[flag]
+            grid[r][c] = name
+
+    return Layout(len(lines), cols, _build_slots(grid, slot_types, slot_borders))
+
+
+def _build_slots(grid, slot_types, slot_borders):
+    """Turn the grid of names into Slots, checking each name covers a rectangle."""
+    cells = {}  # name -> list of (row, col)
+    for r, row in enumerate(grid):
+        for c, name in enumerate(row):
+            if name is not None:
+                cells.setdefault(name, []).append((r, c))
+
+    slots = {}
+    for name, type_ in slot_types.items():
+        rows = [r for r, _ in cells[name]]
+        cols = [c for _, c in cells[name]]
+        top, left = min(rows), min(cols)
+        rowspan, colspan = max(rows) - top + 1, max(cols) - left + 1
+        if len(cells[name]) != rowspan * colspan:
+            hint = f"; to add a second {type_}, give it its own name: {type_}[other_name]" if type_ else ""
+            raise LayoutError(f"'{name}' doesn't form a rectangle{hint}")
+        slots[name] = Slot(name, type_, top, left, rowspan, colspan, slot_borders[name])
+    return slots
+
+
+def parse_size(spec):
+    """Turn a size into (min, max), max None for no limit.
+    5 or "5" exactly, "5+" at least 5, "5-10" between, None flexible (at least 1)."""
+    if spec is None:
+        return 1, None
+    if isinstance(spec, int):
+        return spec, spec
+    match = SIZE.match(str(spec).strip())
+    if not match:
+        raise LayoutError(f"bad size '{spec}' (use e.g. 5, '5+' or '5-10')")
+    low, plus, high = match.groups()
+    low = int(low)
+    if plus:
+        return low, None
+    if high is not None:
+        if int(high) < low:
+            raise LayoutError(f"bad size '{spec}': max is smaller than min")
+        return low, int(high)
+    return low, low
+
+
+@dataclass
+class Placement:
+    rects: dict    # name -> (x, y, width, height) of the widget's content
+    frames: dict   # name -> (x, y, width, height) of the border, for bordered widgets
+    min_width: int # smallest screen the layout fits on
+    min_height: int
+    fits: bool     # False if the screen is smaller than that
+
+
+def place(layout, width, height, sizes=None, borders=None, outer=False):
+    """Work out where every widget goes on a width x height screen.
+
+    sizes:   name -> (width spec, height spec), see parse_size
+    borders: name -> True if the widget has a border
+    outer:   always leave room for a border around the whole layout (popups)
+
+    Border lines sit between grid rows/columns and are shared by neighbours,
+    so two bordered widgets next to each other have one line between them."""
+    sizes = sizes or {}
+    borders = borders or {}
+    slots = list(layout.slots.values())
+    specs = {s.name: [parse_size(spec) for spec in sizes.get(s.name, (None, None))] for s in slots}
+
+    col_lines = _lines(layout.cols, [(s.col, s.colspan) for s in slots if borders.get(s.name)])
+    row_lines = _lines(layout.rows, [(s.row, s.rowspan) for s in slots if borders.get(s.name)])
+    if outer:
+        col_lines[0] = col_lines[-1] = row_lines[0] = row_lines[-1] = 1
+    col_widths, min_width = _size_tracks(width, layout.cols, col_lines,
+                                         [(s.col, s.colspan, *specs[s.name][0]) for s in slots])
+    row_heights, min_height = _size_tracks(height, layout.rows, row_lines,
+                                           [(s.row, s.rowspan, *specs[s.name][1]) for s in slots])
+    col_x = _starts(col_widths, col_lines)
+    row_y = _starts(row_heights, row_lines)
+
+    rects, frames = {}, {}
+    for s in slots:
+        x, y = col_x[s.col], row_y[s.row]
+        last_col, last_row = s.col + s.colspan - 1, s.row + s.rowspan - 1
+        w = col_x[last_col] + col_widths[last_col] - x
+        h = row_y[last_row] + row_heights[last_row] - y
+        rects[s.name] = (x, y, w, h)
+        if borders.get(s.name):
+            frames[s.name] = (x - 1, y - 1, w + 2, h + 2)
+    return Placement(rects, frames, min_width, min_height, width >= min_width and height >= min_height)
+
+
+def _lines(count, spans):
+    """Thickness (0 or 1) of the border line before each track, plus one after the last."""
+    lines = [0] * (count + 1)
+    for start, span in spans:
+        lines[start] = lines[start + span] = 1
+    return lines
+
+
+def _size_tracks(total, count, lines, items):
+    """Size the rows (or columns). items are (start, span, min, max) per widget.
+    Returns the sizes and the minimum total needed."""
+    # Each track's range comes from the widgets that sit only in that track
+    mins = [0] * count
+    maxs = [None] * count
+    single = [[] for _ in range(count)]
+    for start, span, low, high in items:
+        if span == 1:
+            single[start].append((low, high))
+    for i, ranges in enumerate(single):
+        if ranges:
+            mins[i] = max(low for low, _ in ranges)
+            # A widget with a size limit limits its track; flexible neighbours adapt
+            highs = [high for _, high in ranges if high is not None]
+            maxs[i] = max(min(highs), mins[i]) if highs else None
+
+    # Spanning widgets: if their tracks are too small together, grow one of them
+    for start, span, low, high in items:
+        if span > 1:
+            covered = sum(mins[start:start + span]) + sum(lines[start + 1:start + span])
+            if covered < low:
+                tracks = range(start, start + span)
+                grow = next((i for i in reversed(tracks) if maxs[i] is None), tracks[-1])
+                mins[grow] += low - covered
+                if maxs[grow] is not None:
+                    maxs[grow] = max(maxs[grow], mins[grow])
+
+    # Everyone starts at their min, then the rest is shared equally between
+    # tracks that can still grow, in rounds, until it runs out or all are full
+    sizes = mins[:]
+    remaining = total - sum(lines) - sum(sizes)
+    while remaining > 0:
+        growable = [i for i in range(count) if maxs[i] is None or sizes[i] < maxs[i]]
+        if not growable:
+            break
+        share = remaining // len(growable)
+        if share == 0:
+            for i in growable[:remaining]:
+                sizes[i] += 1
+            break
+        for i in growable:
+            add = share if maxs[i] is None else min(share, maxs[i] - sizes[i])
+            sizes[i] += add
+            remaining -= add
+    return sizes, sum(mins) + sum(lines)
+
+
+def _starts(sizes, lines):
+    """Start position of each track, leaving room for the border lines."""
+    starts, pos = [], 0
+    for i, size in enumerate(sizes):
+        pos += lines[i]
+        starts.append(pos)
+        pos += size
+    return starts