teek 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fdcad5500b3501e3d2b83d29678b76f8cc043b2f44e5e0af66a300fd8fa03ac
-  data.tar.gz: ca0b209ebe033d7e246271bda5491c8192279e063fdb5e45f2bb719fcd0cb5dc
+  metadata.gz: 3ff08eb5884f74dc6461c5ff1163a025b44b798e2e480bd4f2855210dd0f0fdf
+  data.tar.gz: 8e012ccf6a6fffe427630c033b288f784ed455552b064870b0bce054d11e62ee
 SHA512:
-  metadata.gz: d69b03be50a1ad912ba7f8f0610ae7ba6163b19bc342a9f763112a467ddef39f2b8d0e5e2317463c91096d02674f6641d345370c35c09b71f37055d40ceab926
-  data.tar.gz: b720547bd7a11f6a3f7c15ec33c78d2c86c42e80ea9b273dd50803e5d2012c6dd286ae2ebd30275ca9b85eaa26866da00df8d0982a21cde97361d8fa98a1df10
+  metadata.gz: 878e28a9a7493abdccdce1a4b28e372ade4648b12392cdb0815581b4590ab69b601eceb1da686e01719c6930fe1e88c333d4751e80f3af7875ce84a2a391957c
+  data.tar.gz: 0cd4b0ae71353720e185455e3966b954b9b2e2237417ce0efc596ad9915234f6b79923d318a54a1f42ddf9a839e8e58857462017192f750cd1d4ef31ce92710a

data/README.md

@@ -104,25 +104,54 @@ If a callback raises a Ruby exception, it becomes a Tcl error. The exception mes
 
 ## Menus
 
-Build a menu bar with standard `menu` widgets:
+Build a menu bar with `App#menu`:
 
 ```ruby
 app = Teek::App.new(title: 'My App')
 
-app.command(:menu, '.menubar')
-app.command('.', :configure, menu: '.menubar')
+menubar = app.menu('.menubar')
+app.command('.', :configure, menu: menubar)
 
-app.command(:menu, '.menubar.file', tearoff: 0)
-app.command('.menubar', :add, :cascade, label: 'File', menu: '.menubar.file')
-app.command('.menubar.file', :add, :command,
-           label: 'Quit', command: proc { app.command(:destroy, '.') })
+file_menu = app.menu('.menubar.file')
+menubar.command(:add, :cascade, label: 'File', menu: file_menu)
+file_menu.command(:add, :command, label: 'Quit', command: proc { app.command(:destroy, '.') })
 
 app.show
 app.mainloop
 ```
 
+`app.menu(path)` creates the underlying Tk menu the first time it's called for a given path (tearoff disabled) and just returns a handle to it on later calls, so it's safe to call again whenever you're about to rebuild a menu's entries (e.g. on every right-click). Every entry-mutating call — `add`, `insert`, `entryconfigure`, `delete` — tracks any `command:` callback and releases it when the entry is replaced, deleted, or the menu itself is destroyed. That's true whether you call it through the `Widget` handle (`menubar.command(:add, ...)`) or as a raw `app.command(path, :add, ...)`; both go through the same tracking, so there's no less-safe way to build a menu.
+
 > **macOS note:** On macOS, Tk always displays a menu bar. If you don't configure one, Tk shows a default menu with items like "Run Widget Demo" that are meant for the Tcl interpreter shell. Attach a custom menu bar (even an empty one) to suppress it. See the [TkDocs menu tutorial](https://tkdocs.com/tutorial/menus.html) for details.
 
+## Dialogs
+
+`App` has safe wrappers for the standard Tk dialogs — `choose_open_file`, `choose_save_file`, `message_box`, `choose_color`, and `popup_menu` — built without any string interpolation, so titles, paths, and messages containing spaces or braces are passed through correctly:
+
+```ruby
+path = app.choose_open_file(
+  title: 'Open Image',
+  filetypes: [['Images', ['.png', '.jpg']], ['All Files', '*']]
+)
+
+app.message_box(message: 'Really delete this?', type: :yesno, icon: :warning) # => :yes / :no
+```
+
+File/color pickers return `nil` when cancelled (an array of paths if `multiple: true`); `message_box` returns the pressed button as a symbol. See `sample/dialogs/dialogs_demo.rb` for a runnable demo of all five.
+
+## Window info
+
+`app.winfo` groups typed wrappers for Tk's `winfo` command family — one method per query, coerced to the right Ruby type:
+
+```ruby
+app.winfo.width(btn)      # => 90 (Integer)
+app.winfo.exists?(btn)    # => true / false
+app.winfo.class_name(btn) # => "TButton"
+app.winfo.pointerx        # => current mouse x, screen pixels
+```
+
+Every method accepts a path string or anything with a matching `to_s` (a `Widget`, for instance). `Widget` also has `#width`, `#height`, and `#exist?` convenience methods that delegate here for its own path.
+
 ## List operations
 
 Convert between Ruby arrays and Tcl list strings:

