tkinter-web-backend 0.1.0__py3-none-any.whl

tkinter_web/tk/widgets/frame.py

@@ -0,0 +1,189 @@
+"""
+Frames: frame, toplevel (and the root window) and labelframe.
+"""
+
+from ..tcl import to_str
+from .base import Widget
+
+LABELSPACING = 1
+LABELMARGIN = 4
+
+
+class Frame(Widget):
+    kind = "frame"
+    default_class = "Frame"
+
+    def internal_border(self):
+        o = self.options
+        b = o.pixels("-borderwidth") + o.pixels("-highlightthickness")
+        px, py = o.pixels("-padx"), o.pixels("-pady")
+        return (b + px, b + py, b + px, b + py)
+
+    def natural_size(self):
+        w, h = self.options.pixels("-width"), self.options.pixels("-height")
+        if w > 0 or h > 0:
+            return max(w, 0), max(h, 0)
+        return None  # no request of its own
+
+    def display(self):
+        return self.common_display()
+
+
+class Toplevel(Frame):
+    kind = "toplevel"
+    default_class = "Toplevel"
+
+    def __init__(self, interp, path, parent, args):
+        self.wm = {
+            "title": None, "geometry": None, "position": None, "state": "normal",
+            "resizable": (True, True), "minsize": (1, 1), "maxsize": None,
+            "protocols": {}, "attributes": {"-alpha": 1.0, "-topmost": 0,
+                                            "-fullscreen": 0, "-type": "",
+                                            "-zoomed": 0},
+            "overrideredirect": False, "transient": "", "iconphoto": None,
+            "group": "", "user_size": None, "grid": None, "aspect": None,
+            "iconname": "",
+        }
+        super().__init__(interp, path, parent, args)
+        if path == ".":
+            self.tk_class = interp.class_name
+        self.wm["title"] = None
+
+    def is_toplevel_like(self):
+        return True
+
+    def natural_size(self):
+        w, h = self.options.pixels("-width"), self.options.pixels("-height")
+        if w > 0 or h > 0:
+            return max(w, 0), max(h, 0)
+        return 200, 200
+
+    def title(self):
+        t = self.wm["title"]
+        if t is None:
+            return self.interp.app_name if self.path == "." else self.name
+        return t
+
+    def viewable(self):
+        return self.wm["state"] == "normal"
+
+
+class Labelframe(Frame):
+    kind = "labelframe"
+    default_class = "Labelframe"
+
+    def _label_size(self):
+        o = self.options
+        text = o.str("-text")
+        lw = o.str("-labelwidget")
+        if lw:
+            try:
+                w = self.interp.widget(lw)
+                return w.req_w, w.req_h, True
+            except Exception:
+                return 0, 0, False
+        if text:
+            font = self.interp.font(o["-font"])
+            layout = font.layout(text, 0, "center")
+            return layout.width + 2 * LABELSPACING, layout.height + 2 * LABELSPACING, True
+        return 0, 0, False
+
+    def _anchor(self):
+        return self.options.str("-labelanchor") or "nw"
+
+    def internal_border(self):
+        o = self.options
+        bw = o.pixels("-borderwidth")
+        b = bw + o.pixels("-highlightthickness")
+        px, py = o.pixels("-padx"), o.pixels("-pady")
+        left, right, top, bottom = b + px, b + px, b + py, b + py
+        lw, lh, any_label = self._label_size()
+        if any_label:
+            a = self._anchor()
+            if a[0] in "n" or a in ("n", "ne", "nw"):
+                top += max(lh, bw) - bw
+            elif a[0] == "s":
+                bottom += max(lh, bw) - bw
+            elif a[0] == "e":
+                right += max(lw, bw) - bw
+            else:
+                left += max(lw, bw) - bw
+        return (left, top, right, bottom)
+
+    def min_req(self):
+        o = self.options
+        lw, lh, any_label = self._label_size()
+        if not any_label:
+            return 0, 0
+        bw, ht = o.pixels("-borderwidth"), o.pixels("-highlightthickness")
+        padding = ht + (bw + LABELMARGIN if bw > 0 else 0)
+        padding *= 2
+        if self._anchor()[0] in "ns":
+            return lw + padding, max(lh, bw) + bw + ht
+        return max(lw, bw) + bw + ht, lh + padding
+
+    def label_box(self):
+        """(x, y, w, h) of the label."""
+        o = self.options
+        lw, lh, any_label = self._label_size()
+        if not any_label:
+            return None
+        bw, ht = o.pixels("-borderwidth"), o.pixels("-highlightthickness")
+        a = self._anchor()
+        padding = ht + (bw + LABELMARGIN if bw > 0 else 0)
+        W, H = self.width, self.height
+        if a[0] in "ns":
+            lw = min(lw, max(W - 2 * padding, 1))
+            y = ht if a[0] == "n" else H - lh - ht
+            sub = a[1:] or "c"
+            if sub == "w":
+                x = padding
+            elif sub == "e":
+                x = W - padding - lw
+            else:
+                x = (W - lw) // 2
+        else:
+            lh = min(lh, max(H - 2 * padding, 1))
+            x = ht if a[0] == "w" else W - lw - ht
+            sub = a[1:] or "c"
+            if sub == "n":
+                y = padding
+            elif sub == "s":
+                y = H - padding - lh
+            else:
+                y = (H - lh) // 2
+        return x, y, lw, lh
+
+    def display(self):
+        o = self.options
+        bg = o.color("-background") or "#d9d9d9"
+        bw, ht = o.pixels("-borderwidth"), o.pixels("-highlightthickness")
+        res = [["fill", 0, 0, self.width, self.height, bg]]
+        box = self.label_box()
+        bx, by, bwid, bhei = ht, ht, self.width - 2 * ht, self.height - 2 * ht
+        if box is not None:
+            lx, ly, lw, lh = box
+            a = self._anchor()
+            if a[0] == "n":
+                by = ht + (lh - bw) // 2
+                bhei = self.height - by - ht
+            elif a[0] == "s":
+                bhei = self.height - ht - (lh - bw) // 2 - by
+            elif a[0] == "w":
+                bx = ht + (lw - bw) // 2
+                bwid = self.width - bx - ht
+            else:
+                bwid = self.width - ht - (lw - bw) // 2 - bx
+        relief = o.str("-relief")
+        if bw > 0 and relief != "flat":
+            res.append(["border", bx, by, bwid, bhei, bw, relief, bg])
+        if box is not None and not o.str("-labelwidget"):
+            lx, ly, lw, lh = box
+            res.append(["fill", lx, ly, lw, lh, bg])
+            font = self.interp.font(o["-font"])
+            layout = font.layout(o.str("-text"), 0, "center")
+            for x, y, text, _ in layout.runs(lx + LABELSPACING, ly + LABELSPACING):
+                res.append(["text", x, y, text, font.css(),
+                            o.color("-foreground") or "#000000", -1])
+        res.extend(self.highlight_display())
+        return res

