glimmer-dsl-tk 0.0.44 → 0.0.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cb173f133301f49a6f4ddfc86578e450b563ff842b96274b6003b784b2e8acb
-  data.tar.gz: 810087c40f044768c6394a968b945fdc2e3c4c0d1eb8caac2b3421259c431d61
+  metadata.gz: 8c99ac84c772515736f995d5a5ab31aaa38bbbe986d26d1c1566c8d49c5347c9
+  data.tar.gz: 192d47da74f8630c268f52f7601b67126cbe07d2284defc8a8a6174a068b6274
 SHA512:
-  metadata.gz: 8842b20e509fd9c0f918953942665ac5a0609cbc91b0faf020c808e736890e1d2617abb579b384696711ecb0d40bf7ab82a5a0e669a1ff878bede9ed061c6abb
-  data.tar.gz: 983740e737d7e066f56411ddea5ab7ab607bf196579d519e41aea07bd4c5e8d24b2dcd178086a3d8f35aa8e6ae7b0b8995cb27e3846516887ad4908e07758847
+  metadata.gz: 950ef28b2882ee22d7adf49528eb8fe0e3aa3c1949ea92ec319274af09bd5c10b5832a78ace63b1e77404fa26c9f0e0fe29ba78d398162150ca235b0441566fa
+  data.tar.gz: 65f424fc3206e9bbd30bbae63da5a249f259c4619d5e987b1ab19b5e608442f0502f3b9ec5b2aac92c6cf92dfc67fa08727297d8b06aee22c3d910a865458c01

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Change Log
 
+## 0.0.48
+
+- Moved `OS` class to `Glimmer::Tk::OS` to avoid clashing with os gem when installed for users
+- Moved `DragAndDropEvent` from `Glimmer::Tk::DraggableAndDroppable` into `Glimmer::Tk` namespace directly as `Glimmer::Tk::DragAndDropEvent`
+
+## 0.0.47
+
+- Upgrade to glimmer 2.5.1 (includes more advanced data-binding/observer features)
+
+## 0.0.46
+
+- Support `drag_source true` on `list` widget
+- Support `drop_target true` keyword alternative to `on_drop` for cases where it is implied what to drop (text in the case of label, entry, combo, list, and button)
+- Support `on('drag_start')` (instead of `on_drag_start`), `on('drag_motion')`, and `on('drop')` for consistency with Glimmer DSL for general Tk listener style (`on('event')`)
+
+## 0.0.45
+
+- Support `lbl` widget as the non-tile-themed version of `label` (i.e. `::TkLabel` not `::Tk::Tile::TLabel`)
+- Add `#proxy` method to all Tk widgets to return Glimmer widget proxy objects (e.g. `Tk::Tile::TButton#proxy` returns `Glimmer::Tk::WidgetProxy` object)
+- Provide question mark alias of `event.drop_accepted` (i.e. `drop_accepted?`)
+- Have `DragAndDropEvent` `source`/`target` be the enhanced Glimmer widget proxy instead of the unenhanced Tk widget
+- Look into improving code that uses `TkLabel` explicitly in Hello, Drag and Drop! (do `event.tooltip.content {label {...} }` with Glimmer DSL instead)
+- Add Glimmer Style Guide
+- Fix issue with dropping button and list unto checkbox in Hello, Drag and Drop!
+
 ## 0.0.44
 
 - Fix issue with not being able to drop list into checkbox in Hello, Drag and Drop! by disabling functionality for list just like button

data/README.md

