teek 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fe2f5c480c472d6479ac1b92088a748e1216cb1a15472e9e98fbd3c2e4fd347
-  data.tar.gz: c4d2da92180136ca756955258ea59402b27b9019e9d492f0969a7c346dcc053a
+  metadata.gz: 7fdcad5500b3501e3d2b83d29678b76f8cc043b2f44e5e0af66a300fd8fa03ac
+  data.tar.gz: ca0b209ebe033d7e246271bda5491c8192279e063fdb5e45f2bb719fcd0cb5dc
 SHA512:
-  metadata.gz: 6a10e7f92ca08b1385288829cf0188beb408c90cdf52aecb30a36652f2b299954318c4b3a64434ea0158950f05e105db5a289c115dab4506fa91b7ab6e70f26e
-  data.tar.gz: 7cd908cf513d6f92cad5c89d04cb49f7bf3fb3e9d7868af4d0d0fbb7db04e2a7a712c3e6e1e2fd107fd4df4b84140b49d720b2357cc9b9452067a8f5b7bfe2f6
+  metadata.gz: d69b03be50a1ad912ba7f8f0610ae7ba6163b19bc342a9f763112a467ddef39f2b8d0e5e2317463c91096d02674f6641d345370c35c09b71f37055d40ceab926
+  data.tar.gz: b720547bd7a11f6a3f7c15ec33c78d2c86c42e80ea9b273dd50803e5d2012c6dd286ae2ebd30275ca9b85eaa26866da00df8d0982a21cde97361d8fa98a1df10

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in teek.gemspec
 gemspec
+
+gem 'rubyzip', '>= 2.4', '< 4'

data/README.md

@@ -102,6 +102,27 @@ Two other control flow signals are available for advanced use:
 
 If a callback raises a Ruby exception, it becomes a Tcl error. The exception message is preserved and can be caught on the Tcl side with `catch`.
 
+## Menus
+
+Build a menu bar with standard `menu` widgets:
+
+```ruby
+app = Teek::App.new(title: 'My App')
+
+app.command(: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, '.') })
+
+app.show
+app.mainloop
+```
+
+> **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.
+
 ## List operations
 
 Convert between Ruby arrays and Tcl list strings:
@@ -221,3 +242,29 @@ task.stop    # Stop completely
 The work block runs in a background Ractor and cannot access Tk directly. Use `t.yield()` to send results to `on_progress`, which runs on the main thread where Tk is available. Callbacks (`on_progress`, `on_done`) can be chained in any order.
 
 See [`sample/threading_demo.rb`](sample/threading_demo.rb) for a complete file hasher example.
+
+## File Drop Target
+
+Register any widget as a file drop target to receive OS-native drag-and-drop:
+
+```ruby
+app = Teek::App.new(title: "Drop Demo")
+app.show
+
+app.register_drop_target('.')
+
+app.bind('.', '<<DropFile>>', :data) do |data|
+  paths = app.split_list(data)
+  puts "Dropped: #{paths.inspect}"
+end
+
+app.mainloop
+```
+
+Dropped files arrive as a Tcl list in the `:data` substitution. Use `split_list` to get a Ruby array of paths. Works on macOS (Cocoa), Windows (OLE IDropTarget), and Linux (X11 XDND).
+
+See [`sample/drop_demo.rb`](sample/drop_demo.rb) for a complete example.
+
+## Known Issues
+
+- **File drop on Linux/Wayland** — `register_drop_target` does not yet work under Wayland. The current implementation uses the X11 XDND protocol, which is not compatible with Wayland's native drag-and-drop. Workaround: select an Xorg/X11 session at the login screen (e.g., "GNOME on Xorg"). Native Wayland support via `wl_data_device` is planned.

data/Rakefile

@@ -2,6 +2,9 @@ require "bundler/gem_tasks"
 require 'rake/testtask'
 require 'rake/clean'
 
+# Sub-project Rakefiles (define sdl2:compile)
+import 'teek-sdl2/Rakefile'
+
 # Documentation tasks - all doc gems are in docs_site/Gemfile
 namespace :docs do
   desc "Install docs dependencies (docs_site/Gemfile)"