tkinter_web/tk/widgets/listbox.py

@@ -0,0 +1,450 @@
+"""
+Listbox (tkListbox.c and library/listbox.tcl).
+"""
+
+from ..events import Event
+from ..options import OptionSet
+from ..tcl import TclError, get_double, get_int, split_list, to_str
+from .base import Widget
+
+_ITEM_SPECS = (
+    ("-background", "", "", ""), ("-foreground", "", "", ""),
+    ("-selectbackground", "", "", ""), ("-selectforeground", "", "", ""),
+)
+
+
+class Listbox(Widget):
+    kind = "listbox"
+    default_class = "Listbox"
+    traversal = True
+
+    def __init__(self, interp, path, parent, args):
+        self.items = []
+        self.item_options = {}  # index -> dict
+        self.selection = set()
+        self.active = 0
+        self.anchor = 0
+        self.top = 0  # first visible line
+        self.xoffset = 0
+        self.drag_start = None
+        super().__init__(interp, path, parent, args)
+
+    def options_changed(self, names, creating):
+        if "-listvariable" in names:
+            self.interp.variables.relink(self, "-listvariable")
+            var = self.options.str("-listvariable")
+            if var:
+                value = self.interp.variables.peek(var)
+                if value is None:
+                    self._sync_var()
+                else:
+                    self.items = [to_str(x) for x in split_list(value)]
+        super().options_changed(names, creating)
+
+    def variable_changed(self, option):
+        var = self.options.str("-listvariable")
+        value = self.interp.variables.peek(var)
+        self.items = [] if value is None else [to_str(x) for x in split_list(value)]
+        self.selection = {i for i in self.selection if i < len(self.items)}
+        self.mark_dirty(layout=True)
+        self._yscroll()
+
+    def _sync_var(self):
+        var = self.options.str("-listvariable")
+        if var:
+            self.interp.variables.set(var, tuple(self.items), notify_widget=self)
+
+    # -- geometry
+
+    def font(self):
+        return self.interp.font(self.options["-font"])
+
+    def inset(self):
+        o = self.options
+        return o.pixels("-highlightthickness") + o.pixels("-borderwidth")
+
+    def line_height(self):
+        return self.font().linespace + 1 + 2 * self.options.pixels("-selectborderwidth")
+
+    def natural_size(self):
+        o = self.options
+        font = self.font()
+        unit = font.measure("0") or 1
+        width = o.int("-width")
+        if width <= 0:
+            maxw = max((font.measure(t) for t in self.items), default=0)
+            width = max((maxw + unit - 1) // unit, 1)
+        sbw = o.pixels("-selectborderwidth")
+        inset = self.inset()
+        height = o.int("-height")
+        if height <= 0:
+            height = max(len(self.items), 1)
+        return width * unit + 2 * inset + 2 * sbw, height * self.line_height() + 2 * inset
+
+    def visible_lines(self):
+        h = self.height - 2 * self.inset()
+        return max(h // self.line_height(), 1)
+
+    def nearest(self, y):
+        i = self.top + (y - self.inset()) // self.line_height()
+        return max(0, min(i, len(self.items) - 1))
+
+    # -- display
+
+    def display(self):
+        o = self.options
+        state = o.str("-state")
+        bg = o.color("-background")
+        fg = o.color("-disabledforeground") if state == "disabled" else o.color("-foreground")
+        res = [["fill", 0, 0, self.width, self.height, bg]]
+        inset = self.inset()
+        font = self.font()
+        lh = self.line_height()
+        sbw = o.pixels("-selectborderwidth")
+        res.append(["clip", inset, inset, self.width - 2 * inset, self.height - 2 * inset])
+        n = self.visible_lines() + 1
+        css = font.css()
+        justify = o.str("-justify")
+        for k in range(n):
+            i = self.top + k
+            if i >= len(self.items):
+                break
+            y = inset + k * lh
+            iopts = self.item_options.get(i, {})
+            text = self.items[i]
+            color = iopts.get("-foreground") or fg
+            ibg = iopts.get("-background")
+            if ibg:
+                res.append(["fill", inset, y, self.width - 2 * inset, lh, ibg])
+            if i in self.selection:
+                sel_bg = iopts.get("-selectbackground") or o.color("-selectbackground")
+                res.append(["fill", inset, y, self.width - 2 * inset, lh, sel_bg])
+                if sbw > 0:
+                    res.append(["border", inset, y, self.width - 2 * inset, lh, sbw, "raised", sel_bg])
+                color = iopts.get("-selectforeground") or o.color("-selectforeground") or color
+            tw = font.measure(text)
+            avail = self.width - 2 * inset - 2 * sbw
+            if justify == "center":
+                x = inset + sbw + (avail - tw) // 2
+            elif justify == "right":
+                x = inset + sbw + avail - tw - 1
+            else:
+                x = inset + sbw + 1
+            res.append(["text", x - self.xoffset, y + sbw + font.ascent, text, css, color, -1])
+            if i == self.active and self.has_focus and state != "disabled":
+                style = o.str("-activestyle")
+                if style == "dotbox":
+                    res.append(["dotbox", inset, y, self.width - 2 * inset, lh, color])
+                elif style == "underline":
+                    res.append(["hline", x - self.xoffset, y + sbw + font.ascent + 1, tw, color])
+        res.append(["unclip"])
+        res.append(["border", o.pixels("-highlightthickness"), o.pixels("-highlightthickness"),
+                    self.width - 2 * o.pixels("-highlightthickness"),
+                    self.height - 2 * o.pixels("-highlightthickness"),
+                    o.pixels("-borderwidth"), o.str("-relief"), bg])
+        res.extend(self.highlight_display())
+        return res
+
+    # -- scrolling
+
+    def _clamp_top(self):
+        n = len(self.items)
+        self.top = max(0, min(self.top, max(n - self.visible_lines(), 0)))
+
+    def geometry_changed(self):
+        self._clamp_top()
+        self._yscroll()
+
+    def yview_fractions(self):
+        n = len(self.items)
+        if n == 0:
+            return 0.0, 1.0
+        first = self.top / n
+        last = min((self.top + self.visible_lines()) / n, 1.0)
+        return first, last
+
+    def _yscroll(self):
+        cmd = self.options.str("-yscrollcommand")
+        if cmd:
+            first, last = self.yview_fractions()
+            self.interp.renderer.scroll_command(self, cmd, first, last)
+
+    def see(self, i):
+        vis = self.visible_lines()
+        if i < self.top:
+            self.top = i
+        elif i >= self.top + vis:
+            self.top = i - vis + 1
+        self._clamp_top()
+        self.mark_dirty()
+        self._yscroll()
+
+    # -- indices
+
+    def index(self, value, end_ok=True):
+        v = to_str(value)
+        n = len(self.items)
+        if v == "end":
+            return n if end_ok else max(n - 1, 0)
+        if v == "active":
+            return self.active
+        if v == "anchor":
+            return self.anchor
+        if v.startswith("@"):
+            try:
+                _, y = (int(p) for p in v[1:].split(","))
+            except ValueError:
+                raise TclError(f'bad listbox index "{v}": must be active, anchor, end, @x,y, or a number') from None
+            return self.nearest(y)
+        try:
+            i = get_int(v)
+        except TclError:
+            raise TclError(f'bad listbox index "{v}": must be active, anchor, end, @x,y, or a number') from None
+        return i
+
+    def _range(self, args):
+        first = self.index(args[0])
+        last = self.index(args[1]) if len(args) > 1 else first
+        if to_str(args[1] if len(args) > 1 else args[0]) == "end":
+            last = len(self.items) - 1
+        if to_str(args[0]) == "end":
+            first = len(self.items) - 1
+        return first, last
+
+    # -- widget command
+
+    def subcommand(self, sub, args):
+        n = len(self.items)
+        if sub == "insert":
+            i = self.index(args[0])
+            i = max(0, min(i, n))
+            new = [to_str(a) for a in args[1:]]
+            self.items[i:i] = new
+            self.selection = {s + len(new) if s >= i else s for s in self.selection}
+            self.item_options = {k + len(new) if k >= i else k: v for k, v in self.item_options.items()}
+            if self.active >= i and n:
+                self.active += len(new)
+            self._sync_var()
+            self.mark_dirty(layout=True)
+            self._yscroll()
+            return ""
+        if sub == "delete":
+            first, last = self._range(args)
+            first = max(first, 0)
+            last = min(last, n - 1)
+            if first > last:
+                return ""
+            cnt = last - first + 1
+            del self.items[first : last + 1]
+
+            def shift(i):
+                return i - cnt if i > last else i
+
+            self.selection = {shift(s) for s in self.selection if not first <= s <= last}
+            self.item_options = {shift(k): v for k, v in self.item_options.items()
+                                 if not first <= k <= last}
+            if self.active > last:
+                self.active -= cnt
+            elif self.active >= first:
+                self.active = min(first, max(len(self.items) - 1, 0))
+            self._clamp_top()
+            self._sync_var()
+            self.mark_dirty(layout=True)
+            self._yscroll()
+            return ""
+        if sub == "get":
+            first, last = self._range(args)
+            if len(args) == 1:
+                return self.items[first] if 0 <= first < n else ""
+            first = max(first, 0)
+            return tuple(self.items[first : last + 1])
+        if sub == "size":
+            return n
+        if sub == "index":
+            return self.index(args[0])
+        if sub == "curselection":
+            return tuple(sorted(self.selection))
+        if sub in ("selection", "select"):
+            op = to_str(args[0])
+            if op == "includes":
+                return int(self.index(args[1]) in self.selection)
+            if op == "anchor":
+                self.anchor = max(0, min(self.index(args[1]), n - 1))
+                return ""
+            first, last = self._range(args[1:])
+            first, last = min(first, last), max(first, last)
+            rng = {i for i in range(max(first, 0), min(last, n - 1) + 1)}
+            if op == "set":
+                self.selection |= rng
+            elif op == "clear":
+                self.selection -= rng
+            else:
+                raise TclError(f'bad option "{op}": must be anchor, clear, includes, or set')
+            self.mark_dirty()
+            return ""
+        if sub == "activate":
+            i = self.index(args[0])
+            self.active = max(0, min(i, n - 1)) if n else 0
+            self.mark_dirty()
+            return ""
+        if sub == "see":
+            i = self.index(args[0])
+            if 0 <= i < n:
+                self.see(i)
+            return ""
+        if sub == "nearest":
+            return self.nearest(get_int(args[0]))
+        if sub == "bbox":
+            i = self.index(args[0])
+            if not self.top <= i < self.top + self.visible_lines() + 1 or i >= n:
+                return ""
+            font = self.font()
+            inset = self.inset()
+            y = inset + (i - self.top) * self.line_height()
+            return (inset + 1, y, font.measure(self.items[i]), font.linespace)
+        if sub == "yview":
+            return self._yview(args)
+        if sub == "xview":
+            if not args:
+                return (0.0, 1.0)
+            return ""
+        if sub in ("itemconfigure", "itemcget"):
+            i = self.index(args[0])
+            opts = self.item_options.setdefault(i, {})
+            if sub == "itemcget":
+                return opts.get(to_str(args[1]), "")
+            if len(args) == 1:
+                return tuple((k, "", "", "", opts.get(k, "")) for k, *_ in _ITEM_SPECS)
+            if len(args) == 2:
+                k = to_str(args[1])
+                return (k, "", "", "", opts.get(k, ""))
+            from ..options import parse_color
+            for k, v in zip(args[1::2], args[2::2]):
+                k = to_str(k)
+                if k in ("-bg",):
+                    k = "-background"
+                if k in ("-fg",):
+                    k = "-foreground"
+                opts[k] = parse_color(v) if to_str(v) else ""
+            self.mark_dirty()
+            return ""
+        if sub == "scan":
+            return ""
+        raise TclError(f'bad option "{sub}": must be activate, bbox, cget, configure, '
+                       'curselection, delete, get, index, insert, itemcget, '
+                       'itemconfigure, nearest, scan, see, selection, size, xview, or yview')
+
+    def _yview(self, args):
+        if not args:
+            return self.yview_fractions()
+        sub = to_str(args[0])
+        n = len(self.items)
+        if sub == "moveto":
+            self.top = int(get_double(args[1]) * n + 0.5)
+        elif sub == "scroll":
+            k = get_int(args[1])
+            if to_str(args[2]).startswith("p"):
+                k *= max(self.visible_lines() - 1, 1)
+            self.top += k
+        else:
+            self.top = self.index(args[0])
+        self._clamp_top()
+        self.mark_dirty()
+        self._yscroll()
+        return ""
+
+    # -- class bindings (listbox.tcl)
+
+    def _select_event(self):
+        self.interp.queue_event(Event("VirtualEvent", self, detail="ListboxSelect"))
+
+    def class_event(self, event):
+        o = self.options
+        if o.str("-state") == "disabled":
+            return None
+        t = event.type
+        mode = o.str("-selectmode")
+        n = len(self.items)
+        if t == "ButtonPress" and event.button == 1 and n:
+            if self.interp.takes_focus_on_click(self):
+                self.interp.set_focus(self)
+            i = self.nearest(event.y)
+            old = set(self.selection)
+            if mode in ("browse", "single"):
+                if mode == "single" and i in self.selection:
+                    self.selection = set()
+                else:
+                    self.selection = {i}
+            elif mode == "multiple":
+                self.selection ^= {i}
+            else:  # extended
+                if event.state & 4:
+                    self.selection ^= {i}
+                    self.anchor = i
+                elif event.state & 1:
+                    a = self.anchor
+                    self.selection = set(range(min(a, i), max(a, i) + 1))
+                else:
+                    self.selection = {i}
+                    self.anchor = i
+            self.anchor = i if not event.state & 1 else self.anchor
+            self.active = i
+            self.drag_start = i
+            self.mark_dirty()
+            if self.selection != old:
+                self._select_event()
+        elif t == "Motion" and event.state & 256 and self.drag_start is not None and n:
+            i = self.nearest(event.y)
+            old = set(self.selection)
+            if mode == "browse":
+                self.selection = {i}
+            elif mode == "extended":
+                a = self.anchor
+                self.selection = set(range(min(a, i), max(a, i) + 1))
+            self.active = i
+            if event.y < 0 or event.y >= self.height:
+                self.see(i)
+            self.mark_dirty()
+            if self.selection != old:
+                self._select_event()
+        elif t == "ButtonRelease" and event.button == 1:
+            self.drag_start = None
+        elif t == "MouseWheel":
+            self._yview(("scroll", -5 if event.delta > 0 else 5, "units"))
+            return "break"
+        elif t == "KeyPress" and n:
+            k = event.keysym
+            step = {"Up": -1, "Down": 1, "Prior": -self.visible_lines(),
+                    "Next": self.visible_lines(), "Home": -n, "End": n}.get(k)
+            if step is not None:
+                i = max(0, min(self.active + step, n - 1))
+                self.active = i
+                old = set(self.selection)
+                if mode == "browse":
+                    self.selection = {i}
+                elif mode == "extended":
+                    if event.state & 1:
+                        a = self.anchor
+                        self.selection = set(range(min(a, i), max(a, i) + 1))
+                    else:
+                        self.selection = {i}
+                        self.anchor = i
+                self.see(i)
+                self.mark_dirty()
+                if self.selection != old:
+                    self._select_event()
+            elif k == "space" and mode in ("single", "multiple", "extended"):
+                old = set(self.selection)
+                if mode == "multiple":
+                    self.selection ^= {self.active}
+                else:
+                    self.selection = {self.active}
+                self.anchor = self.active
+                self.mark_dirty()
+                if self.selection != old:
+                    self._select_event()
+            elif event.state & 4 and k in ("a", "slash") and mode in ("multiple", "extended"):
+                self.selection = set(range(n))
+                self.mark_dirty()
+                self._select_event()
+        return None