@@ -1,4 +1,4 @@
-# [<img src="https://raw.githubusercontent.com/AndyObtiva/glimmer/master/images/glimmer-logo-hi-res.png" height=85 />](https://github.com/AndyObtiva/glimmer) Glimmer DSL for Tk 0.0.44
+# [<img src="https://raw.githubusercontent.com/AndyObtiva/glimmer/master/images/glimmer-logo-hi-res.png" height=85 />](https://github.com/AndyObtiva/glimmer) Glimmer DSL for Tk 0.0.48
 ## MRI Ruby Desktop Development GUI Library
 [![Gem Version](https://badge.fury.io/rb/glimmer-dsl-tk.svg)](http://badge.fury.io/rb/glimmer-dsl-tk)
 [![Ruby](https://github.com/AndyObtiva/glimmer-dsl-tk/actions/workflows/ruby.yml/badge.svg)](https://github.com/AndyObtiva/glimmer-dsl-tk/actions/workflows/ruby.yml)
@@ -53,7 +53,7 @@ Glimmer app:
 
 NOTE: Glimmer DSL for Tk is currently in early alpha mode (incomplete). Please help make better by contributing, adopting for small or low risk projects, and providing feedback. It is still an early alpha, so the more feedback and issues you report the better.
 
-Other [Glimmer](https://github.com/AndyObtiva/glimmer) DSL gems:
+Other [Glimmer](https://github.com/AndyObtiva/glimmer) DSL gems you might be interested in:
 - [glimmer-dsl-swt](https://github.com/AndyObtiva/glimmer-dsl-swt): Glimmer DSL for SWT (JRuby Desktop Development GUI Framework)
 - [glimmer-dsl-opal](https://github.com/AndyObtiva/glimmer-dsl-opal): Glimmer DSL for Opal (Pure Ruby Web GUI and Auto-Webifier of Desktop Apps)
 - [glimmer-dsl-libui](https://github.com/AndyObtiva/glimmer-dsl-libui): Glimmer DSL for LibUI (Prerequisite-Free Ruby Desktop Development GUI Library)
@@ -100,6 +100,7 @@ Other [Glimmer](https://github.com/AndyObtiva/glimmer) DSL gems:
     - [Radiobutton Data-Binding](#radiobutton-data-binding)
   - [Command Callback](#command-callback)
   - [Gotchas](#gotchas)
+  - [Glimmer Style Guide](#glimmer-style-guide)
   - [Samples](#samples)
     - [Hello, World!](#hello-world)
     - [Hello, Button!](#hello-button)
@@ -181,7 +182,7 @@ gem install glimmer-dsl-tk
 
 Add the following to `Gemfile`:
 ```
-gem 'glimmer-dsl-tk', '0.0.44'
+gem 'glimmer-dsl-tk', '0.0.48'
 ```
 
 And, then run:
@@ -225,6 +226,8 @@ The Glimmer GUI DSL follows these simple concepts in mapping from Tk syntax:
 - **Content/Options Block**: Any keyword may optionally be followed by a Ruby curly-brace block containing nested widgets (content) and attributes (options). Attributes are simply Tk option keywords followed by arguments and no block (e.g. `title 'Hello, World!'` under a `root`)
 - **Event Binding Block**: `on(event) {}` keyword receiving a Tk binding event name (e.g. `KeyPress` or `ComboboxSelected`). Surrounding event by `<>` is optional as [Glimmer DSL for Tk](https://rubygems.org/gems/glimmer-dsl-tk) can take care of that automatically.
 
+Note that Glimmer widgets are proxy objects (wrappers) for Tk widgets. To get wrapped Tk widget from a Glimmer widget, you simply invoke `#tk` method. To get the proxy of a wrapped Tk widget, you may invoke `#proxy` method.
+
 Example of an app written in [Tk](https://www.tcl.tk/) imperative syntax:
 
 ```ruby
@@ -303,6 +306,7 @@ keyword(args) | attributes | event bindings & callbacks
 `spinbox` | `text`, `from`, `to`, `increment`, `format`, [more attributes](https://tcl.tk/man/tcl8.6/TkCmd/text.htm#M116) | `command {}`, `'increment'`, `'decrement'`
 `frame(text: nil)` | `width`, `height`, `borderwidth`, `relief` (`'flat' (default), 'raised', 'sunken', 'solid', 'ridge', 'groove'`) | None
 `label` | `text`, `image` (optional keyword args: `subsample`, `zoom`, `from`, `to`, `shrink`, `compositingrule`), `compound` (`'center', 'top', 'bottom', 'left', 'right'`), `font` (`'default', 'text', 'fixed', 'menu', 'heading', 'caption', 'small_caption', 'icon', 'tooltip'`), `relief` (`'flat' (default), 'raised', 'sunken', 'solid', 'ridge', 'groove'`), `justify` (`'left', 'center', 'right'`), `foreground`, `background` | None
+`lbl` (non-tile-themed version of `label`) | `text`, `image` (optional keyword args: `subsample`, `zoom`, `from`, `to`, `shrink`, `compositingrule`), `compound` (`'center', 'top', 'bottom', 'left', 'right'`), `font` (`'default', 'text', 'fixed', 'menu', 'heading', 'caption', 'small_caption', 'icon', 'tooltip'`), `relief` (`'flat' (default), 'raised', 'sunken', 'solid', 'ridge', 'groove'`), `justify` (`'left', 'center', 'right'`), `foreground`, `background`, `bg`, `bitmap`, [more here](https://tcl.tk/man/tcl8.6/TkCmd/label.htm) | None
 `list` | `selectmode`, `selection` | None
 `message_box(type: , message: , detail: , title: , icon: , default: , parent: )` | None | None
 `menu(label: nil) (label is nil if nested under root/toplevel for menu bar)` | None | None
@@ -476,14 +480,23 @@ Check out the [Hello, Scrollbar!](#hello-scrollbar) sample for a `text` demo wit
 
 #### Drag and Drop API
 
-Drag and drop works by simply designating a widget as a drag source with attribute `drag_source true`
+Drag and drop works by simply designating a widget as a drag source with attribute `drag_source true` and another widget as a drop target with attribute `drop_target true`.
+
+Alternatively, add listeners on the drag source:
+- `on('drag_start') {|event| ...}`: fires on drag start receiving an `event` arg to set `data` and configure `source`
+- `on('drag_motion') {|event| ...}`: fires on drag motion receiving an `event` arg to check `event#drop_accepted`, and configure `source` and `tooltip`
 
-Alternatively, add listeners:
-- `on_drag_start {|event| ...}`: fires on drag start receiving an `event` arg to set `data` and configure `source`
-- `on_drag_motion {|event| ...}`: fires on drag motion receiving an `event` arg to check `event#drop_accepted`, and configure `source` and `tooltip`
+And on the drop target, add listener:
+- `on('drop') { |event| ...}`: fires on drop, receiving an `event` arg with `event#target` and `event#data` (set during drag). You can even destroy the `event#source` if you want to get rid of the dragged widget.
 
-On the drop target, you simply define:
-- `on_drop { |event| ...}`: fires on drop, receiving an `event` arg with `event#target` and `event#data` (set during drag). You can even destroy the `event#source` if you want to get rid of the dragged widget.
+These are all the available attributes on event, which is of type `DragAndDropEvent`:
+- `source`: drag source widget proxy
+- `target`: drop target widget proxy
+- `tooltip`: tooltip widget proxy
+- `x_root`: x coordinate from top-left root corner
+- `y_root`: y coordinate from top-left root corner
+- `data`: data being transferred through drag and drop
+- `drop_accepted`: boolean indicating if drop was accepted
 
 Learn more at the [Hello, Drag and Drop!](#hello-drag-and-drop) sample.
 
@@ -824,6 +837,17 @@ More details can be found in the [Hello, Button!](#hello-button) sample below.
 
 - Setting `background` attribute on `frame` or `label` does not work in `'aqua'` theme on the Mac (only in `'classic'` theme)
 
+## Glimmer Style Guide
+
+- Widget arguments are always wrapped by parentheses.
+- Widget blocks are always declared with curly braces `{}` to clearly visualize hierarchical view code and separate from logic code.
+- Widget attribute declarations always have arguments that are never wrapped inside parentheses and never take a block.
+- Widget listeners are always declared with `on` keyword receiving listener event name as an argument. Their multi-line blocks have a `do; end` style to distinguish as logic from widget keywords and attributes.
+- In a widget's content block, group attributes on top first, with the `grid` geometry management attribute being first, and separate by an empty line from nested widgets and listeners following afterwards.
+- In a widget's content block, after attributes, you may either include nested widgets second and listeners third or vice versa.
+- Unlike attributes, nested widgets and listeners are all separated by an empty line to make readability easier except where it helps to group two widgets together (e.g. label and described entry)
+- Pure logic multi-line blocks that do not constitute GUI DSL view elements in general always have `do; end` style to clearly separate logic code from view code.
+
 ## Samples
 
 The easiest way to run samples is by launching the Glimmer Meta-Sample (the Sample of Samples).
@@ -1026,14 +1050,14 @@ class HelloButton
           text 'Text Button'
         }
         
-        button {
+        button { |b|
           text <= [self, :count, on_read: ->(value) { "Click To Increment: #{value}  " }]
           default 'active'
           focus true
           
-          command {
+          on('command') do
             self.count += 1
-          }
+          end
         }
       }
         
@@ -1048,9 +1072,9 @@ class HelloButton
         button {
           image File.expand_path('../../icons/glimmer.png', __dir__), subsample: 5
           
-          command {
+          on('command') do
             message_box(title: 'Image Button', message: 'Image Button Clicked!')
-          }
+          end
         }
       }
       
@@ -1065,12 +1089,12 @@ class HelloButton
         ['center', 'top', 'bottom', 'left', 'right'].each do |compound_option|
           button {
             image File.expand_path('../../icons/glimmer.png', __dir__), subsample: 5
-            text 'Text Image Button'
+            text "#{compound_option.capitalize} Image"
             compound compound_option
             
-            command {
+            on('command') do
               message_box(title: 'Text Image Button', message: 'Text Image Button Clicked!', detail: "(#{compound_option})")
-            }
+            end
           }
         end
       }
@@ -2699,27 +2723,40 @@ root {
       
       label {
         grid :row => 0, :column => 0
-        text "Entry"
+        text "Label"
+      }
+      label {
+        grid :row => 0, :column => 1, :pady => 10, :sticky => "e"
+        text "Drag label text"
+        width 30
+        drag_source true
       }
       
+      label {
+        grid :row => 1, :column => 0
+        text "Entry"
+      }
       entry {
-        grid :row => 0, :column => 1, :pady => 5, :sticky => "e"
+        grid :row => 1, :column => 1, :pady => 5, :sticky => "e"
         text "Drag entry text"
         width 30
         
-        on_drag_start do |event|
-          event.data = event.source.textvariable&.value
+        # drag_source true
+        # This is how to do `drag_source true` the manual way for use in exceptional cases
+        on('drag_start') do |event|
+          event.data = event.source.text
           event.source.configure(:cursor => "hand2")
-          TkLabel.new(event.tooltip) {
-            text event.data + " "
-            bg "yellow"
-            bitmap "warning"
-            compound "right"
-          }.pack
+          event.tooltip.content { # re-open tooltip content and add a label
+            lbl { # non-tile-theme version of label
+              text event.data + " "
+              bg "yellow"
+              bitmap "warning"
+              compound "right"
+            }
+          }
         end
-        
-        on_drag_motion do |event|
-          if event.drop_accepted
+        on('drag_motion') do |event|
+          if event.drop_accepted?
             event.source.configure(:cursor => "hand1")
           else
             event.source.configure(:cursor => "hand2")
@@ -2728,48 +2765,34 @@ root {
         end
       }
       
-      label {
-        grid :row => 1, :column => 0
-        text "Label"
-      }
-      
-      label {
-        grid :row => 1, :column => 1, :pady => 10, :sticky => "e"
-        text "Drag label text"
-        width 30
-        drag_source true
-      }
-      
       label {
         grid :row => 2, :column => 0
         text "Combobox"
       }
-      
       combobox {
         grid :row => 2, :column => 1, :pady => 5, :sticky => "e"
         text "Spain"
         values %w[USA Canada Mexico Columbia UK Australia Germany Italy Spain]
         width 27
         
-        on_drag_start do |event|
-          event.data = event.source.textvariable&.value
-        end
+        drag_source true
       }
       
       label {
         grid :row => 3, :column => 0
         text 'List'
       }
-      
-      country_list = list {
+      list {
         grid :row => 3, :column => 1, :pady => 5, :sticky => "e"
         selectmode 'browse'
         items %w[USA Canada Mexico]
         selection 'Canada'
         height 3
         
-        on_drag_start do |event|
-          event.data = event.source.selection.to_a.first.text
+        # drag_source true
+        # This is another alternative to `drag_source true` with manual specification of transferred data only
+        on('drag_start') do |event|
+          event.data = event.source.selection.first
         end
       }
       
@@ -2777,7 +2800,6 @@ root {
         grid :row => 4, :column => 0
         text "Button"
       }
-      
       button {
         grid :row => 4, :column => 1, :pady => 5, :sticky => "w"
         text "Drag it"
@@ -2792,89 +2814,76 @@ root {
       
       label {
         grid :row => 0, :column => 0
-        text "Entry"
+        text "Label"
       }
-      
-      entry {
-        grid :row => 0, :column => 1, :pady => 5, :sticky => "e"
+      label {
+        grid :row => 0, :column => 1, :pady => 10, :sticky => "e"
         width 30
+        borderwidth 2
+        relief "solid"
         
-        on_drop { |event|
-          event.target.textvariable.value = event.data
-        }
+        drop_target true
       }
       
       label {
         grid :row => 1, :column => 0
-        text "Label"
+        text "Entry"
       }
-      
-      label {
-        grid :row => 1, :column => 1, :pady => 10, :sticky => "e"
+      entry {
+        grid :row => 1, :column => 1, :pady => 5, :sticky => "e"
         width 30
-        borderwidth 2
-        relief "solid"
         
-        on_drop do |event|
-          event.target.textvariable.value = event.data
-        end
+        drop_target true
       }
       
       label {
         grid :row => 2, :column => 0
         text "Combobox"
       }
-      
       combobox {
         grid :row => 2, :column => 1, :pady => 5, :sticky => "e"
         width 27
         
-        on_drop do |event|
-          event.target.textvariable.value = event.data
-        end
+        drop_target true
       }
       
       label {
         grid :row => 3, :column => 0
         text 'List'
       }
-      
       list {
         grid :row => 3, :column => 1, :pady => 5, :sticky => "e"
         selectmode 'browse'
         height 3
         
-        on_drop do |event|
-          event.target.insert('', 'end', :text => event.data)
-        end
+        drop_target true
       }
       
       label {
         grid :row => 4, :column => 0
         text "Button"
       }
-      
       button {
         grid :row => 4, :column => 1, :pady => 5, :sticky => "w"
         text "Drop here"
         
-        on_drop do |event|
-          event.target.text = event.data
-        end
+        drop_target true
       }
       
       label {
         grid :row => 5, :column => 0
         text "Checkbutton"
       }
-      
       checkbutton {
         grid :row => 5, :column => 1, :pady => 5, :sticky => "w"
-        text "Drop here to destroy a widget\n(except button)"
-        
-        on_drop do |event|
+        text "Drop here to destroy a widget"
+
+        # drop_target true
+        # This is an alternative to `drop_target true` with manual consumption of transferred data
+        on('drop') do |event|
           event.target.text = event.data
-          event.source.destroy unless event.source.is_a? Tk::Button
+          # execute asynchronously after 100ms to ensure all events have been processed before destruction
+          ::Tk.after(100) {event.source.destroy}
         end
       }
     }

data/VERSION

@@ -1 +1 @@
-0.0.44
+0.0.48

data/lib/glimmer/dsl/tk/list_selection_data_binding_expression.rb

@@ -50,7 +50,7 @@ module Glimmer
           #TODO check if nested data binding works for list widget and other widgets that need custom data binding
           list_selection_binding.observe(model, model_binding.property_name_expression)
   
-          parent.tk.bind('<TreeviewSelect>') do
+          parent.on('<TreeviewSelect>') do
             model_binding.call(list_selection_binding.evaluate_property)
           end
         end

data/lib/glimmer/tk/drag_and_drop_event.rb

@@ -0,0 +1,23 @@
+module Glimmer
+  module Tk
+    DragAndDropEvent = Struct.new(:source, :target, :tooltip, :x_root, :y_root, :data, :drop_accepted) do
+      alias drop_accepted? drop_accepted
+      
+      def as_json(*)
+        klass = self.class.name
+        {
+          JSON.create_id => klass,
+          "v" => [values[0].object_id, values[1].object_id, values[2].object_id].concat(values.drop 3),
+        }
+      end
+
+      def to_json(*args)
+        as_json.to_json(*args)
+      end
+
+      def self.json_create(object)
+        new(*[ObjectSpace._id2ref(object["v"][0]), ObjectSpace._id2ref(object["v"][1]).proxy, ObjectSpace._id2ref(object["v"][2])].concat(object["v"].drop 3))
+      end
+    end
+  end
+end

data/lib/glimmer/tk/draggable_and_droppable.rb

@@ -0,0 +1,165 @@
+# Copyright (c) 2020-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require_relative 'drag_and_drop_event'
+require "json"
+
+module Glimmer
+  module Tk
+    module DraggableAndDroppable
+      attr_accessor :on_drag_motion_block
+      
+      def handle_listener(listener_name, &listener)
+        case listener_name.to_s.downcase
+        when 'drag_start'
+          self.on_drag_start_block = listener
+        when 'drag_motion'
+          self.on_drag_motion_block = listener
+        when 'drop'
+          self.on_drop_block = listener
+        else
+          super
+        end
+      end
+
+      def drag_source=(value)
+        @drag_source = value
+        if @drag_source
+          make_draggable
+        else
+          make_non_draggable
+        end
+      end
+
+      def drop_target=(value)
+        @drop_target = value
+        if @drop_target
+          make_droppable
+        else
+          make_non_droppable
+        end
+      end
+
+      def on_drag_start_block=(block)
+        @on_drag_start_block = block
+        make_draggable
+      end
+
+      def on_drop_block=(value)
+        @on_drop_block = value
+        self.tk.bind("<DropEvent>", proc { |tk_event|
+          drop_event = Glimmer::Tk::DragAndDropEvent.json_create(JSON.parse("{" + tk_event.detail + "}"))
+          @on_drop_block.call(drop_event) if self == drop_event.target
+        })
+        self.tk.bind("<DropCheckEvent>", proc { |tk_event|
+          drop_check_event = Glimmer::Tk::DragAndDropEvent.json_create(JSON.parse("{" + tk_event.detail + "}"))
+          drop_check_event.source.event_generate("<DropAcceptedEvent>")
+        })
+      end
+
+      def textvariable_defined?
+        tk_widget_has_attribute_setter?(:textvariable) && !tk.textvariable.nil?
+      end
+
+      def make_draggable
+        drag_event = nil
+        bind("<DropAcceptedEvent>", proc { |event| drag_event.drop_accepted = true })
+        bind("B1-Motion", proc { |tk_event|
+          if drag_event.nil?
+            tooltip = WidgetProxy.new('toplevel', root_parent_proxy, [])
+            tooltip.overrideredirect(1) #create tooltip window to display dragged data
+            tooltip.geometry("+#{tk_event.x_root + 10}+#{tk_event.y_root - 2}")
+            drag_event = Glimmer::Tk::DragAndDropEvent.new(self, nil, tooltip, tk_event.x_root, tk_event.y_root, nil, false)
+            if @drag_source
+              tk_event.widget.configure(:cursor => "hand2")
+              # Default data to drag is text
+              drag_event.data = if textvariable_defined?
+                tk.textvariable.value
+              elsif has_attribute?('text')
+                tk.text
+              elsif has_attribute?('selection')
+                selection.first
+              end
+              tooltip_label = WidgetProxy.new('label', tooltip, [])
+              tooltip_label.text = drag_event.data
+              tooltip_label.pack # TODO look into using grid instead to be consistent with the modern Tk way
+            elsif !@on_drag_start_block.nil?
+              @on_drag_start_block.call(drag_event)
+              if tooltip.winfo_children().length == 0
+                tooltip_label = WidgetProxy.new('label', tooltip, [])
+                tooltip_label.text = drag_event.data
+                tooltip_label.pack # TODO look into using grid instead to be consistent with the modern Tk way
+              end
+            end
+          else
+            drag_event.x_root, drag_event.y_root = tk_event.x_root, tk_event.y_root
+            drag_event.drop_accepted = false
+            move_over_widget = tk_event.widget.winfo_containing(tk_event.x_root, tk_event.y_root)
+            drag_event.target = move_over_widget.proxy
+            move_over_widget.event_generate("<DropCheckEvent>", :data => drag_event.to_json)
+            if @on_drag_motion_block.nil?
+              # Default motion behavior:
+              # 1.Change cursor to show whether text can be dropped.
+              # 2.Move tooltip with dragged data.
+              if drag_event.drop_accepted
+                tk_event.widget.configure(:cursor => "hand1")
+              else
+                tk_event.widget.configure(:cursor => "hand2")
+              end
+              drag_event.tooltip.geometry("+#{tk_event.x_root + 10}+#{tk_event.y_root - 2}")
+            else
+              @on_drag_motion_block.call(drag_event)
+            end
+          end
+        })
+        bind("ButtonRelease-1", proc { |tk_event|
+          if drag_event
+            drag_event.target = tk_event.widget.winfo_containing(tk_event.x_root, tk_event.y_root).proxy
+            drag_event.source.configure(:cursor => "")
+            drag_event.target.event_generate("<DropEvent>", :data => drag_event.to_json)
+            drag_event.tooltip.destroy
+            drag_event = nil
+          end
+        })
+      end
+
+      def make_non_draggable
+        @tk.bind_remove("B1-Motion")
+        @tk.bind_remove("ButtonRelease-1")
+        @tk.bind_remove("<DropAcceptedEvent>")
+      end
+
+      def make_droppable
+        self.on_drop_block = Proc.new do |event|
+          event.target.text = event.data if event.target.has_attribute?('text')
+          event.target.items += [event.data] if event.target.has_attribute?('items')
+          event.target.selection += [event.data] if event.target.has_attribute?('selection')
+        end
+      end
+
+      def make_non_droppable
+        @tk.bind_remove('<DropEvent>')
+        @tk.bind_remove('<DropCheckEvent>')
+        @on_drop_block = nil
+      end
+    end
+  end
+end

data/lib/glimmer/tk/lbl_proxy.rb

@@ -0,0 +1,33 @@
+# Copyright (c) 2020-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'glimmer/tk/widget_proxy'
+
+module Glimmer
+  module Tk
+    # Non-Themable (non-Tile) Tk Label
+    class LblProxy < WidgetProxy
+      def build_widget
+        @tk = ::TkLabel.new(@parent_proxy.tk, *args).tap {|tk| tk.singleton_class.include(Glimmer::Tk::Widget); tk.proxy = self}
+      end
+    end
+  end
+end