data/Rakefile

@@ -5,6 +5,82 @@ require 'rake/clean'
 # Sub-project Rakefiles (define sdl2:compile)
 import 'teek-sdl2/Rakefile'
 
+desc 'Run clang-tidy on C code'
+task :lint do
+  # Find clang-tidy binary
+  clang_tidy = nil
+
+  # Try system PATH first (Linux, or if user has llvm in PATH)
+  if system('which clang-tidy > /dev/null 2>&1')
+    clang_tidy = 'clang-tidy'
+  # On macOS, check Homebrew LLVM (keg-only, not in PATH by default)
+  elsif system('which brew > /dev/null 2>&1')
+    llvm_prefix = `brew --prefix llvm 2>/dev/null`.strip
+    clang_tidy = "#{llvm_prefix}/bin/clang-tidy" if !llvm_prefix.empty? && File.exist?("#{llvm_prefix}/bin/clang-tidy")
+  end
+
+  unless clang_tidy
+    abort("clang-tidy not installed.\n  " \
+          "macOS: brew install llvm\n  " \
+          "Ubuntu/Debian: apt-get install clang-tidy\n  " \
+          'Fedora/RHEL: dnf install clang-tools-extra')
+  end
+
+  puts 'Running clang-tidy on C code...'
+
+  # Find all .c files in ext/cataract/ and ext/cataract_color/
+  c_files = Dir.glob('ext/teek/**/*.c') + Dir.glob('teek-sdl2/ext/**/*.c')
+
+  # Run clang-tidy on each file
+  # Note: clang-tidy uses the .clang-tidy config file automatically
+  # We pass Ruby include path so it can find ruby.h
+  ruby_include = RbConfig::CONFIG['rubyhdrdir']
+  ruby_arch_include = RbConfig::CONFIG['rubyarchhdrdir']
+
+  # Without an explicit -I, clang-tidy falls back to whatever tcl.h/tk.h it
+  # finds on the default system search path - on macOS that's Apple's own
+  # ancient bundled Tcl/Tk 8.5 (symlinked into the Command Line Tools SDK),
+  # not the Homebrew tcl-tk this project actually builds against. That
+  # header unconditionally needs X11/Xlib.h, which isn't in the SDK -
+  # hence "file not found" even though the real build works fine.
+  # pkg-config points at the same tcl-tk include dir extconf.rb uses,
+  # which also bundles its own vendored X11 headers alongside tk.h, so no
+  # separate X11 lookup is needed.
+  tcltk_cflags = `pkg-config --cflags tcl tk 2>/dev/null`.strip.split
+  if tcltk_cflags.empty?
+    warn "Warning: pkg-config couldn't find tcl/tk - clang-tidy may pick up " \
+         "the wrong (or no) tcl.h/tk.h. Install tcl-tk via Homebrew/apt, or " \
+         "ensure pkg-config can see it."
+  end
+
+  # Same story for teek-sdl2: no explicit -I means clang-tidy won't find
+  # SDL2/SDL.h (and friends) at all, since SDL2 has no system-bundled
+  # fallback to silently misresolve to - it just fails outright.
+  sdl2_cflags = `pkg-config --cflags sdl2 SDL2_ttf SDL2_image SDL2_mixer 2>/dev/null`.strip.split
+  if sdl2_cflags.empty?
+    warn "Warning: pkg-config couldn't find SDL2 - clang-tidy will fail on " \
+         "teek-sdl2/ext/**/*.c. Install SDL2 (+ ttf/image/mixer) via " \
+         "Homebrew/apt, or ensure pkg-config can see it."
+  end
+
+  success = c_files.all? do |file|
+    puts "  Checking #{file}..."
+    system(clang_tidy, '--quiet', file, '--',
+           "-I#{ruby_include}",
+           "-I#{ruby_arch_include}",
+           '-Iext/teek',
+           '-Iteek-sdl2/ext',
+           *tcltk_cflags,
+           *sdl2_cflags)
+  end
+
+  if success
+    puts '✓ clang-tidy passed'
+  else
+    abort('clang-tidy found issues!')
+  end
+end
+
 # Documentation tasks - all doc gems are in docs_site/Gemfile
 namespace :docs do
   desc "Install docs dependencies (docs_site/Gemfile)"

