Find which widget has focus in Ruby 2.3.3 - ruby

Question

In Python, I use:
who = widget.focus_get()
and in Perl:
$who = $widget->focusCurrent;
to tell me which widget has the focus. So:
What is the equivalent code in Ruby under Linux?
Is there a good book or article about low-level Ruby Tk? All the articles I have seen only cover the simplistic stuff.

Answer 1

[T]o tell me which widget has the focus[...w]hat is the equivalent code in Ruby under Linux?
Fairly equivalently, if you have three Tk objects (for example), then you can say (in Ruby):
array = [tk_object_1, tk_object_2, tk_object_3]
path = Tk.focus.path
index = array.find_index {|e| e.path == path}
object = array.at index
EDIT: Or, more simply:
object = Tk.focus
Here's how to determine which object (of your many Tk objects) this is:
array = [tk_object_1, tk_object_2, tk_object_3]
index = array.find_index {|e| e == object}
(End of edit.)
I managed to locate documentation for the focus method (in both the
Ruby wrapper
and the original
Tcl)
and for the path method (in the
Ruby wrapper).
I wrote a program which demonstrates setting and getting the focus:
require 'tk'
def focus_array
#focus_array ||= [
f_content, e_content,
to_one, e_one,
to_two, e_two,
]
end
def focus_array_class_width_max
#focus_array_class_width_max ||= focus_array.map {|e| e.class.to_s.length}.max
end
def focus_delay
milliseconds = 1000
Tk.after milliseconds, lambda_focus_rotate
nil
end
def focus_force(object)
force = true
Tk.focus_to object, force
nil
end
def focus_print
path = Tk.focus.path
index = focus_array.find_index {|e| e.path == path}
s = klass_justified index
puts "Item #{index}'s class and path are: #{s} #{path}"
nil
end
def focus_rotate
#counter += 1
index = #counter % focus_array.length
puts '' if 0 == index
focus_force focus_array.at index
nil
end
def klass_justified(index)
focus_array.at(index).class.to_s.ljust focus_array_class_width_max
end
def lambda_focus_rotate
#lambda_focus_rotate ||= Kernel.lambda do
focus_rotate
focus_print
focus_delay
end
end
def main
root.title = 'Root'
objects_create
#counter = -1 # Start before first.
focus_delay
Tk.mainloop
nil
end
def objects_create
# Keep order:
e_content
e_one
e_two
nil
end
def spacing_set(object)
object.width 7
object.grid padx: 40
end
#-------------
# Tk objects:
def e_content
#e_content ||= begin
e = Tk::Tile::Entry.new f_content
spacing_set e
end
end
def e_one
#e_one ||= begin
e = Tk::Tile::Entry.new to_one
spacing_set e
end
end
def e_two
#e_two ||= begin
e = Tk::Tile::Entry.new to_two
spacing_set e
end
end
def f_content
$f_content ||= begin
f = Tk::Tile::Frame.new root
f.grid
end
end
def root
$root ||= TkRoot.new
end
def to_one
#to_one ||= TkToplevel.new f_content
end
def to_two
#to_two ||= TkToplevel.new f_content
end
main
It works for me using Ruby 2.2.5 (with Tk 8.5.12) on Windows 7.
Is there a good book or article about low-level Ruby Tk? All the articles I have seen only cover the simplistic stuff.
To my knowledge, no one has written a thorough description of Ruby's wrapper for Tk (at least, not in English). However, we have the wrapper's
RDoc
documentation, and we can read books describing how to use Tk from other languages. I think the best one (for Ruby purposes) is Learning Perk/Tk by Nancy Walsh (1999). Here are its links at
Amazon,
Alibris
and
O'Reilly (along with its example code).
Also we can grep the wrapper's library source code (since it's installed on our computers).
Doing so for the constant TkToplevel (for example) leads to the file /Ruby/lib/ruby/2.2.0/tk/toplevel.rb (or wherever that file resides on your system).
In that file, searching (for the string TkToplevel) reveals that the constant seems to be defined as an alias for class Tk::Toplevel, which is documented
here.
Ultimately it takes fairly difficult effort to investigate how to do unusual things in Ruby with Tk.
Good results regarding particular issues have been obtained by asking on the
Ruby forum.
The
TkDocs
tutorial is very helpful, along with the Tcl-language
Tk commands
reference documentation.