button.on_clicked {
p ‘clicked good’
}

if you set it within the JButton class
see:
https://gist.github.com/705822

Replacing @block.call with “instance_eval @block” should solve the context problem you outlined.

Block remembers context in which it was defined. So when you finally invoke:

block.call

in your example you’ll most probably notice that ’self’ isn’t necesserily the instance of ActionListener itself. Your example works fine however, it will cease to do so whenever you create instance of ActionListener inside some other class’ method. I’m trying to figure out how to make it work in such cases too. Any ideas?

You’ll have to do something with a block, like in the event proxy shown in the post. The problem here is that the anonymous class you created doesn’t have access to variables which exist solely within the scope of the Kernel override (which is what a non-class script is). Your other options is to encase the entire example in a class and make the anonymous class a top-level class in the same way as the example class. Not a terribly good solution IMHO. If I were you, I’d use the block proxy.

I then use @@textfield and it worked but i dont think it is a good way of doing this.
How can i do the same thing but without using @@

@@tfTexto = JTextField.new 15

listener = Class.new(ActionListener).new
def listener.actionPerformed(e)
puts @@tfTexto.text
end

frame = JFrame.new ‘Test Frame’
frame.layout = FlowLayout.new
button = JButton.new ‘Click Me’
button.add @@tfTexto
button.addActionListener listener

frame.content_pane.add button

frame.setSize(200, 75)
frame.default_close_operation = JFrame::EXIT_ON_CLOSE
frame.visible = true

In any case, I’ve worked extensively with the Mozilla Rhino JavaScript engine in the past and it provides a very clean binding layer for listeners/anonymous classes that I thought I’d mention here:

IN JavaScript:

comp.addActionListener(function(event) {
//do what you need to do for the actionPerformed method
});

I would imagine that with JRuby, an equivalent would be:

comp.add_action_listener {|event|
//do what you need to do for the actionPerformed method
}

It should be possible for the JRuby engine to determine that the required type for addActionListener is of type ActionListener and that there is only one method on the interface definition, therefore the block should be bound to that.

I hope JRuby integrates something like that in the future. I’ll use the anonymous syntax described by Martin in the meantime.

Thanks for your reply. I was just searching for an easy way of defining anonymous classes.
And, maybe I can’t hide my java-roots but this syntax seemed easy to understand and easy to define without any auxiliary method or library. (Okay, a little change like that what you posted is still necessary). I believe that I would use the proxy_method in some cases and the other in some other cases. Both seems acceptable to me.

Honestly, I wasn’t aware of that particular JRuby syntax trick. That does have certain advantages, but it’s still a little bulky syntactically. It would depend on my mood which I would prefer (proxy_method or JavaProxy).

Incidentally, you can make this work like so:

module JavaClassProxy
def initialize(&block)
block.call
end
end

ActionListener = java.awt.event.ActionListener

class ActionListener
include JavaClassProxy
end

ActionListener.new do
def actionPerformed(e) # we do need the method parameter
puts “clicked”
end
end

I haven’t tested the above code, but afaik it should work just fine.

module Swing
include_package ‘javax.swing’
include_package ‘java.awt’
include_package ‘java.awt.event’
end

button.add_action_listener(Swing::ActionListener.new do
def actionPerformed event
puts “Click!”
end
end)

Is it possible to provide the Java-Proxy-Classes with a block, which is then evaluated to add the defined methods to the proxy?
This would be similar to the concept of anonymous classes in Java. The lower code makes it possible to define methods via block evaluated by the initialize-method, but these are private, but it shows the concept. Methods defined via Module::define_method are public. Maybe that can be used to solve this problem.

I think a way that does not need thousands of Listener classes like the way with the proxy_method is good, but a way without calling a helper-method is even better. A way of defining anonymous classes
in a way that uses blocks seems best, because it is easy an can even be understood by Java-guys.

Is this possible or am I on the wrong way?

PSEUDO_CODE (does not work, but shows what I mean):
——————————————

class JavaProxy
def initialize &block
block.call # evaluates the block
end
end

include_class ‘java.awt.event.ActionListener’ #ActionListener is one of the JavaProxies

ActionListener.new do
def actionPerformed # define the method in a block, which is then evaluated
puts “CLICK!”
end
end