@@ -112,20 +115,15 @@ CLOBBER.include('teek-sdl2/lib/*.bundle', 'teek-sdl2/lib/*.so', 'teek-sdl2/ext/*
 # Clean coverage artifacts before test runs to prevent accumulation
 CLEAN.include('coverage/.resultset.json', 'coverage/results')
 
-# Conditionally load rake-compiler
+# rake compile = teek core only (tcltklib)
 if Gem::Specification.find_all_by_name('rake-compiler').any?
   require 'rake/extensiontask'
+
   Rake::ExtensionTask.new do |ext|
     ext.name = 'tcltklib'
     ext.ext_dir = 'ext/teek'
     ext.lib_dir = 'lib'
   end
-
-  Rake::ExtensionTask.new do |ext|
-    ext.name = 'teek_sdl2'
-    ext.ext_dir = 'teek-sdl2/ext/teek_sdl2'
-    ext.lib_dir = 'teek-sdl2/lib'
-  end
 end
 
 namespace :screenshots do
@@ -209,55 +207,55 @@ end
 
 task test: [:compile, :clean_coverage]
 
-def detect_platform
-  case RUBY_PLATFORM
-  when /darwin/ then 'darwin'
-  when /linux/ then 'linux'
-  when /mingw|mswin/ then 'windows'
-  else 'unknown'
-  end
-end
-
 namespace :sdl2 do
-  desc "Compile teek-sdl2 C extension"
-  task compile: 'compile:teek_sdl2'
-
   Rake::TestTask.new(:test) do |t|
     t.libs << 'teek-sdl2/test' << 'teek-sdl2/lib'
     t.test_files = FileList['teek-sdl2/test/**/test_*.rb'] - FileList['teek-sdl2/test/test_helper.rb']
     t.ruby_opts << '-r test_helper'
     t.verbose = true
   end
-  task test: 'compile:teek_sdl2'
+  task test: 'sdl2:compile'
 end
 
 task :default => :compile
 
 namespace :release do
-  desc "Build gems, install to temp dir, run smoke test"
+  desc "Clean-slate smoke test: clobber, build gems, install fresh, verify"
   task :smoke do
     require 'tmpdir'
     require 'fileutils'
 
+    # Clean slate — nuke compiled extensions so nothing local leaks in
+    puts "Clobbering local build artifacts..."
+    Rake::Task['clobber'].invoke
+    Rake::Task['sdl2:clobber'].invoke
+
     Dir.mktmpdir('teek-smoke') do |tmpdir|
       gem_home = File.join(tmpdir, 'gems')
 
       # Build both gems
-      puts "Building gems..."
+      puts "\nBuilding gems..."
       sh "gem build teek.gemspec -o #{tmpdir}/teek.gem 2>&1"
       Dir.chdir('teek-sdl2') { sh "gem build teek-sdl2.gemspec -o #{tmpdir}/teek-sdl2.gem 2>&1" }
 
-      # Install into isolated GEM_HOME
-      puts "\nInstalling gems..."
+      # Install into isolated GEM_HOME (no system gems, no stale versions)
+      puts "\nInstalling gems into #{gem_home}..."
       sh "GEM_HOME=#{gem_home} gem install #{tmpdir}/teek.gem --no-document 2>&1"
       sh "GEM_HOME=#{gem_home} gem install #{tmpdir}/teek-sdl2.gem --no-document 2>&1"
 
       # Run smoke test using only the installed gems (no -I, no bundle)
-      puts "\nRunning SDL2 smoke test..."
+      puts "\nRunning smoke test..."
       smoke = <<~'RUBY'
         require "teek"
         require "teek/sdl2"
 
+        # Verify native extensions loaded from gem path, not local source
+        %w[tcltklib teek_sdl2].each do |ext|
+          path = $LOADED_FEATURES.find { |f| f.include?(ext) && f.end_with?(".bundle", ".so", ".dll") }
+          abort "#{ext}: native extension not found in $LOADED_FEATURES" unless path
+          abort "#{ext}: loaded from local source (#{path}), not installed gem" if path.include?("/ext/")
+        end
+
         app = Teek::App.new
         app.set_window_title("Release Smoke Test")
         app.set_window_geometry("320x240")
@@ -266,6 +264,7 @@ namespace :release do
 
         vp = Teek::SDL2::Viewport.new(app, width: 300, height: 200)
         vp.pack
+        app.update
 
         vp.render do |r|
           r.clear(30, 30, 30)
@@ -280,7 +279,7 @@ namespace :release do
 
         app.after(500) { vp.destroy; app.destroy }
         app.mainloop
-        puts "Release smoke test passed (teek #{Teek::VERSION}, teek-sdl2 #{Teek::SDL2::VERSION})"
+        puts "release:smoke OK — teek #{Teek::VERSION}, teek-sdl2 #{Teek::SDL2::VERSION}"
       RUBY
 
       smoke_file = File.join(tmpdir, 'smoke.rb')
@@ -301,6 +300,15 @@ namespace :docker do
     ruby_version == '4.0' ? base : "#{base}-ruby#{ruby_version}"
   end
 
+  def warn_if_containers_running(image_name)
+    running = `docker ps --filter ancestor=#{image_name} --format '{{.ID}} {{.Status}}'`.strip
+    return if running.empty?
+    count = running.lines.size
+    warn "\n⚠  #{count} container(s) already running on #{image_name}:"
+    running.lines.each { |l| warn "   #{l.strip}" }
+    warn "   This usually means a previous test suite is stuck. Consider: docker kill $(docker ps -q --filter ancestor=#{image_name})\n"
+  end
+
   def tcl_version_from_env
     version = ENV.fetch('TCL_VERSION', '9.0')
     unless ['8.6', '9.0'].include?(version)
@@ -345,6 +353,8 @@ namespace :docker do
     require 'fileutils'
     FileUtils.mkdir_p('coverage')
 
+    warn_if_containers_running(image_name)
+
     puts "Running tests in Docker (Ruby #{ruby_version}, Tcl #{tcl_version})..."
     cmd = "docker run --rm --init"
     cmd += " -v #{Dir.pwd}/coverage:/app/coverage"
@@ -374,6 +384,22 @@ namespace :docker do
     sh cmd
   end
 
+  desc "Force rebuild Docker image (no cache)"
+  task :rebuild do
+    tcl_version = tcl_version_from_env
+    ruby_version = ruby_version_from_env
+    image_name = docker_image_name(tcl_version, ruby_version)
+
+    puts "Rebuilding Docker image (no cache) for Ruby #{ruby_version}, Tcl #{tcl_version}..."
+    cmd = "docker build -f #{DOCKERFILE} --no-cache"
+    cmd += " --label #{DOCKER_LABEL}"
+    cmd += " --build-arg RUBY_VERSION=#{ruby_version}"
+    cmd += " --build-arg TCL_VERSION=#{tcl_version}"
+    cmd += " -t #{image_name} ."
+
+    sh cmd
+  end
+
   desc "Remove dangling Docker images from teek builds"
   task :prune do
     sh "docker image prune -f --filter label=#{DOCKER_LABEL}"
@@ -391,6 +417,8 @@ namespace :docker do
       require 'fileutils'
       FileUtils.mkdir_p('coverage')
 
+      warn_if_containers_running(image_name)
+
       puts "Running teek-sdl2 tests in Docker (Ruby #{ruby_version}, Tcl #{tcl_version})..."
       cmd = "docker run --rm --init"
       cmd += " -v #{Dir.pwd}/coverage:/app/coverage"
@@ -416,7 +444,7 @@ namespace :docker do
       FileUtils.rm_rf('coverage')
       FileUtils.mkdir_p('coverage/results')
 
-      # Run both test suites with coverage enabled and distinct COVERAGE_NAMEs
+      # Run all three test suites with coverage enabled and distinct COVERAGE_NAMEs
       ENV['COVERAGE'] = '1'
 
       ENV['COVERAGE_NAME'] = 'main'

data/ext/teek/extconf.rb

@@ -26,6 +26,21 @@ def find_tcltk
       if File.exist?("#{inc}/tcl-tk/tcl.h")
         inc = "#{inc}/tcl-tk"
       end
+
+      # Check for versioned subdirectories (Debian/Ubuntu layout:
+      # /usr/include/tcl9.0/tcl.h, /usr/include/tcl8.6/tcl.h)
+      unless File.exist?("#{inc}/tcl.h")
+        versioned = Dir.glob("#{inc}/tcl*/tcl.h").max
+        if versioned
+          tcl_ver_dir = File.dirname(versioned)
+          tk_ver_dir = tcl_ver_dir.sub(/tcl/, 'tk')
+          $INCFLAGS << " -I#{tcl_ver_dir}"
+          $INCFLAGS << " -I#{tk_ver_dir}" if File.directory?(tk_ver_dir)
+          $LDFLAGS << " -L#{lib}"
+          break
+        end
+      end
+
       if File.exist?("#{inc}/tcl.h") && File.exist?("#{inc}/tk.h")
         $INCFLAGS << " -I#{inc}"
         $LDFLAGS << " -L#{lib}"
@@ -69,11 +84,29 @@ def find_tcltk
 
   abort "Tcl stub library not found" unless tcl_stub
   abort "Tk stub library not found" unless tk_stub
+
+  # Also link the real Tcl shared library so it's loaded at runtime.
+  # Some distros (e.g. Fedora) ship Tcl symbols in a separate .so that
+  # stubs alone don't pull in, causing dlsym() to fail at bootstrap.
+  have_library('tcl9.0') || have_library('tcl8.6') || have_library('tcl')
 end
 
 find_tcltk
 
 # Source files for the extension
-$srcs = ['tcltkbridge.c', 'tkphoto.c', 'tkfont.c', 'tkwin.c', 'tkeventsource.c']
+$srcs = ['tcltkbridge.c', 'tkphoto.c', 'tkfont.c', 'tkwin.c', 'tkeventsource.c', 'tkdrop.c']
+
+# Platform-specific file drop target
+case RbConfig::CONFIG['host_os']
+when /darwin/
+  $srcs << 'tkdrop_macos.m'
+  $LDFLAGS << ' -framework Cocoa'
+when /mingw|mswin|cygwin/
+  $srcs << 'tkdrop_win.c'
+  have_library('ole32')
+  have_library('shell32')
+else
+  $srcs << 'tkdrop_x11.c'
+end
 
 create_makefile('tcltklib')

data/ext/teek/tcltkbridge.c

@@ -59,6 +59,39 @@ static void *get_tcl_proc(const char *name)
 }
 #endif
 
