teek 0.1.3 → 0.1.4

data/ext/teek/tkdrop_win.c

@@ -0,0 +1,232 @@
+/* tkdrop_win.c - Windows file drop target via OLE IDropTarget
+ *
+ * Uses the OLE drag-and-drop API (RegisterDragDrop/IDropTarget) for
+ * flexible drop support. Extracts file paths from CF_HDROP format and
+ * generates <<DropFile>> virtual events.
+ *
+ * Based on tkdnd (https://github.com/petasis/tkdnd) as reference.
+ * See THIRD_PARTY_NOTICES for attribution.
+ */
+
+#include <tcl.h>
+#include <tk.h>
+#include "tkdrop.h"
+
+#ifdef _WIN32
+
+#define COBJMACROS
+#include <initguid.h>
+#include <windows.h>
+#include <ole2.h>
+#include <shlobj.h>
+#include <shellapi.h>
+#include "tkPlatDecls.h"
+
+/* --------------------------------------------------------- */
+/* IDropTarget implementation in C via COM vtable             */
+/* --------------------------------------------------------- */
+
+typedef struct TeekDropTarget {
+    IDropTargetVtbl *lpVtbl;
+    LONG ref_count;
+    Tcl_Interp *interp;
+    char *widget_path;
+    HWND hwnd;
+} TeekDropTarget;
+
+static HRESULT STDMETHODCALLTYPE
+tdt_QueryInterface(IDropTarget *self, REFIID riid, void **ppv)
+{
+    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDropTarget)) {
+        *ppv = self;
+        IDropTarget_AddRef(self);
+        return S_OK;
+    }
+    *ppv = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG STDMETHODCALLTYPE
+tdt_AddRef(IDropTarget *self)
+{
+    TeekDropTarget *tdt = (TeekDropTarget *)self;
+    return InterlockedIncrement(&tdt->ref_count);
+}
+
+static ULONG STDMETHODCALLTYPE
+tdt_Release(IDropTarget *self)
+{
+    TeekDropTarget *tdt = (TeekDropTarget *)self;
+    LONG count = InterlockedDecrement(&tdt->ref_count);
+    if (count == 0) {
+        free(tdt->widget_path);
+        free(tdt);
+    }
+    return count;
+}
+
+/* Check if the drag contains files */
+static BOOL
+has_file_data(IDataObject *pDataObj)
+{
+    FORMATETC fmt = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+    return IDataObject_QueryGetData(pDataObj, &fmt) == S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE
+tdt_DragEnter(IDropTarget *self, IDataObject *pDataObj, DWORD grfKeyState,
+              POINTL pt, DWORD *pdwEffect)
+{
+    if (has_file_data(pDataObj)) {
+        *pdwEffect = DROPEFFECT_COPY;
+    } else {
+        *pdwEffect = DROPEFFECT_NONE;
+    }
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE
+tdt_DragOver(IDropTarget *self, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
+{
+    *pdwEffect = DROPEFFECT_COPY;
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE
+tdt_DragLeave(IDropTarget *self)
+{
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE
+tdt_Drop(IDropTarget *self, IDataObject *pDataObj, DWORD grfKeyState,
+         POINTL pt, DWORD *pdwEffect)
+{
+    TeekDropTarget *tdt = (TeekDropTarget *)self;
+    FORMATETC fmt = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+    STGMEDIUM stg;
+    HRESULT hr;
+
+    *pdwEffect = DROPEFFECT_NONE;
+
+    hr = IDataObject_GetData(pDataObj, &fmt, &stg);
+    if (FAILED(hr)) return hr;
+
+    HDROP hDrop = (HDROP)GlobalLock(stg.hGlobal);
+    if (!hDrop) {
+        ReleaseStgMedium(&stg);
+        return E_FAIL;
+    }
+
+    UINT count = DragQueryFileW(hDrop, 0xFFFFFFFF, NULL, 0);
+    UINT i;
+
+    /* Build a Tcl list of all dropped file paths */
+    Tcl_Obj *listObj = Tcl_NewListObj(0, NULL);
+    Tcl_IncrRefCount(listObj);
+
+    for (i = 0; i < count; i++) {
+        WCHAR wpath[MAX_PATH];
+        if (DragQueryFileW(hDrop, i, wpath, MAX_PATH) == 0) continue;
+
+        /* Convert wide string to UTF-8 for Tcl */
+        int utf8_len = WideCharToMultiByte(CP_UTF8, 0, wpath, -1,
+                                           NULL, 0, NULL, NULL);
+        if (utf8_len <= 0) continue;
+
+        char *utf8 = (char *)malloc(utf8_len);
+        if (!utf8) continue;
+
+        WideCharToMultiByte(CP_UTF8, 0, wpath, -1, utf8, utf8_len, NULL, NULL);
+        Tcl_ListObjAppendElement(NULL, listObj,
+            Tcl_NewStringObj(utf8, -1));
+        free(utf8);
+    }
+
+    /* Generate single <<DropFile>> event with all paths as a Tcl list */
+    Tcl_Obj *script = Tcl_ObjPrintf(
+        "event generate %s <<DropFile>> -data {%s}",
+        tdt->widget_path, Tcl_GetString(listObj));
+    Tcl_IncrRefCount(script);
+    Tcl_EvalObjEx(tdt->interp, script, TCL_EVAL_GLOBAL);
+    Tcl_DecrRefCount(script);
+    Tcl_DecrRefCount(listObj);
+
+    GlobalUnlock(stg.hGlobal);
+    ReleaseStgMedium(&stg);
+    *pdwEffect = DROPEFFECT_COPY;
+    return S_OK;
+}
+
+/* COM vtable */
+static IDropTargetVtbl teek_drop_vtbl = {
+    tdt_QueryInterface,
+    tdt_AddRef,
+    tdt_Release,
+    tdt_DragEnter,
+    tdt_DragOver,
+    tdt_DragLeave,
+    tdt_Drop
+};
+
+/* --------------------------------------------------------- */
+
+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;
+    }
+
+    HWND hwnd = Tk_GetHWND(drawable);
+    if (!hwnd) {
+        Tcl_SetResult(interp, "could not get HWND", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    HRESULT hr = OleInitialize(NULL);
+    if (FAILED(hr)) {
+        Tcl_SetResult(interp, "OleInitialize failed", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    TeekDropTarget *tdt = (TeekDropTarget *)malloc(sizeof(TeekDropTarget));
+    if (!tdt) {
+        Tcl_SetResult(interp, "out of memory", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    tdt->lpVtbl = &teek_drop_vtbl;
+    tdt->ref_count = 1;
+    tdt->interp = interp;
+    tdt->widget_path = strdup(widget_path);
+    tdt->hwnd = hwnd;
+
+    hr = RegisterDragDrop(hwnd, (IDropTarget *)tdt);
+    if (FAILED(hr)) {
+        free(tdt->widget_path);
+        free(tdt);
+        if (hr == DRAGDROP_E_ALREADYREGISTERED) {
+            return TCL_OK; /* Already registered */
+        }
+        Tcl_SetResult(interp, "RegisterDragDrop failed", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    return TCL_OK;
+}
+
+#else
+
+int
+teek_register_drop_target(Tcl_Interp *interp, Tk_Window tkwin,
+                          const char *widget_path)
+{
+    Tcl_SetResult(interp, "file drop not supported on this platform", TCL_STATIC);
+    return TCL_ERROR;
+}
+
+#endif /* _WIN32 */

data/ext/teek/tkdrop_x11.c

@@ -0,0 +1,337 @@
+/* tkdrop_x11.c - X11 file drop target via XDND protocol
+ *
+ * Implements the XDND (version 5) drop target protocol for receiving
+ * file drops from X11 desktop environments. Handles XdndEnter,
+ * XdndPosition, XdndDrop client messages and selection transfer.
+ *
+ * Based on tkdnd (https://github.com/petasis/tkdnd) as reference.
+ * See THIRD_PARTY_NOTICES for attribution.
+ */
+
+#include <tcl.h>
+#include <tk.h>
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include "tkdrop.h"
+
+#define XDND_VERSION 5
+
+/* Per-window drop target state */
+typedef struct {
+    Tcl_Interp *interp;
+    char *widget_path;
+    Tk_Window tkwin;
+    Display *display;
+    Window window;
+    /* XDND atoms (cached) */
+    Atom xdnd_aware;
+    Atom xdnd_enter;
+    Atom xdnd_position;
+    Atom xdnd_status;
+    Atom xdnd_drop;
+    Atom xdnd_finished;
+    Atom xdnd_selection;
+    Atom xdnd_type_list;
+    Atom xdnd_action_copy;
+    Atom text_uri_list;
+    Atom teek_drop_prop;
+    /* State during drag */
+    Window source_window;
+    int has_uri_list;
+} TeekXdndState;
+
+/* Decode a %XX hex escape in a URI, return decoded char or -1 on error */
+static int
+hex_decode(const char *s)
+{
+    int hi, lo;
+    hi = s[0];
+    lo = 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;
+    else return -1;
+    if (lo >= '0' && lo <= '9') lo -= '0';
+    else if (lo >= 'a' && lo <= 'f') lo = lo - 'a' + 10;
+    else if (lo >= 'A' && lo <= 'F') lo = lo - 'A' + 10;
+    else return -1;
+    return (hi << 4) | lo;
+}
+
+/* Convert a file:// URI to a filesystem path in-place.
+ * Strips the file:// prefix and decodes %XX escapes.
+ * Returns pointer to the path within the buffer, or NULL if not a file URI. */
+static char *
+uri_to_path(char *uri)
+{
+    char *src, *dst;
+
+    /* Strip file:// prefix */
+    if (strncmp(uri, "file://", 7) == 0) {
+        src = uri + 7;
+        /* Skip optional hostname (file://localhost/path -> /path) */
+        if (*src != '/' && strncmp(src, "localhost", 9) == 0) {
+            src += 9;
+        }
+    } else {
+        return NULL;
+    }
+
+    /* URL-decode in place */
+    dst = src;
+    while (*src) {
+        if (*src == '%' && src[1] && src[2]) {
+            int ch = hex_decode(src + 1);
+            if (ch >= 0) {
+                *dst++ = (char)ch;
+                src += 3;
+                continue;
+            }
+        }
+        *dst++ = *src++;
+    }
+    *dst = '\0';
+
+    return uri + 7 + (uri[7] != '/') * 9; /* return start of decoded path */
+}
+
+/* Send XdndStatus response to source */
+static void
+send_xdnd_status(TeekXdndState *st, int accept)
+{
+    XClientMessageEvent msg;
+    memset(&msg, 0, sizeof(msg));
+    msg.type = ClientMessage;
+    msg.display = st->display;
+    msg.window = st->source_window;
+    msg.message_type = st->xdnd_status;
+    msg.format = 32;
+    msg.data.l[0] = st->window;          /* target window */
+    msg.data.l[1] = accept ? 1 : 0;      /* bit 0 = accept */
+    msg.data.l[2] = 0;                    /* empty rectangle */
+    msg.data.l[3] = 0;
+    msg.data.l[4] = accept ? st->xdnd_action_copy : 0;
+
+    XSendEvent(st->display, st->source_window, False, NoEventMask,
+               (XEvent *)&msg);
+}
+
+/* Send XdndFinished to source */
+static void
+send_xdnd_finished(TeekXdndState *st, int success)
+{
+    XClientMessageEvent msg;
+    memset(&msg, 0, sizeof(msg));
+    msg.type = ClientMessage;
+    msg.display = st->display;
+    msg.window = st->source_window;
+    msg.message_type = st->xdnd_finished;
+    msg.format = 32;
+    msg.data.l[0] = st->window;
+    msg.data.l[1] = success ? 1 : 0;
+    msg.data.l[2] = success ? st->xdnd_action_copy : 0;
+
+    XSendEvent(st->display, st->source_window, False, NoEventMask,
+               (XEvent *)&msg);
+}
+
+/* Process dropped data (text/uri-list) and generate a single <<DropFile>> event */
+static void
+process_uri_list(TeekXdndState *st, const char *data, unsigned long len)
+{
+    char *buf = (char *)malloc(len + 1);
+    if (!buf) return;
+    memcpy(buf, data, len);
+    buf[len] = '\0';
+
+    /* Build a Tcl list of all dropped file paths */
+    Tcl_Obj *listObj = Tcl_NewListObj(0, NULL);
+    Tcl_IncrRefCount(listObj);
+
+    /* text/uri-list: one URI per line, \r\n separated, # lines are comments */
+    char *line = buf;
+    while (line && *line) {
+        char *eol = strstr(line, "\r\n");
+        if (eol) *eol = '\0';
+
+        /* Skip comments and empty lines */
+        if (*line && *line != '#') {
+            char *uri_copy = strdup(line);
+            if (uri_copy) {
+                char *path = uri_to_path(uri_copy);
+                if (path && *path) {
+                    Tcl_ListObjAppendElement(NULL, listObj,
+                        Tcl_NewStringObj(path, -1));
+                }
+                free(uri_copy);
+            }
+        }
+
+        line = eol ? eol + 2 : NULL;
+    }
+
+    /* Generate single <<DropFile>> event with all paths as a Tcl list */
+    Tcl_Obj *script = Tcl_ObjPrintf(
+        "event generate %s <<DropFile>> -data {%s}",
+        st->widget_path, Tcl_GetString(listObj));
+    Tcl_IncrRefCount(script);
+    Tcl_EvalObjEx(st->interp, script, TCL_EVAL_GLOBAL);
+    Tcl_DecrRefCount(script);
+    Tcl_DecrRefCount(listObj);
+
+    free(buf);
+}
+
+/* Tk event handler for ClientMessage and SelectionNotify */
+static int
+xdnd_event_handler(ClientData clientData, XEvent *eventPtr)
+{
+    TeekXdndState *st = (TeekXdndState *)clientData;
+
+    if (eventPtr->type == ClientMessage) {
+        XClientMessageEvent *cm = &eventPtr->xclient;
+
+        if (cm->message_type == st->xdnd_enter) {
+            st->source_window = (Window)cm->data.l[0];
+            int version = (cm->data.l[1] >> 24) & 0xFF;
+            if (version > XDND_VERSION) return 0;
+
+            /* Check if text/uri-list is among offered types */
+            st->has_uri_list = 0;
+            int more_than_3 = cm->data.l[1] & 1;
+
+            if (more_than_3) {
+                /* Fetch XdndTypeList property from source */
+                Atom type;
+                int format;
+                unsigned long count, remaining;
+                unsigned char *prop_data = NULL;
+
+                XGetWindowProperty(st->display, st->source_window,
+                    st->xdnd_type_list, 0, 1024, False, XA_ATOM,
+                    &type, &format, &count, &remaining, &prop_data);
+
+                if (prop_data) {
+                    Atom *types = (Atom *)prop_data;
+                    unsigned long i;
+                    for (i = 0; i < count; i++) {
+                        if (types[i] == st->text_uri_list) {
+                            st->has_uri_list = 1;
+                            break;
+                        }
+                    }
+                    XFree(prop_data);
+                }
+            } else {
+                /* Types are in data.l[2..4] */
+                int i;
+                for (i = 2; i <= 4; i++) {
+                    if ((Atom)cm->data.l[i] == st->text_uri_list) {
+                        st->has_uri_list = 1;
+                        break;
+                    }
+                }
+            }
+            return 1;
+        }
+
+        if (cm->message_type == st->xdnd_position) {
+            send_xdnd_status(st, st->has_uri_list);
+            return 1;
+        }
+
+        if (cm->message_type == st->xdnd_drop) {
+            if (st->has_uri_list) {
+                Time timestamp = (Time)cm->data.l[2];
+                XConvertSelection(st->display, st->xdnd_selection,
+                    st->text_uri_list, st->teek_drop_prop,
+                    st->window, timestamp);
+            } else {
+                send_xdnd_finished(st, 0);
+            }
+            return 1;
+        }
+    }
+
+    if (eventPtr->type == SelectionNotify) {
+        XSelectionEvent *sel = &eventPtr->xselection;
+        if (sel->property == st->teek_drop_prop) {
+            Atom type;
+            int format;
+            unsigned long count, remaining;
+            unsigned char *data = NULL;
+
+            XGetWindowProperty(st->display, st->window,
+                st->teek_drop_prop, 0, 65536, True, AnyPropertyType,
+                &type, &format, &count, &remaining, &data);
+
+            if (data && count > 0) {
+                process_uri_list(st, (const char *)data, count);
+            }
+            if (data) XFree(data);
+
+            send_xdnd_finished(st, 1);
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+/* Tk generic event handler wrapper */
+static int
+xdnd_generic_handler(ClientData clientData, XEvent *eventPtr)
+{
+    return xdnd_event_handler(clientData, eventPtr);
+}
+
+int
+teek_register_drop_target(Tcl_Interp *interp, Tk_Window tkwin,
+                          const char *widget_path)
+{
+    Display *display = Tk_Display(tkwin);
+    Window window = Tk_WindowId(tkwin);
+
+    if (!display || !window) {
+        Tcl_SetResult(interp, "window has no X11 display/id", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    TeekXdndState *st = (TeekXdndState *)calloc(1, sizeof(TeekXdndState));
+    if (!st) {
+        Tcl_SetResult(interp, "out of memory", TCL_STATIC);
+        return TCL_ERROR;
+    }
+
+    st->interp = interp;
+    st->widget_path = strdup(widget_path);
+    st->tkwin = tkwin;
+    st->display = display;
+    st->window = window;
+
+    /* Cache atoms */
+    st->xdnd_aware      = Tk_InternAtom(tkwin, "XdndAware");
+    st->xdnd_enter       = Tk_InternAtom(tkwin, "XdndEnter");
+    st->xdnd_position    = Tk_InternAtom(tkwin, "XdndPosition");
+    st->xdnd_status      = Tk_InternAtom(tkwin, "XdndStatus");
+    st->xdnd_drop        = Tk_InternAtom(tkwin, "XdndDrop");
+    st->xdnd_finished    = Tk_InternAtom(tkwin, "XdndFinished");
+    st->xdnd_selection   = Tk_InternAtom(tkwin, "XdndSelection");
+    st->xdnd_type_list   = Tk_InternAtom(tkwin, "XdndTypeList");
+    st->xdnd_action_copy = Tk_InternAtom(tkwin, "XdndActionCopy");
+    st->text_uri_list    = Tk_InternAtom(tkwin, "text/uri-list");
+    st->teek_drop_prop   = Tk_InternAtom(tkwin, "TeekDropData");
+
+    /* Set XdndAware property (version 5) */
+    Atom version = XDND_VERSION;
+    XChangeProperty(display, window, st->xdnd_aware, XA_ATOM, 32,
+                    PropModeReplace, (unsigned char *)&version, 1);
+
+    /* Register generic event handler for ClientMessage + SelectionNotify */
+    Tk_CreateGenericHandler(xdnd_generic_handler, (ClientData)st);
+
+    return TCL_OK;
+}

data/ext/teek/tkwin.c

@@ -101,6 +101,47 @@ interp_get_root_coords(VALUE self, VALUE window_path)
     return rb_ary_new_from_args(2, INT2NUM(x), INT2NUM(y));
 }
 
+/* ---------------------------------------------------------
+ * Interp#window_geometry(window_path)
+ *
+ * Get a window's screen position and interior size in one call.
+ *
+ * Arguments:
+ *   window_path - Tk window path (e.g., ".", ".settings")
+ *
+ * Returns [root_x, root_y, width, height].
+ *
+ * root_x/root_y are absolute screen coordinates (Tk_GetRootCoords).
+ * width/height are the interior size excluding any border (Tk_Width/Tk_Height).
+ * --------------------------------------------------------- */
+
+static VALUE
+interp_window_geometry(VALUE self, VALUE window_path)
+{
+    struct tcltk_interp *tip = get_interp(self);
+    Tk_Window mainWin;
+    Tk_Window tkwin;
+    int x, y;
+
+    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_GetRootCoords(tkwin, &x, &y);
+
+    return rb_ary_new_from_args(4,
+        INT2NUM(x), INT2NUM(y),
+        INT2NUM(Tk_Width(tkwin)), INT2NUM(Tk_Height(tkwin)));
+}
+
 /* ---------------------------------------------------------
  * Interp#coords_to_window(root_x, root_y)
  *
@@ -223,6 +264,7 @@ Init_tkwin(VALUE cInterp)
 {
     rb_define_method(cInterp, "user_inactive_time", interp_user_inactive_time, 0);
     rb_define_method(cInterp, "get_root_coords", interp_get_root_coords, 1);
+    rb_define_method(cInterp, "window_geometry", interp_window_geometry, 1);
     rb_define_method(cInterp, "coords_to_window", interp_coords_to_window, 2);
     rb_define_method(cInterp, "native_window_handle", interp_native_window_handle, 1);
 }

data/lib/teek/platform.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Standalone platform detection — no dependencies on the rest of Teek.
+# Safe to require from extconf.rb or any context where the full gem
+# isn't loaded yet.
+
+module Teek
+  class Platform
+    def initialize(platform = RUBY_PLATFORM)
+      @platform = platform.freeze
+    end
+
+    def darwin?  = @platform.include?('darwin')
+    def linux?   = @platform.include?('linux')
+    def windows? = !!(@platform =~ /mingw|mswin|cygwin/)
+
+    def to_s
+      if darwin? then 'darwin'
+      elsif windows? then 'windows'
+      elsif linux? then 'linux'
+      else @platform
+      end
+    end
+  end
+
+  def self.platform
+    @platform ||= Platform.new
+  end
+end

data/lib/teek/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Teek
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end