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

tkinter_web/tk/widgets/menu.py

@@ -0,0 +1,723 @@
+"""
+Menus (tkMenu.c, tkUnixMenu.c, library/menu.tcl) and menubuttons.
+
+A menu is a toplevel window: posted menus are displayed by the client as
+undecorated windows, menubars (``toplevel -menu``) as an HTML bar above the
+window content.
+"""
+
+import time
+
+from ..events import Event
+from ..options import OptionSet, menu_entry_specs, parse_color
+from ..tcl import TclError, get_int, split_list, to_str
+from .base import Widget
+from .buttons import Label, TYPE_BUTTON
+
+TEAROFF_HEIGHT = 8
+SEPARATOR_HEIGHT = 8
+
+
+class MenuEntry:
+    def __init__(self, menu, kind):
+        self.menu = menu
+        self.kind = kind
+        specs = menu_entry_specs("separator" if kind == "tearoff" else kind)
+        self.options = OptionSet(specs, "menuentry", menu.interp.scaling)
+        if kind == "checkbutton" or kind == "radiobutton":
+            pass
+
+    def label(self):
+        return self.options.str("-label") if "-label" in self.options.specs else ""
+
+    def state(self):
+        return self.options.str("-state") if "-state" in self.options.specs else "normal"
+
+    def selected(self):
+        o = self.options
+        var = o.str("-variable") if "-variable" in o.specs else ""
+        if not var:
+            return False
+        v = self.menu.interp.variables.peek(var)
+        if v is None:
+            return False
+        if self.kind == "checkbutton":
+            return to_str(v) == to_str(o["-onvalue"])
+        if self.kind == "radiobutton":
+            value = o.str("-value") or self.label()
+            return to_str(v) == value
+        return False
+
+
+class Menu(Widget):
+    kind = "menu"
+    default_class = "Menu"
+    is_menu = True
+
+    def __init__(self, interp, path, parent, args):
+        self.entries = []
+        self.active = None
+        self.posted_cascade = None  # submenu posted from this menu
+        self.parent_menu = None  # menu (or menubutton/toplevel) that posted this one
+        self.wm = {
+            "title": None, "geometry": None, "position": None, "state": "withdrawn",
+            "resizable": (False, False), "minsize": (1, 1), "maxsize": None,
+            "protocols": {}, "attributes": {"-alpha": 1.0, "-topmost": 1, "-type": "menu"},
+            "overrideredirect": True, "transient": "", "iconphoto": None, "group": "",
+            "user_size": None, "grid": None, "aspect": None, "iconname": "",
+        }
+        self.grabbed = False
+        super().__init__(interp, path, parent, args)
+        if self.options.boolean("-tearoff"):
+            self.entries.append(MenuEntry(self, "tearoff"))
+
+    def is_toplevel_like(self):
+        return True
+
+    def viewable(self):
+        return self.wm["state"] == "normal"
+
+    def title(self):
+        return self.options.str("-title") or self.name
+
+    def options_changed(self, names, creating):
+        if "-tearoff" in names and not creating:
+            has = bool(self.entries) and self.entries[0].kind == "tearoff"
+            want = self.options.boolean("-tearoff")
+            if want and not has:
+                self.entries.insert(0, MenuEntry(self, "tearoff"))
+            elif has and not want:
+                self.entries.pop(0)
+        super().options_changed(names, creating)
+        self._menubar_changed()
+
+    def _menubar_changed(self):
+        for top in self.interp.toplevels():
+            if "-menu" in top.options.specs and top.options.str("-menu") == self.path:
+                top.mark_dirty()
+
+    def mark_dirty(self, layout=False):
+        super().mark_dirty(layout=True)
+
+    # -- geometry
+
+    def font(self, entry=None):
+        if entry is not None and "-font" in entry.options.specs and entry.options.str("-font"):
+            return self.interp.font(entry.options["-font"])
+        return self.interp.font(self.options["-font"])
+
+    def entry_metrics(self):
+        """[(y, height)] of the entries and the column widths."""
+        o = self.options
+        bw = o.pixels("-borderwidth")
+        abw = o.pixels("-activeborderwidth")
+        font = self.font()
+        rows = []
+        y = bw
+        label_w = accel_w = 0
+        indicator = 0
+        for e in self.entries:
+            f = self.font(e)
+            if e.kind == "tearoff":
+                h = TEAROFF_HEIGHT
+            elif e.kind == "separator":
+                h = SEPARATOR_HEIGHT
+            else:
+                h = f.linespace + 2 * abw + 2
+                img = e.options.str("-image") if "-image" in e.options.specs else ""
+                if img and img in self.interp.images:
+                    h = max(h, self.interp.images[img].height + 2 * abw + 2)
+                label_w = max(label_w, f.measure(e.label()) + self._image_w(e))
+                acc = e.options.str("-accelerator") if "-accelerator" in e.options.specs else ""
+                if acc:
+                    accel_w = max(accel_w, f.measure(acc))
+                if e.kind in ("checkbutton", "radiobutton", "cascade"):
+                    indicator = max(indicator, f.linespace)
+            rows.append((y, h))
+            y += h
+        return rows, y + bw, label_w, accel_w, indicator
+
+    def _image_w(self, e):
+        img = e.options.str("-image") if "-image" in e.options.specs else ""
+        if img and img in self.interp.images:
+            w = self.interp.images[img].width
+            compound = e.options.str("-compound")
+            return w + (4 if compound in ("left", "right") and e.label() else 0) if compound != "none" else w
+        return 0
+
+    def natural_size(self):
+        o = self.options
+        bw = o.pixels("-borderwidth")
+        abw = o.pixels("-activeborderwidth")
+        rows, height, label_w, accel_w, indicator = self.entry_metrics()
+        font = self.font()
+        ind = max(font.linespace, indicator)
+        width = bw + abw + ind + label_w + (font.measure("0") * 3 if accel_w else 0) \
+            + accel_w + ind + abw + bw
+        return max(width, 40, getattr(self, "_min_width", 0)), max(height, 2 * bw + 4)
+
+    def menubar_height(self):
+        return 22
+
+    def entry_at(self, y):
+        rows, *_ = self.entry_metrics()
+        for i, (ey, h) in enumerate(rows):
+            if ey <= y < ey + h:
+                return i
+        return None
+
+    # -- display
+
+    def display(self):
+        o = self.options
+        bg = o.color("-background")
+        fg = o.color("-foreground")
+        bw = o.pixels("-borderwidth")
+        abw = o.pixels("-activeborderwidth")
+        W = self.width
+        res = [["fill", 0, 0, W, self.height, bg]]
+        rows, _, label_w, accel_w, indicator = self.entry_metrics()
+        font = self.font()
+        ind = max(font.linespace, indicator)
+        for i, (e, (y, h)) in enumerate(zip(self.entries, rows)):
+            if e.kind == "tearoff":
+                res.append(["dash", bw + 2, y + h // 2, W - 2 * bw - 4, fg])
+                continue
+            if e.kind == "separator":
+                res.append(["border", bw + 2, y + h // 2 - 1, W - 2 * bw - 4, 2, 1, "sunken", bg])
+                continue
+            eo = e.options
+            state = e.state()
+            active = i == self.active and state != "disabled"
+            ebg = eo.color("-background") if "-background" in eo.specs and eo.str("-background") else bg
+            efg = eo.color("-foreground") if "-foreground" in eo.specs and eo.str("-foreground") else fg
+            if active:
+                ebg = (eo.color("-activebackground") if eo.str("-activebackground") else None) or \
+                    o.color("-activebackground")
+                efg = (eo.color("-activeforeground") if eo.str("-activeforeground") else None) or \
+                    o.color("-activeforeground")
+                res.append(["fill", bw, y, W - 2 * bw, h, ebg])
+                if abw > 0:
+                    res.append(["border", bw, y, W - 2 * bw, h, abw, "raised", ebg])
+            elif ebg != bg:
+                res.append(["fill", bw, y, W - 2 * bw, h, ebg])
+            if state == "disabled":
+                efg = o.color("-disabledforeground") or "#a3a3a3"
+            f = self.font(e)
+            css = f.css()
+            ty = y + (h - f.linespace) // 2 + f.ascent
+            x = bw + abw + ind
+            img = eo.str("-image") if "-image" in eo.specs else ""
+            if img and img in self.interp.images:
+                im = self.interp.images[img]
+                res.append(["image", x, y + (h - im.height) // 2, img])
+                x += im.width + 4
+            if e.kind != "tearoff":
+                res.append(["text", x, ty, e.label(), css, efg,
+                            eo.int("-underline", -1) if "-underline" in eo.specs else -1])
+            acc = eo.str("-accelerator") if "-accelerator" in eo.specs else ""
+            if acc:
+                res.append(["text", W - bw - abw - ind - f.measure(acc), ty, acc, css, efg, -1])
+            cy = y + h // 2
+            if e.kind == "cascade":
+                res.append(["arrow", W - bw - abw - ind // 2, cy, max(ind // 2, 5), "right", efg])
+            elif e.kind in ("checkbutton", "radiobutton") and (
+                    "-indicatoron" not in eo.specs or eo.boolean("-indicatoron")):
+                if e.selected():
+                    sel = eo.color("-selectcolor") if eo.str("-selectcolor") else efg
+                    if e.kind == "checkbutton":
+                        res.append(["checkmark", bw + abw + ind // 2, cy, max(ind - 6, 7), sel])
+                    else:
+                        res.append(["dot", bw + abw + ind // 2, cy, max(ind // 5, 2), sel])
+        res.append(["border", 0, 0, W, self.height, bw, o.str("-relief"), bg])
+        return res
+
+    # -- menubar description for the client
+
+    def menubar_description(self):
+        res = []
+        for i, e in enumerate(self.entries):
+            if e.kind in ("tearoff", "separator"):
+                continue
+            sub = e.options.str("-menu") if "-menu" in e.options.specs else ""
+            res.append({"label": e.label(), "menu": sub or None, "index": i,
+                        "state": e.state(), "kind": e.kind,
+                        "open": bool(sub) and sub in self.interp.widgets and
+                        self.interp.widgets[sub].viewable()})
+        return res
+
+    # -- indices
+
+    def index(self, value, allow_none=True):
+        v = value if isinstance(value, int) else to_str(value)
+        n = len(self.entries)
+        if isinstance(v, int):
+            return v
+        if v == "active":
+            return self.active if self.active is not None else "none"
+        if v in ("end", "last"):
+            return n - 1 if n else "none"
+        if v == "none" or v == "":
+            return "none"
+        if v.startswith("@"):
+            try:
+                y = int(v[1:].split(",")[-1])
+            except ValueError:
+                raise TclError(f'bad menu entry index "{v}"') from None
+            i = self.entry_at(y)
+            return i if i is not None else "none"
+        try:
+            return get_int(v)
+        except TclError:
+            pass
+        import fnmatch
+        for i, e in enumerate(self.entries):
+            if e.kind not in ("tearoff", "separator") and fnmatch.fnmatchcase(e.label(), v):
+                return i
+        raise TclError(f'bad menu entry index "{v}"')
+
+    def _entry(self, value):
+        i = self.index(value)
+        if i == "none" or not 0 <= i < len(self.entries):
+            return None, None
+        return i, self.entries[i]
+
+    # -- widget command
+
+    def subcommand(self, sub, args):
+        if sub in ("add", "insert"):
+            if sub == "insert":
+                pos = self.index(args[0])
+                pos = len(self.entries) if pos == "none" else max(0, min(pos, len(self.entries)))
+                if self.entries and self.entries[0].kind == "tearoff" and pos == 0:
+                    pos = 1
+                args = args[1:]
+            else:
+                pos = len(self.entries)
+            kind = to_str(args[0])
+            kinds = ("cascade", "checkbutton", "command", "radiobutton", "separator")
+            m = [k for k in kinds if k.startswith(kind)] if kind else []
+            if len(m) != 1:
+                raise TclError(f'bad menu entry type "{kind}": must be cascade, checkbutton, '
+                               'command, radiobutton, or separator')
+            e = MenuEntry(self, m[0])
+            self._configure_entry(e, args[1:])
+            self.entries.insert(pos, e)
+            self.mark_dirty()
+            self._menubar_changed()
+            return ""
+        if sub == "delete":
+            i1 = self.index(args[0])
+            i2 = self.index(args[1]) if len(args) > 1 else i1
+            if i1 == "none":
+                return ""
+            if i2 == "none":
+                i2 = i1
+            for i in range(min(i2, len(self.entries) - 1), i1 - 1, -1):
+                if self.entries[i].kind != "tearoff":
+                    del self.entries[i]
+            self.active = None
+            self.mark_dirty()
+            self._menubar_changed()
+            return ""
+        if sub in ("entryconfigure", "entrycget"):
+            i, e = self._entry(args[0])
+            if e is None:
+                raise TclError(f'bad menu entry index "{to_str(args[0])}"')
+            if sub == "entrycget":
+                return e.options.values[e.options.resolve(args[1])]
+            if len(args) == 1:
+                return e.options.configure_info()
+            if len(args) == 2:
+                return e.options.configure_info(args[1])
+            self._configure_entry(e, args[1:])
+            self.mark_dirty()
+            self._menubar_changed()
+            return ""
+        if sub == "index":
+            i = self.index(args[0])
+            return i
+        if sub == "type":
+            i, e = self._entry(args[0])
+            return e.kind if e is not None else ""
+        if sub == "invoke":
+            i, e = self._entry(args[0])
+            if e is None:
+                return ""
+            return self.invoke(i)
+        if sub == "activate":
+            i = self.index(args[0])
+            self.active = None if i == "none" else i
+            self.mark_dirty()
+            return ""
+        if sub == "post":
+            x, y = get_int(args[0]), get_int(args[1])
+            self.post(x, y)
+            return ""
+        if sub == "unpost":
+            self.unpost()
+            return ""
+        if sub == "postcascade":
+            i, e = self._entry(args[0])
+            if e is not None and e.kind == "cascade":
+                self._post_cascade(i)
+            return ""
+        if sub == "yposition":
+            i = self.index(args[0])
+            rows, *_ = self.entry_metrics()
+            return rows[i][0] if i != "none" and 0 <= i < len(rows) else 0
+        if sub == "xposition":
+            return 0
+        if sub == "clone":
+            return ""
+        raise TclError(f'bad option "{sub}": must be activate, add, cget, clone, configure, '
+                       'delete, entrycget, entryconfigure, index, insert, invoke, post, '
+                       'postcascade, type, unpost, xposition, or yposition')
+
+    def _configure_entry(self, e, args):
+        if len(args) % 2:
+            raise TclError(f'value for "{to_str(args[-1])}" missing')
+        for name, value in zip(args[::2], args[1::2]):
+            e.options.set(name, value)
+        if e.kind == "radiobutton" and not e.options.str("-variable"):
+            e.options.values["-variable"] = "selectedButton"
+        if e.kind == "checkbutton" and not e.options.str("-variable"):
+            e.options.values["-variable"] = e.label()
+        var = e.options.str("-variable") if "-variable" in e.options.specs else ""
+        if var:
+            self.interp.variables.link(var, self, "-variable")
+
+    def variable_changed(self, option):
+        self.mark_dirty()
+
+    # -- posting
+
+    def post(self, x, y, parent=None):
+        self.interp.run_idle()
+        from ..layout import compute_requests
+        compute_requests(self)
+        w, h = self.req_w, self.req_h
+        sw, sh = self.interp.screen_width, self.interp.screen_height
+        x = max(0, min(x, sw - w))
+        y = max(0, min(y, sh - h)) if y + h > sh else y
+        self.x, self.y = x, y
+        self.wm["position"] = (x, y)
+        self.wm["state"] = "normal"
+        self.parent_menu = parent
+        self.active = None
+        self.post_time = time.monotonic()
+        self.pressed_here = False
+        cmd = self.options.str("-postcommand")
+        if cmd:
+            self.interp.run_protected(self.interp.eval_script, cmd)
+        if self in self.interp.toplevel_order:
+            self.interp.toplevel_order.remove(self)
+        self.interp.toplevel_order.append(self)
+        if self.interp.focus_widget is not None and not getattr(self.interp.focus_widget, "is_menu", False):
+            self._saved_focus = self.interp.focus_widget
+        self.mark_dirty()
+        self._menubar_changed()
+        if parent is not None and hasattr(parent, "_menubar_changed"):
+            parent._menubar_changed()
+        self._owner_changed()
+
+    def _owner_changed(self):
+        for top in self.interp.toplevels():
+            m = top.options.str("-menu") if "-menu" in top.options.specs else ""
+            if m and m in self.interp.widgets:
+                top.mark_dirty()
+
+    def unpost(self):
+        if self.posted_cascade is not None:
+            sub = self.posted_cascade
+            self.posted_cascade = None
+            sub.unpost()
+        if self.wm["state"] != "withdrawn":
+            self.wm["state"] = "withdrawn"
+            self.active = None
+            self.mark_dirty()
+            self._owner_changed()
+            owner = self.parent_menu
+            if isinstance(owner, Menubutton):
+                owner.posted = False
+                owner.mark_dirty()
+
+    @staticmethod
+    def unpost_all(interp, keep=None):
+        for w in list(interp.toplevel_order):
+            if isinstance(w, Menu) and w.viewable():
+                if keep is not None and (keep is w or _menu_chain_contains(w, keep)
+                                         or w.root_menu().parent_menu is keep):
+                    # the owner (menubutton, combobox) toggles its own menu
+                    continue
+                w.unpost()
+
+    def root_menu(self):
+        m = self
+        while isinstance(m.parent_menu, Menu) and m.parent_menu.viewable():
+            m = m.parent_menu
+        return m
+
+    def _post_cascade(self, i):
+        e = self.entries[i]
+        sub_path = e.options.str("-menu")
+        sub = self.interp.widgets.get(sub_path)
+        if not isinstance(sub, Menu):
+            return
+        if self.posted_cascade is sub and sub.viewable():
+            return
+        if self.posted_cascade is not None:
+            self.posted_cascade.unpost()
+        rows, *_ = self.entry_metrics()
+        y = self.y + rows[i][0] - self.options.pixels("-borderwidth")
+        x = self.x + self.width - 2
+        self.posted_cascade = sub
+        sub.post(x, y, parent=self)
+
+    def invoke(self, i):
+        e = self.entries[i]
+        if e.state() == "disabled" or e.kind in ("separator", "tearoff", "cascade"):
+            return ""
+        o = e.options
+        if e.kind == "checkbutton":
+            var = o.str("-variable")
+            if var:
+                self.interp.variables.set(var, o["-offvalue"] if e.selected() else o["-onvalue"])
+        elif e.kind == "radiobutton":
+            var = o.str("-variable")
+            if var:
+                self.interp.variables.set(var, o.str("-value") or e.label())
+        cmd = o["-command"] if "-command" in o.specs else ""
+        if to_str(cmd):
+            return self.interp.eval_script(cmd)
+        return ""
+
+    # -- events
+
+    def class_event(self, event):
+        t = event.type
+        if t in ("Motion", "Enter"):
+            i = self.entry_at(event.y) if 0 <= event.x < self.width else None
+            if i is not None and self.entries[i].kind in ("separator", "tearoff"):
+                i = None
+            if i != self.active:
+                self.active = i
+                self.mark_dirty()
+                if i is not None and self.entries[i].kind == "cascade" and \
+                        self.entries[i].state() != "disabled":
+                    self._post_cascade(i)
+                elif self.posted_cascade is not None and i is not None:
+                    self.posted_cascade.unpost()
+                    self.posted_cascade = None
+        elif t == "Leave":
+            if self.active is not None and (self.posted_cascade is None or
+                                            not self.posted_cascade.viewable()):
+                self.active = None
+                self.mark_dirty()
+        elif t == "ButtonPress":
+            self.pressed_here = True
+        elif t == "ButtonRelease":
+            if not getattr(self, "pressed_here", False) and \
+                    time.monotonic() - getattr(self, "post_time", 0) < 0.4:
+                # the release of the click that posted the menu
+                return None
+            i = self.entry_at(event.y) if 0 <= event.x < self.width else None
+            if i is not None:
+                e = self.entries[i]
+                if e.kind == "cascade":
+                    self._post_cascade(i)
+                    return None
+                if e.kind in ("separator", "tearoff") or e.state() == "disabled":
+                    return None
+                self.root_menu().unpost()
+                Menu.unpost_all(self.interp)
+                self.interp.run_protected(self.invoke, i)
+        elif t == "KeyPress":
+            self.key(event.keysym)
+        return None
+
+    def key(self, keysym):
+        selectable = [i for i, e in enumerate(self.entries)
+                      if e.kind not in ("separator", "tearoff") and e.state() != "disabled"]
+        if keysym in ("Down", "Up") and selectable:
+            if self.active not in selectable:
+                self.active = selectable[0] if keysym == "Down" else selectable[-1]
+            else:
+                k = selectable.index(self.active) + (1 if keysym == "Down" else -1)
+                self.active = selectable[k % len(selectable)]
+            self.mark_dirty()
+        elif keysym in ("Return", "KP_Enter", "space") and self.active is not None:
+            e = self.entries[self.active]
+            if e.kind == "cascade":
+                self._post_cascade(self.active)
+            else:
+                i = self.active
+                Menu.unpost_all(self.interp)
+                self.interp.run_protected(self.invoke, i)
+        elif keysym == "Right" and self.active is not None and \
+                self.entries[self.active].kind == "cascade":
+            self._post_cascade(self.active)
+            sub = self.posted_cascade
+            if sub is not None:
+                sub.key("Down")
+        elif keysym in ("Escape", "Left"):
+            if isinstance(self.parent_menu, Menu):
+                self.unpost()
+            else:
+                Menu.unpost_all(self.interp)
+
+    def client_event(self, msg):
+        """Requests from the client menubar: post a cascade or invoke an entry."""
+        op = msg.get("op")
+        if op == "post":
+            top = self.interp.widgets.get(msg.get("win", "."))
+            if self.viewable():
+                Menu.unpost_all(self.interp)
+                return
+            Menu.unpost_all(self.interp)
+            self.post(int(msg.get("x", 0)), int(msg.get("y", 0)), parent=top)
+        elif op == "invoke":
+            Menu.unpost_all(self.interp)
+            self.interp.run_protected(self.invoke, int(msg.get("index", 0)))
+
+
+def _menu_chain_contains(menu, w):
+    while w is not None:
+        if w is menu:
+            return True
+        w = w.parent_menu if isinstance(w, Menu) else None
+    return False
+
+
+class Menubutton(Label):
+    kind = "menubutton"
+    default_class = "Menubutton"
+    btype = TYPE_BUTTON
+    traversal = True
+
+    def __init__(self, interp, path, parent, args):
+        self.posted = False
+        super().__init__(interp, path, parent, args)
+
+    def indicator_size(self):
+        """(width, height) of the option menu indicator (tkUnixMenubu.c)."""
+        if not self.options.boolean("-indicatoron"):
+            return 0, 0
+        px_per_mm = self.interp.scaling * 72 / 25.4
+        h = int(17 * px_per_mm / 10)
+        return int(40 * px_per_mm / 10) + 2 * h, h
+
+    def geometry_info(self):
+        g = super().geometry_info()
+        g["width"] -= 2
+        g["height"] -= 2
+        g["width"] += self.indicator_size()[0]
+        return g
+
+    def display(self):
+        o = self.options
+        ind_w, ind_h = self.indicator_size()
+        if not ind_w:
+            return super().display()
+        # the label is drawn without the indicator, which goes on the right
+        o.values["-indicatoron"] = 0
+        try:
+            self.width -= ind_w
+            res = super().display()
+        finally:
+            self.width += ind_w
+            o.values["-indicatoron"] = 1
+        bg = o.color("-activebackground") if o.str("-state") == "active" else o.color("-background")
+        inset = o.pixels("-highlightthickness") + o.pixels("-borderwidth")
+        W, H = self.width, self.height
+        # widen the background and border drawn for the narrower label
+        res = [r for r in res if r[0] not in ("border", "ring")]
+        res.insert(1, ["fill", W - ind_w - inset, 0, ind_w + inset, H, bg])
+        bw = max((ind_h + 1) // 3, 1)
+        res.append(["fill", W - inset - ind_w + ind_h, (H - ind_h) // 2, ind_w - 2 * ind_h,
+                    ind_h, bg])
+        res.append(["border", W - inset - ind_w + ind_h, (H - ind_h) // 2, ind_w - 2 * ind_h,
+                    ind_h, bw, "raised", bg])
+        if o.str("-relief") != "flat" and o.pixels("-borderwidth") > 0:
+            ht = o.pixels("-highlightthickness")
+            res.append(["border", ht, ht, W - 2 * ht, H - 2 * ht, o.pixels("-borderwidth"),
+                        o.str("-relief"), bg])
+        res.extend(self.highlight_display())
+        return res
+
+    def _shift(self, relief, x, y, width, height):
+        return x, y
+
+    def subcommand(self, sub, args):
+        raise TclError(f'bad option "{sub}": must be cget or configure')
+
+    def class_event(self, event):
+        o = self.options
+        t = event.type
+        if o.str("-state") == "disabled":
+            return None
+        if t == "Enter":
+            self.inside = True
+            o.values["-state"] = "active" if o.str("-state") == "normal" else o.str("-state")
+            self.mark_dirty()
+        elif t == "Leave":
+            self.inside = False
+            if o.str("-state") == "active":
+                o.values["-state"] = "normal"
+            self.mark_dirty()
+        elif t == "ButtonPress" and event.button == 1:
+            menu = self.interp.widgets.get(o.str("-menu"))
+            if isinstance(menu, Menu):
+                if menu.viewable():
+                    menu.unpost()
+                    return None
+                Menu.unpost_all(self.interp)
+                rx, ry = self.interp.root_xy(self)
+                direction = o.str("-direction")
+                from ..layout import compute_requests
+                compute_requests(menu)
+                if direction == "above":
+                    menu.post(rx, ry - menu.req_h, parent=self)
+                elif direction == "flush":
+                    # place the selected entry on the button (OptionMenu)
+                    menu.post(rx, ry, parent=self)
+                elif direction == "right":
+                    menu.post(rx + self.width, ry, parent=self)
+                elif direction == "left":
+                    menu.post(rx - menu.req_w, ry, parent=self)
+                else:
+                    menu.post(rx, ry + self.height, parent=self)
+                self.posted = True
+                self.mark_dirty()
+        return None
+
+
+def tk_popup(interp, args):
+    menu = interp.widget(args[0])
+    x, y = get_int(args[1]), get_int(args[2])
+    if isinstance(menu, Menu):
+        Menu.unpost_all(interp)
+        if len(args) > 3 and to_str(args[3]) != "":
+            i = menu.index(args[3])
+            rows, *_ = menu.entry_metrics()
+            if i != "none" and 0 <= i < len(rows):
+                y -= rows[i][0] + rows[i][1] // 2
+            menu.post(x, y)
+            menu.active = None if i == "none" else i
+        else:
+            menu.post(x, y)
+    return ""
+
+
+def tk_option_menu(interp, args):
+    path, var = to_str(args[0]), to_str(args[1])
+    values = [to_str(v) for v in args[2:]]
+    if interp.variables.peek(var) is None and values:
+        interp.variables.set(var, values[0])
+    interp.call("menubutton", path, "-textvariable", var, "-indicatoron", 1,
+                "-menu", path + ".menu", "-relief", "raised", "-highlightthickness", 1,
+                "-anchor", "c", "-direction", "flush")
+    interp.call("menu", path + ".menu", "-tearoff", 0)
+    for v in values:
+        interp.call(path + ".menu", "add", "radiobutton", "-label", v, "-variable", var)
+    return path + ".menu"