[lnkForumImage]
TotalShareware - Download Free Software
Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.ruby

Ruby/Tk: How to access surrounding class from Tk Callback?

u235321044

2/27/2006 11:52:00 AM

Assume that I'm modelling a visible form, consisting of entry fields,
buttons etc., as a class:

require 'tk'
class Form
def initialize(...)
@foo=1234
...
@root=TkRoot.new() { title "My Form" }
action_button=TkButton.new(@root) {
text "Action!"
command {
# Do something with @root and @foo
puts @root.foo # DOES NOT WORK
}
}
action_button.pack("side" => "right");
end
end

The problem is with the command routine inside the action_button:
Both @root and @foo are undefined here. Obviously, the class context
is not present anymore inside this callback function.

How would one model this situation in Ruby? In C++ terms: How do
I pass the 'this' pointer of my class into the command callback
of the button?

In my case, I happen to have only one instance of the Form, so
I could use a global variable, $form, to hold a reference to my
Form object and access it via this global, but of course this
solution would be ugly beyond imagination...

Kind regards,

Ronald





--
Sent by mn-pg-p-e-b-consultant-3.com from siemens subdomain of com
This is a spam protected message. Please answer with reference header.
Posted via http://www.usenet-re...
5 Answers

Hidetoshi NAGAI

2/27/2006 3:14:00 PM

0

u235321044

3/1/2006 8:21:00 AM

0

Hidetoshi NAGAI wrote:
> From: u235321044@spawnkill.ip-mobilphone.net (Ronald Fischer)
> > @root=TkRoot.new() { title "My Form" }
> > action_button=TkButton.new(@root) {
> > text "Action!"
> > command {
> > # Do something with @root and @foo
> > puts @root.foo # DOES NOT WORK
> > }
> > }
>
> It may be a FAQ.

Arigatou gozaimasu! But where can I find the FAQ? I was able to
locate one only in Japanese, and my Japanese is barely sufficient
to order some Yakitori, let alone reading such a FAQ.... :-(

Aside from a FAQ, a Ruby/Tk reference manual might be handy. Right
now I am "learning" Ruby/Tk by looking at examples I find on the
net, and *guessing* how they could work - not a very satisfying
means to grasp a new language.

> A block given to <TkWidget-class>.new method is
> evaluated by <the widget>.instance_eval(<the block>).
> That is, in the block, 'self' is the widget object.
> So, @root in your button's command is an instance variable
> of the button widget.

I understand.

> To avoid it, you have to give attention to scope of variables.
> For example,
> ------< example 1 >------------------------------------------
> def initialize(...)
> foo = @foo=1234
> ...
> root = @root = TkRoot.new() { title "My Form" }
> action_button=TkButton.new(@root) {
> text "Action!"
> command {
> # use local variables
> puts foo # same as @foo
> puts root # same as @root
> }
> }
> action_button.pack("side" => "right");
> end

I amazed that this works, but I don't know how. foo is a local
variable inside initialize, isn't it? So it should go out of scope
as soon as initialize ends. How then can I refer to it from inside
my action command?

> ------< example 2 >------------------------------------------
> def initialize(...)
> @foo=1234
> ...
> @root = TkRoot.new() { title "My Form" }
> action_button=TkButton.new(@root,
> :text=>"Action!",
> :command=>proc{
> puts @foo
> puts @root
> })
> action_button.pack("side" => "right");
> end

Here I have two questions: What is the meaning of the
colon in front of "command", and why can I access @root
now from inside command, but not in my original code?

> ------< example 3 >------------------------------------------
> def initialize(...)
> @foo=1234
> ...
> @root = TkRoot.new() { title "My Form" }
> cmd = proc{
> puts @foo
> puts @root
> }
> action_button=TkButton.new(@root) {
> text "Action!"
> command cmd
> }
> action_button.pack("side" => "right");
> end

This looks clever too. From a design point of view, I like solution 2
best, because it avoids the need for additional variables. Still would
like to understand, *why* it works.

Ronald






--
Spam protected message from:
Sent by mn-pg-p-e-b-consultant-3.com from siemens in field com
Posted via http://www.usenet-re...

u235321044

3/1/2006 9:20:00 AM

0

> > ------< example 2 >------------------------------------------
> > def initialize(...)
> > @foo=1234
> > ...
> > @root = TkRoot.new() { title "My Form" }
> > action_button=TkButton.new(@root,
> > :text=>"Action!",
> > :command=>proc{
> > puts @foo
> > puts @root
> > })
> > action_button.pack("side" => "right");
> > end
>
> Here I have two questions: What is the meaning of the
> colon in front of "command", and why can I access @root
> now from inside command, but not in my original code?

I think, I figured this out by myself: Instead of setting
text and command in an initialization procedure for the button,
you supply them as parameter (:command denotes the named parameter
"command" - I had used only positional parameters before, so I
was not aware of this possibility). Since the command procedure
is defined inside the list of actual parameters to the TkButton
constructor, they can access any variable within the scope of
the initialize function body; in particular, they can access
the member variables of the surrounding class.

Ronald







--
Spam protected message from:
Sent by mn-pg-p-e-b-consultant-3.com from siemens part of com
Posted via http://www.usenet-re...

Hidetoshi NAGAI

3/8/2006 2:37:00 PM

0

Clave

8/28/2012 5:02:00 PM

0

It's no mystery that modern conservatives pray for Democrats to become
homeless, starve and die.

It's the only way they can win elections.

Jim