data/ext/teek/tcltkbridge.c

@@ -584,6 +584,70 @@ interp_unregister_callback(VALUE self, VALUE id)
     return Qnil;
 }
 
+/* ---------------------------------------------------------
+ * Interp#callback_ids - Currently registered callback id strings
+ * (test/introspection use: asserting exactly which ids survive a
+ * release, not just how many)
+ * --------------------------------------------------------- */
+
+static VALUE
+interp_callback_ids(VALUE self)
+{
+    struct tcltk_interp *tip = get_interp(self);
+    return rb_funcall(tip->callbacks, rb_intern("keys"), 0);
+}
+
+/* ---------------------------------------------------------
+ * Raise Teek::TclError for a Tcl_Eval/Tcl_EvalObjv failure, attaching
+ * errorInfo/errorCode via Tcl_GetReturnOptions - the return options are
+ * tied to the specific result code just returned, not the mutable
+ * ::errorInfo/::errorCode globals, so this is safe even though it runs
+ * after control has already left Tcl_Eval/Tcl_EvalObjv.
+ * --------------------------------------------------------- */
+
+static VALUE
+tclobj_to_rb_str_or_nil(Tcl_Obj *obj)
+{
+    Tcl_Size len;
+    const char *str;
+
+    if (obj == NULL) return Qnil;
+    str = Tcl_GetStringFromObj(obj, &len);
+    return rb_utf8_str_new(str, len);
+}
+
+NORETURN(static void raise_tcl_error(Tcl_Interp *interp, int code));
+
+static void
+raise_tcl_error(Tcl_Interp *interp, int code)
+{
+    Tcl_Obj *options, *einfo_key, *ecode_key;
+    Tcl_Obj *einfo_val = NULL, *ecode_val = NULL;
+    VALUE msg, backtrace, error_code, exc;
+
+    options = Tcl_GetReturnOptions(interp, code);
+    Tcl_IncrRefCount(options);
+
+    einfo_key = Tcl_NewStringObj("-errorinfo", -1);
+    ecode_key = Tcl_NewStringObj("-errorcode", -1);
+    Tcl_IncrRefCount(einfo_key);
+    Tcl_IncrRefCount(ecode_key);
+
+    Tcl_DictObjGet(interp, options, einfo_key, &einfo_val);
+    Tcl_DictObjGet(interp, options, ecode_key, &ecode_val);
+
+    msg = rb_utf8_str_new_cstr(Tcl_GetStringResult(interp));
+    backtrace = tclobj_to_rb_str_or_nil(einfo_val);
+    error_code = tclobj_to_rb_str_or_nil(ecode_val);
+
+    Tcl_DecrRefCount(einfo_key);
+    Tcl_DecrRefCount(ecode_key);
+    Tcl_DecrRefCount(options);
+
+    exc = rb_funcall(eTclError, rb_intern("new"), 3, msg, backtrace, error_code);
+    rb_exc_raise(exc);
+}
+
 /* ---------------------------------------------------------
  * Thread-safe event queue: run Ruby proc on main Tcl thread
  *
@@ -606,7 +670,7 @@ execute_queued_eval(VALUE arg)
     int result = Tcl_Eval(tip->interp, script_cstr);
 
     if (result != TCL_OK) {
-        rb_raise(eTclError, "%s", Tcl_GetStringResult(tip->interp));
+        raise_tcl_error(tip->interp, result);
     }
     return rb_utf8_str_new_cstr(Tcl_GetStringResult(tip->interp));
 }
@@ -647,7 +711,7 @@ execute_queued_invoke(VALUE arg)
     }
 
     if (result != TCL_OK) {
-        rb_raise(eTclError, "%s", Tcl_GetStringResult(tip->interp));
+        raise_tcl_error(tip->interp, result);
     }
     return rb_utf8_str_new_cstr(Tcl_GetStringResult(tip->interp));
 }
@@ -818,7 +882,7 @@ interp_tcl_eval(VALUE self, VALUE script)
     result = Tcl_Eval(tip->interp, script_cstr);
 
     if (result != TCL_OK) {
-        rb_raise(eTclError, "%s", Tcl_GetStringResult(tip->interp));
+        raise_tcl_error(tip->interp, result);
     }
 
     return rb_utf8_str_new_cstr(Tcl_GetStringResult(tip->interp));
@@ -883,7 +947,7 @@ interp_tcl_invoke(int argc, VALUE *argv, VALUE self)
     }
 
     if (result != TCL_OK) {
-        rb_raise(eTclError, "%s", Tcl_GetStringResult(tip->interp));
+        raise_tcl_error(tip->interp, result);
     }
 
     ret = rb_utf8_str_new_cstr(Tcl_GetStringResult(tip->interp));
@@ -1504,6 +1568,7 @@ Init_tcltklib(void)
     rb_define_method(cInterp, "mainloop", interp_mainloop, 0);
     rb_define_method(cInterp, "register_callback", interp_register_callback, 1);
     rb_define_method(cInterp, "unregister_callback", interp_unregister_callback, 1);
+    rb_define_method(cInterp, "callback_ids", interp_callback_ids, 0);
     rb_define_method(cInterp, "create_slave", interp_create_slave, -1);
     rb_define_method(cInterp, "thread_timer_ms", interp_get_thread_timer_ms, 0);
     rb_define_method(cInterp, "thread_timer_ms=", interp_set_thread_timer_ms, 1);

data/ext/teek/tkdrop_x11.c

@@ -48,8 +48,8 @@ static int
 hex_decode(const char *s)
 {
     int hi, lo;
-    hi = s[0];
-    lo = s[1];
+    hi = (unsigned char)s[0];
+    lo = (unsigned char)s[1];
     if (hi >= '0' && hi <= '9') hi -= '0';
     else if (hi >= 'a' && hi <= 'f') hi = hi - 'a' + 10;
     else if (hi >= 'A' && hi <= 'F') hi = hi - 'A' + 10;

data/lib/teek/callback_registry.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Teek
+  # Tracks Ruby callback ids scoped to something narrower than a whole
+  # widget - keyed by (container, key) pairs - so they can be released
+  # again without waiting for a <Destroy> that may never come for the
+  # thing the callback is actually attached to (an event binding, a menu
+  # entry, ...). A single instance is shared across every feature that
+  # needs this; callers namespace their own container keys (by
+  # convention, [feature_tag, path] tuples) so two features tracking the
+  # same underlying path never collide.
+  #
+  # There is exactly one way to keep the registry in sync: {#reconcile}.
+  # Its block is handed the {key => id} hash tracked last time and must
+  # return the {key => id} hash that should be tracked now; whatever id
+  # drops out between the two gets released. What the block *does* with
+  # the hash it's handed is entirely up to the caller - reuse its values
+  # as a starting point for a cheap in-memory update (nothing external
+  # can silently change an event binding), or ignore it and recompute
+  # the truth from scratch by asking Tk (Tk silently renumbers menu
+  # entries, so nothing short of asking can be trusted there). The
+  # registry itself never knows or cares which one a caller chose.
+  #
+  # The one hard rule either way: the returned hash must be a DIFFERENT
+  # object from the one the block was handed - e.g. +before.merge(...)+,
+  # never +before.merge!(...)+ returned as-is. Released ids are computed
+  # as +before.values - after.values+; if the block mutates +before+ in
+  # place and returns that same object, +before+ and +after+ are
+  # identical by the time that subtraction runs, so any id that was
+  # dropped or replaced is silently never released - a leak, the exact
+  # thing this class exists to prevent.
+  #
+  # {#forget_all_for_path} is the only thing a <Destroy> handler needs to
+  # call: it releases every container ever registered under a path,
+  # regardless of which feature created it, via a reverse index built
+  # automatically as a side effect of {#reconcile}.
+  class CallbackRegistry
+    def initialize(app)
+      @app = app
+      @entries = Hash.new { |h, k| h[k] = {} }
+      @containers_by_path = Hash.new { |h, k| h[k] = Set.new }
+    end
+
+    # @yieldparam before [Hash] the {key => id} hash tracked for +container+
+    #   as of the last call (empty on the first call)
+    # @yieldreturn [Hash] the {key => id} hash that should be tracked now -
+    #   must be a different object from +before+ (see class docs above);
+    #   do not mutate +before+ in place and return it, or dropped/replaced
+    #   ids silently never get released
+    # @return [void]
+    def reconcile(container)
+      track(container)
+      before = @entries[container]
+      after = yield(before)
+      (before.values - after.values).each { |id| @app.unregister_callback(id) }
+      @entries[container] = after
+    end
+
+    # Release every callback tracked under any container registered for
+    # +path+, regardless of which feature created it, and forget them.
+    # @return [void]
+    def forget_all_for_path(path)
+      containers = @containers_by_path.delete(path)
+      return unless containers
+      containers.each do |container|
+        ids = @entries.delete(container)
+        ids&.each_value { |id| @app.unregister_callback(id) }
+      end
+    end
+
+    private
+
+    # Convention, not a type check: every container is [feature_tag, path].
+    def track(container)
+      @containers_by_path[container.last] << container
+    end
+  end
+end

data/lib/teek/canvas_bind_interceptor.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'command_interceptors'
+require_relative 'callback_registry'
+
+module Teek
+  # @api private
+  #
+  # Registered for the "canvas" {CommandInterceptors} entry below.
+  #
+  # Canvas items aren't windows (only the canvas itself is one), so a bound
+  # item's callback never fires <Destroy> on its own, and `canvas delete`
+  # is silent - the same leak shape menu entries have. Unlike menu or
+  # text/treeview tags, canvas has no "list every live binding" enumeration
+  # command (no analogue to menu's `index end` or text's `tag names`), so
+  # this can't do a full-scan reconcile. Instead it re-queries only the
+  # (tagOrId, sequence) keys it already knows about - via `canvas bind
+  # tagOrId sequence`, the 2-arg read form - after every bind/delete call,
+  # and lets whatever no longer resolves drop out.
+  #
+  # A binding on a numeric item id is released this way once that item is
+  # deleted (Tk's Tk_DeleteAllBindings clears its binding-table entries
+  # along with it). A binding on a tag is NOT released by deleting a
+  # tagged item - the tag itself isn't an item, so its binding-table entry
+  # persists independent of which (if any) items currently carry that tag.
+  module CanvasBindInterceptor
+    MUTATING_SUBCOMMANDS = %w[bind delete].freeze
+
+    def self.call(app, path, args, kwargs)
+      sub = args[0]&.to_s
+      return nil unless MUTATING_SUBCOMMANDS.include?(sub)
+
+      result = app.raw_command(path, *args, **kwargs)
+      app.callback_registry.reconcile([:canvas_bind, path]) { |before| requery(app, path, before, sub, args) }
+      result
+    end
+
+    def self.requery(app, path, before, sub, args)
+      keys = before.keys
+      keys += [[args[1].to_s, args[2].to_s]] if sub == 'bind' && args.length >= 4
+
+      keys.uniq.each_with_object({}) do |(tag_or_id, seq), after|
+        # Unlike a tag (a plain Tcl string, always a valid query target even
+        # if nothing currently carries it), a numeric item id is a hash key
+        # into the canvas's item table - querying one after its item is
+        # deleted raises "item \"N\" doesn't exist" rather than returning
+        # empty, so a deleted item's binding has to be dropped via rescue,
+        # not by checking the result.
+        current = begin
+          app.tcl_eval("#{path} bind #{tag_or_id} #{seq}")
+        rescue Teek::TclError
+          ''
+        end
+        # \z anchors this to a BARE `ruby_callback <id>` with nothing
+        # after. raw_command's generic positional-Proc handling
+        # technically allows a caller to pass %-substitutions to a
+        # canvas-bind-shaped app.command call (the same mechanism
+        # App#bind uses), but nothing in teek does that today. If a
+        # caller ever does, this regex silently stops matching and that
+        # id leaks on rebuild/delete - drop the \z anchor (match just
+        # the leading `ruby_callback <id>`) if that changes.
+        after[[tag_or_id, seq]] = Regexp.last_match(1) if current =~ /\Aruby_callback (\S+)\z/
+      end
+    end
+  end
+
+  CommandInterceptors.register('canvas', 'canvas_bind') { |*a| CanvasBindInterceptor.call(*a) }
+end

data/lib/teek/command_interceptors.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Teek
+  # @api private
+  #
+  # Registry of per-Tk-widget-type interceptors that App#command consults
+  # before falling back to its own generic handling. Each interceptor is a
+  # labeled block registered under a widget type string (the same strings
+  # used in WIDGET_COMMANDS); App#command looks up the type for the path it
+  # was given (see App#record_widget_type) and tries every interceptor
+  # registered for that type.
+  #
+  # An interceptor block receives (app, path, args, kwargs) and must
+  # return nil if this call isn't its concern - Tcl results from
+  # App#raw_command are always Strings, never nil, so nil is an
+  # unambiguous "not mine" sentinel - or the Tcl result if it handled the
+  # call itself (typically by calling App#raw_command internally).
+  #
+  # Multiple widget types can share the same interceptor logic (text and
+  # ttk::treeview tag bindings are byte-identical in Tcl shape) by
+  # registering the same block under each type. The +label+ is what
+  # App#command reports if two DIFFERENT interceptors both claim the same
+  # call for the same type - it raises AmbiguousCommandError naming both
+  # labels rather than silently picking one, so whoever's debugging can
+  # tell which interceptors collided (built-in shape-matching bug, a
+  # custom interceptor overlapping a built-in one, two custom interceptors
+  # overlapping each other, ...).
+  class CommandInterceptors
+    Entry = Struct.new(:label, :block)
+
+    class << self
+      def register(type, label, &block)
+        interceptors[type.to_s] << Entry.new(label.to_s, block)
+      end
+
+      def for_type(type)
+        interceptors[type.to_s]
+      end
+
+      private
+
+      def interceptors
+        @interceptors ||= Hash.new { |h, k| h[k] = [] }
+      end
+    end
+  end
+end

data/lib/teek/debugger.rb

@@ -27,8 +27,7 @@ module Teek
       app.command(:wm, 'geometry', TOP, '400x500')
 
       # Don't let closing the debugger kill the app
-      close_proc = proc { |*| app.command(:wm, 'withdraw', TOP) }
-      app.command(:wm, 'protocol', TOP, 'WM_DELETE_WINDOW', close_proc)
+      app.on_close(window: TOP) { app.command(:wm, 'withdraw', TOP) }
 
       setup_ui
       sync_widget_tree
@@ -246,10 +245,9 @@ module Teek
       @app.command(:pack, vars_tree, fill: :both, expand: 1)
 
       # Right-click context menu
-      @app.command(:menu, "#{NB}.vars.ctx", tearoff: 0)
+      vars_ctx = @app.menu("#{NB}.vars.ctx")
       watch_proc = proc { |*| watch_selected_variable }
-      @app.command("#{NB}.vars.ctx", 'add', 'command',
-        label: 'Watch', command: watch_proc)
+      vars_ctx.command(:add, :command, label: 'Watch', command: watch_proc)
 
       @app.command(:bind, vars_tree, '<Button-3>', proc { |*|
         # Select the row under cursor, then show context menu
@@ -257,7 +255,7 @@ module Teek
           set item [#{vars_tree} identify item [winfo pointerx #{vars_tree}] [winfo pointery #{vars_tree}]]
           if {$item ne {}} { #{vars_tree} selection set $item }
         ")
-        @app.tcl_eval("tk_popup #{NB}.vars.ctx [winfo pointerx .] [winfo pointery .]")
+        @app.popup_menu(vars_ctx, x: @app.winfo.pointerx, y: @app.winfo.pointery)
       })
 
       # Double-click to watch
@@ -530,17 +528,16 @@ module Teek
       @app.command(:bind, watch_tree, '<<TreeviewSelect>>', select_proc)
 
       # Right-click to unwatch
-      @app.command(:menu, "#{NB}.watches.ctx", tearoff: 0)
+      watches_ctx = @app.menu("#{NB}.watches.ctx")
       unwatch_proc = proc { |*| unwatch_selected }
-      @app.command("#{NB}.watches.ctx", 'add', 'command',
-        label: 'Unwatch', command: unwatch_proc)
+      watches_ctx.command(:add, :command, label: 'Unwatch', command: unwatch_proc)
 
       @app.command(:bind, watch_tree, '<Button-3>', proc { |*|
         @app.tcl_eval("
           set item [#{watch_tree} identify item [winfo pointerx #{watch_tree}] [winfo pointery #{watch_tree}]]
           if {$item ne {}} { #{watch_tree} selection set $item }
         ")
-        @app.tcl_eval("tk_popup #{NB}.watches.ctx [winfo pointerx .] [winfo pointery .]")
+        @app.popup_menu(watches_ctx, x: @app.winfo.pointerx, y: @app.winfo.pointery)
       })
     end
 

data/lib/teek/demo_support.rb

@@ -94,8 +94,8 @@ module TeekDemo
 
       try_signal = proc do
         app.tcl_eval('update idletasks')
-        width = app.tcl_eval("winfo width #{window}").to_i
-        height = app.tcl_eval("winfo height #{window}").to_i
+        width = app.winfo.width(window)
+        height = app.winfo.height(window)
 
         if width >= 10 && height >= 10
           @_recording_ready_sent = true