+/* Try to dlopen the real Tcl shared library if it's not already loaded.
+ * Some distros (e.g. Fedora) ship Tcl/Tk in separate .so files and only
+ * the Tk combined library gets pulled in via stubs, leaving Tcl_CreateInterp
+ * unresolvable via RTLD_DEFAULT. */
+#ifndef _WIN32
+static void *tcl_dlhandle = NULL;
+
+static void *
+dlsym_tcl(const char *name)
+{
+    void *sym = dlsym(RTLD_DEFAULT, name);
+    if (sym) return sym;
+
+    /* Try loading the real Tcl library explicitly */
+    if (!tcl_dlhandle) {
+        static const char *lib_names[] = {
+            "libtcl9.0.so", "libtcl8.6.so",
+            "libtcl9.0.dylib", "libtcl8.6.dylib",
+            NULL
+        };
+        int i;
+        for (i = 0; lib_names[i]; i++) {
+            tcl_dlhandle = dlopen(lib_names[i], RTLD_NOW | RTLD_GLOBAL);
+            if (tcl_dlhandle) break;
+        }
+    }
+    if (tcl_dlhandle) {
+        sym = dlsym(tcl_dlhandle, name);
+    }
+    return sym;
+}
+#endif
+
 static void
 find_executable_bootstrap(const char *argv0)
 {
@@ -71,7 +104,7 @@ find_executable_bootstrap(const char *argv0)
 #ifdef _WIN32
     real_find_executable = (void (*)(const char *))get_tcl_proc("Tcl_FindExecutable");
 #else
-    real_find_executable = dlsym(RTLD_DEFAULT, "Tcl_FindExecutable");
+    real_find_executable = dlsym_tcl("Tcl_FindExecutable");
 #endif
     if (real_find_executable) {
         real_find_executable(argv0);
@@ -89,7 +122,7 @@ create_interp_bootstrap(void)
 #ifdef _WIN32
     real_create_interp = (Tcl_Interp *(*)(void))get_tcl_proc("Tcl_CreateInterp");
 #else
-    real_create_interp = dlsym(RTLD_DEFAULT, "Tcl_CreateInterp");
+    real_create_interp = dlsym_tcl("Tcl_CreateInterp");
 #endif
     if (!real_create_interp) {
         return NULL;
@@ -1490,6 +1523,9 @@ Init_tcltklib(void)
     /* External event source integration (tkeventsource.c) */
     Init_tkeventsource(mTeek);
 
+    /* File drop target support (tkdrop.c) */
+    Init_tkdrop(cInterp);
+
     /* Class methods for instance tracking */
     rb_define_singleton_method(cInterp, "instance_count", tcltkip_instance_count, 0);
     rb_define_singleton_method(cInterp, "instances", tcltkip_instances, 0);

data/ext/teek/tcltkbridge.h

@@ -42,4 +42,7 @@ void Init_tkwin(VALUE cInterp);
 /* External event source integration - defined in tkeventsource.c */
 void Init_tkeventsource(VALUE mTeek);
 
+/* File drop target support - defined in tkdrop.c */
+void Init_tkdrop(VALUE cInterp);
+
 #endif /* TCLTKBRIDGE_H */

data/ext/teek/tkdrop.c

@@ -0,0 +1,66 @@
+/* tkdrop.c - File drop target support (common entry point)
+ *
+ * Provides Interp#register_drop_target(window_path) which delegates
+ * to platform-specific teek_register_drop_target().
+ *
+ * Based on tkdnd (https://github.com/petasis/tkdnd) as reference.
+ */
+
+#include "tcltkbridge.h"
+#include "tkdrop.h"
+
+/* ---------------------------------------------------------
+ * Interp#register_drop_target(window_path)
+ *
+ * Register a Tk widget as a native file drop target.
+ * After registration, dropping a file onto the widget generates
+ * a <<DropFile>> virtual event with the file path in -data.
+ *
+ * Arguments:
+ *   window_path - Tk widget path (e.g., ".", ".frame")
+ *
+ * Returns: nil
+ * --------------------------------------------------------- */
+
+static VALUE
+interp_register_drop_target(VALUE self, VALUE window_path)
+{
+    struct tcltk_interp *tip = get_interp(self);
+    Tk_Window mainWin;
+    Tk_Window tkwin;
+    int result;
+
+    StringValue(window_path);
+
+    mainWin = Tk_MainWindow(tip->interp);
+    if (!mainWin) {
+        rb_raise(eTclError, "Tk not initialized (no main window)");
+    }
+
+    tkwin = Tk_NameToWindow(tip->interp, StringValueCStr(window_path), mainWin);
+    if (!tkwin) {
+        rb_raise(eTclError, "window not found: %s", StringValueCStr(window_path));
+    }
+
+    Tk_MakeWindowExist(tkwin);
+
+    result = teek_register_drop_target(tip->interp, tkwin, StringValueCStr(window_path));
+    if (result != TCL_OK) {
+        rb_raise(eTclError, "failed to register drop target: %s",
+                 Tcl_GetStringResult(tip->interp));
+    }
+
+    return Qnil;
+}
+
+/* ---------------------------------------------------------
+ * Init_tkdrop - Register drop target methods on Interp
+ *
+ * Called from Init_tcltklib in tcltkbridge.c.
+ * --------------------------------------------------------- */
+
+void
+Init_tkdrop(VALUE cInterp)
+{
+    rb_define_method(cInterp, "register_drop_target", interp_register_drop_target, 1);
+}

data/ext/teek/tkdrop.h

@@ -0,0 +1,26 @@
+/* tkdrop.h - Native file drop target support
+ *
+ * Cross-platform abstraction for registering Tk widgets as file drop targets.
+ * Each platform implements teek_register_drop_target() which hooks into the
+ * OS drag-and-drop system and generates <<DropFile>> virtual events.
+ *
+ * Based on tkdnd (https://github.com/petasis/tkdnd) as reference.
+ * See THIRD_PARTY_NOTICES for attribution.
+ */
+
+#ifndef TKDROP_H
+#define TKDROP_H
+
+#include <tcl.h>
+#include <tk.h>
+
+/*
+ * Register a Tk window as a file drop target.
+ * When a file is dropped, generates <<DropFile>> with -data set to the path.
+ *
+ * Returns TCL_OK on success, TCL_ERROR on failure (with error in interp).
+ */
+int teek_register_drop_target(Tcl_Interp *interp, Tk_Window tkwin,
+                              const char *widget_path);
+
+#endif /* TKDROP_H */

data/ext/teek/tkdrop_macos.m

@@ -0,0 +1,141 @@
+/* tkdrop_macos.m - macOS file drop target via Cocoa NSDraggingDestination
+ *
+ * Based on tkdnd (https://github.com/petasis/tkdnd) as reference.
+ * See THIRD_PARTY_NOTICES for attribution.
+ */
+
+#import <Cocoa/Cocoa.h>
+#include <tcl.h>
+#include <tk.h>
+#include "tkdrop.h"
+
+#ifndef MAC_OSX_TK
+#define MAC_OSX_TK
+#endif
+#include "tkPlatDecls.h"
+
+/* --------------------------------------------------------- */
+
+@interface TeekDropView : NSView <NSDraggingDestination>
+{
+    Tcl_Interp *_interp;
+    char *_widgetPath;
+}
+- (instancetype)initWithFrame:(NSRect)frame
+                       interp:(Tcl_Interp *)interp
+                   widgetPath:(const char *)widgetPath;
+@end
+
+@implementation TeekDropView
+
+- (instancetype)initWithFrame:(NSRect)frame
+                       interp:(Tcl_Interp *)interp
+                   widgetPath:(const char *)widgetPath
+{
+    self = [super initWithFrame:frame];
+    if (self) {
+        _interp = interp;
+        _widgetPath = strdup(widgetPath);
+        [self setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
+        [self registerForDraggedTypes:@[NSPasteboardTypeFileURL]];
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    free(_widgetPath);
+    [super dealloc];
+}
+
+- (NSDragOperation)draggingEntered:(id<NSDraggingInfo>)sender
+{
+    NSPasteboard *pb = [sender draggingPasteboard];
+    if ([pb canReadObjectForClasses:@[[NSURL class]]
+                            options:@{NSPasteboardURLReadingFileURLsOnlyKey: @YES}]) {
+        return NSDragOperationCopy;
+    }
+    return NSDragOperationNone;
+}
+
+- (BOOL)performDragOperation:(id<NSDraggingInfo>)sender
+{
+    NSPasteboard *pb = [sender draggingPasteboard];
+    NSArray<NSURL *> *urls = [pb readObjectsForClasses:@[[NSURL class]]
+                                               options:@{NSPasteboardURLReadingFileURLsOnlyKey: @YES}];
+    if (!urls || [urls count] == 0) {
+        return NO;
+    }
+
+    /* Build a Tcl list of all dropped file paths */
+    Tcl_Obj *listObj = Tcl_NewListObj(0, NULL);
+    Tcl_IncrRefCount(listObj);
+
+    for (NSURL *url in urls) {
+        NSString *path = [url path];
+        if (!path) continue;
+        Tcl_ListObjAppendElement(NULL, listObj,
+            Tcl_NewStringObj([path UTF8String], -1));
+    }
+
+    /* Generate single <<DropFile>> event with all paths as a Tcl list */
+    Tcl_Obj *script = Tcl_ObjPrintf(
+        "event generate %s <<DropFile>> -data {%s}",
+        _widgetPath, Tcl_GetString(listObj));
+    Tcl_IncrRefCount(script);
+    Tcl_EvalObjEx(_interp, script, TCL_EVAL_GLOBAL);
+    Tcl_DecrRefCount(script);
+    Tcl_DecrRefCount(listObj);
+
+    return YES;
+}
+
+/* Allow the drop view to be transparent to mouse events when not dragging */
+- (NSView *)hitTest:(NSPoint)point
+{
+    return nil;
+}
+
+@end
+
+/* --------------------------------------------------------- */
+
+int
+teek_register_drop_target(Tcl_Interp *interp, Tk_Window tkwin,
+                          const char *widget_path)
+{
+    Drawable drawable = Tk_WindowId(tkwin);
+    if (!drawable) {
+        Tcl_SetResult(interp, "window has no native handle", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    void *nswindow = Tk_MacOSXGetNSWindowForDrawable(drawable);
+    if (!nswindow) {
+        Tcl_SetResult(interp, "could not get NSWindow", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    NSWindow *window = (__bridge NSWindow *)nswindow;
+    NSView *contentView = [window contentView];
+    if (!contentView) {
+        Tcl_SetResult(interp, "could not get content view", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    /* Check if we already registered a drop view on this window */
+    for (NSView *subview in [contentView subviews]) {
+        if ([subview isKindOfClass:[TeekDropView class]]) {
+            return TCL_OK; /* Already registered */
+        }
+    }
+
+    TeekDropView *dropView = [[TeekDropView alloc]
+        initWithFrame:[contentView bounds]
+               interp:interp
+           widgetPath:widget_path];
+
+    [contentView addSubview:dropView];
+
+    return TCL_OK;
+}