rubeus 0.0.1-java → 0.0.2-java

data/lib/rubeus/awt/attributes.rb

@@ -0,0 +1,51 @@
+module Rubeus::Awt
+  module Attributes
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_eval do
+        alias :new_without_attributes :new
+        alias :new :new_with_attributes
+      end
+    end
+    
+    module ClassMethods
+      def new_with_attributes(*args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        result = self.new_without_attributes(*args, &block)
+        attributes = ((@class_to_default_attributes || {})[self.java_class.name] || {}).merge(options)
+        if respond_to?(:update_attributes)
+          update_attributes(result, attributes)
+        else
+          attributes.each do |attr, value|
+            begin
+              result.send("#{attr.to_s}=", value)
+            rescue
+              raise ArgumentError, "Failed setting #{value.inspect} to #{attr.inspect} cause of #{$!.to_s}"
+            end
+          end
+        end
+        result
+      end
+      
+      def default_attributes(attributes = nil)
+        self.default_attributes = attributes if attributes
+        result = {}
+        @class_to_default_attributes ||= {}
+        classes = self.ancestors.select{|klass| 
+          !klass.java_class.interface? and klass.respond_to?(:default_attributes)}
+        classes.reverse.each do |klass|
+          if attrs = @class_to_default_attributes[klass.java_class.name]
+            result.update(attrs)
+          end
+        end
+        result
+      end
+      
+      def default_attributes=(attributes)
+        @class_to_default_attributes ||= {}
+        @class_to_default_attributes[self.java_class.name] ||= (attributes || {})
+      end
+      
+    end
+  end
+end

data/lib/rubeus/awt/event.rb

@@ -0,0 +1,133 @@
+module Rubeus::Awt
+  module Event
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def uncapitalize(str)
+        str[0..0].downcase + str[1..-1]
+      end
+    end
+    
+    def find_java_method(method_name, &block)
+      klass = self.java_class
+      while klass
+        method = klass.declared_instance_methods.detect do |m|
+          (m.name == method_name) and (block_given? ? yield(m) : true)
+        end
+        return method if method
+        klass = klass.superclass
+      end
+      nil
+    end
+
+    def events
+      self.event_types.inject({}){|dest, event_type|
+        dest[event_type] = event_methods(event_type); dest}
+    end
+
+    def event_types
+      self.methods.map{|m| /^add\_(.*?)\_listener$/ =~ m ? $1 : nil }.compact.sort
+    end
+
+    def event_methods(event_type, *methods)
+      listener_interface = listener_interface(event_type)
+      listener_interface.declared_instance_methods.map{|method|
+        method.name.underscore}
+    end
+
+    NULL_METHOD = Proc.new{}
+
+    private
+    def build_hash_comparision(options, option_key, method, inverse, comparision_options = nil)
+      comparision_options ||= options[option_key]
+      return nil unless comparision_options
+      "#{option_key.inspect} option must be a hash" unless comparision_options.is_a?(Hash)
+      Proc.new do |event|
+        matched = comparision_options.send(method){|key, value| event.send(key) == value}
+        inverse ? !matched : matched
+      end
+    end
+
+    def build_listener_filters(options)
+      filters = []
+      [:if, :unless].each do |condition|
+        [:any, :all].each do |joiner|
+          filters << build_hash_comparision(options, 
+            "#{condition.to_s}_#{joiner.to_s}".to_sym, 
+            "#{joiner.to_s}?", condition == :unless)
+        end
+      end
+      if filters.empty?
+        filters << build_hash_comparision(options, :if, :all?, false) if options[:if]
+        filters << build_hash_comparision(options, :unless, :all?, true) if options[:unless]
+      end
+      unless filters.empty? and options.empty?
+        filters << build_hash_comparision(nil, :if, :all?, false, options)
+      end
+      filters.compact!
+      filters
+    end
+
+    public
+    def listen(event_type, *methods, &block)
+      options = methods.last.is_a?(Hash) ? methods.pop : {}
+      filters = build_listener_filters(options)
+      listener_block = filters.empty? ? block :
+        Proc.new do |event|
+          block.call(event) if filters.all?{|filter| filter.call(event)}
+        end
+
+      listener_interface = listener_interface(event_type)
+      lister_methods = listener_interface.declared_instance_methods.map{|method| method.name}
+      handling_methods = methods.empty? ?
+        lister_methods :
+        methods.map{|method| invokable_method(lister_methods, event_type, method)}.compact
+      mod = Module.new do
+        lister_methods.each do |listener_method|
+          if handling_methods.include?(listener_method) 
+            define_method(listener_method){|*args| listener_block.call(*args)}
+          else
+            define_method(listener_method, &NULL_METHOD)
+          end
+        end
+      end
+      method_name = "add#{event_type.to_s.camelize}Listener"
+      listener = Object.new
+      listener.extend(mod)
+      send(method_name, listener)
+      listener
+    end
+
+    private
+    def listener_interface(event_type)
+      java_event_name = event_type.to_s.camelize
+      method_name = "add#{java_event_name}Listener"
+      java_method = 
+        find_java_method(method_name){|m|m.parameter_types.length == 1} || 
+        find_java_method(method_name)
+      raise "unsupported event '#{java_event_name}' for #{self.class.name}" unless java_method
+      if java_method.parameter_types.length != 1
+        method_name = "%s(%s)" % [java_method.name, java_method.parameter_types.map{|t|t.name}.join(',')]
+        raise "unsupported evnet method #{method_name} for #{java_method.declaring_class.name}" 
+      end
+      java_method.parameter_types.first
+    end
+
+    def invokable_method(java_methods, base_event_type, base_name)
+      base_name = base_name.to_s
+      return base_name if java_methods.include?(base_name)
+      s = self.class.uncapitalize(base_name)
+      return s if java_methods.include?(s)
+      s = self.class.uncapitalize(base_name.camelize)
+      return s if java_methods.include?(s)
+      even_type = self.class.uncapitalize(base_event_type.to_s.camelize)
+      s = "#{even_type}#{base_name}"
+      return s if java_methods.include?(s)
+      s = "#{even_type}#{base_name.camelize}"
+      return s if java_methods.include?(s)
+      return nil
+    end
+  end
+end

data/lib/rubeus/awt/extensions/component.rb

@@ -0,0 +1,14 @@
+Rubeus::Awt.depend_on("Dimension")
+
+module Rubeus::Awt::Extensions
+  module Component
+    def self.included(base)
+      base.module_eval do
+        include Rubeus::Awt::Attributes
+        include Rubeus::Awt::Nestable
+        include Rubeus::Awt::Event
+        include Rubeus::Awt::Setters
+      end
+    end
+  end
+end

data/lib/rubeus/awt/extensions/container.rb

@@ -0,0 +1,6 @@
+Rubeus::Awt.depend_on("Component")
+
+module Rubeus::Awt::Extensions
+  module Container
+  end
+end

data/lib/rubeus/awt/extensions/dimension.rb

@@ -0,0 +1,24 @@
+module Rubeus::Awt::Extensions
+  module Dimension
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def create(*args)
+        values = args
+        if args.length == 1
+          if args.first.is_a?(Array)
+            return create(*args.first)
+          elsif args.first.is_a?(Rubeus::Awt::Dimension)
+            return args.first
+          else
+            values = args.first.to_s.split("x", 2)
+          end
+        end
+        new(*values.map{|s|s.to_i})
+      end
+    end
+  end
+end
+

data/lib/rubeus/awt/extensions.rb

@@ -0,0 +1,4 @@
+module Rubeus::Awt
+  module Extensions
+  end
+end

data/lib/rubeus/awt/nestable.rb

@@ -0,0 +1,88 @@
+module Rubeus::Awt
+  module Nestable
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.instance_eval do
+        alias :new_without_nestable :new
+        alias :new :new_with_nestable
+      end
+    end
+    
+    class Context
+      def self.container_class_names
+        @container_class_names ||= []
+      end
+
+      def self.container_class_names=(*class_names)
+        @container_class_names = class_names
+      end
+
+      def self.register_as_container(*class_names)
+        self.container_class_names.concat(class_names)
+      end
+
+      def self.add_component_if_container_exist(component, &block)
+        @container ||= nil
+        @container.send(@action, component) if @container
+      end
+
+      def self.add_new_component_to(container, action = :add, block_argument = nil, &block)
+        former_container = @container
+        former_action = @action
+        @container = container
+        @action = action
+        begin
+          yield(block_argument || container)
+        ensure
+          @container = former_container
+          @action = former_action
+        end
+      end
+      
+      def self.container
+        @container
+      end
+    end
+    
+    
+    module ClassMethods
+      def new_with_nestable(*args, &block)
+        object = self.new_without_nestable(*args)
+        Context.add_component_if_container_exist(object)
+        return object unless block_given?
+        process_block_for_new(object, &block)
+        return object
+      end
+
+      def constianer?
+        Context.container_class_names.include?(self.java_class.name)
+      end
+
+      def perform_as_container
+        Context.container_class_names << self.java_class.name
+      end
+
+      def perform_as_containee
+        Context.container_class_names.delete(self.java_class.name)
+      end
+
+      def process_block_for_new(object, &block)
+        if self.constianer?
+          self.add_new_component_to(object, &block)
+        elsif object.respond_to?(:listen)
+          object.listen(*self.default_event_type, &block)
+        else
+          raise "#{self.java_class.name} doesn't support process_block_for_new"
+        end
+      end
+
+      def add_new_component_to(object, &block)
+        Context.add_new_component_to(object, &block)
+      end
+
+      def default_event_type
+        :action
+      end
+    end
+  end
+end

data/lib/rubeus/awt/setters.rb

@@ -0,0 +1,26 @@
+Rubeus::Awt.depend_on("Dimension")
+
+module Rubeus::Awt
+  module Setters
+    
+    def self.included(base)
+      base.module_eval do
+        alias_method :set_preferred_size_without_rubeus, :set_preferred_size
+        alias_method :set_preferred_size, :set_preferred_size_with_rubeus
+        alias_method :preferred_size=, :set_preferred_size_with_rubeus
+        
+        alias_method :set_size_without_rubeus, :set_size
+        alias_method :set_size, :set_size_with_rubeus
+        alias_method :size=, :set_size_with_rubeus
+      end
+    end
+    
+    def set_preferred_size_with_rubeus(*args)
+      set_preferred_size_without_rubeus(Rubeus::Awt::Dimension.create(*args))
+    end
+    
+    def set_size_with_rubeus(*args)
+      set_size_without_rubeus(Rubeus::Awt::Dimension.create(*args))
+    end
+  end
+end

data/lib/rubeus/awt.rb

@@ -0,0 +1,14 @@
+require "rubeus/component_loader"
+
+module Rubeus
+  extensions_path = File.join(File.dirname(__FILE__), "awt", "extensions")
+  Awt = ComponentLoader.new("java.awt", extensions_path) do
+    base_path = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    Dir.glob(File.join(base_path, 'rubeus', 'awt', '*.rb')) do |file|
+      rel_path = file.gsub("#{base_path}/", '')
+      autoload(File.basename(rel_path, '.*').camelize, rel_path.gsub(/\.rb$/, ''))
+    end
+  end
+end
+
+require "rubeus/awt/extensions"

data/lib/rubeus/component_loader.rb

@@ -0,0 +1,103 @@
+module Rubeus
+  class ComponentLoader < Module
+    attr_reader :java_package, :ruby_module_path, :base_path
+
+    def self.find_base_path(path)
+      path = File.expand_path(path)
+      $LOAD_PATH.detect{|load_path| path.include?(File.expand_path(load_path))}
+    end
+    
+    def initialize(java_package, ruby_module_path, base_path = nil, &block)
+      @java_package, @ruby_module_path, @base_path =
+        java_package, ruby_module_path, base_path
+      @base_path ||= ComponentLoader.find_base_path(ruby_module_path)
+      @ruby_module_holder_name = File.basename(ruby_module_path).camelize
+      super(&block)
+    end
+    
+    def ruby_module_holder
+       @ruby_module_holder ||= (self.const_get(@ruby_module_holder_name) rescue nil)
+      unless @ruby_module_holder
+        self.const_set(@ruby_module_holder_name, Module.new)
+        @ruby_module_holder =  self.const_get(@ruby_module_holder_name)
+      end
+      @ruby_module_holder
+    end
+    
+    def extended(object)
+      mod = Module.new do
+        def const_missing(java_class_name)
+          @loader.const_get(java_class_name)
+        end
+      end
+      object.instance_variable_set("@loader", self)
+      object.extend(mod)
+    end
+    
+    def autolodings
+      @autolodings ||= {}
+    end
+    
+    def autoload(const_name, feature = nil)
+      autolodings[const_name.to_s] = feature ||"#{self.name}::#{java_class_name.to_s}".underscore
+    end
+    
+    def autoload?(const_name)
+      autolodings[const_name.to_s]
+    end
+    
+    def const_missing(java_class_name)
+      if autoload?(java_class_name)
+        feature = autolodings.delete(java_class_name.to_s) 
+        require(feature)
+        return const_get(java_class_name)
+      end
+      if java_class_name.to_s == @ruby_module_holder_name.to_s
+        raise NameError, java_class_name
+      end
+      if java_class_name.to_s.include?('::')
+        names = java_class_name.to_s.split('::', 2)
+        package = names.first
+        mod = ComponentLoader.new(
+          [@java_package, package.underscore].join('.'),
+          File.join(@ruby_module_path, package.underscore),
+          @base_path)
+        self.const_set(package.camelize, mod)
+        mod.const_get(names.last)
+      else
+        begin
+          require(File.join(@ruby_module_path, java_class_name.to_s.underscore))
+        rescue LoadError => e
+          # puts "warning: #{e}"
+        end
+        java_fqn = to_java_fqn(java_class_name)
+        extension = nil
+        begin
+          extension = self.ruby_module_holder.const_get(java_class_name)
+        rescue
+          # puts "warning: #{$!.inspect}"
+        end
+        if extension
+          JavaUtilities.extend_proxy(java_fqn) do
+            include extension 
+          end
+        end
+        result = instance_eval(java_fqn)
+        self.const_set(java_class_name, result)
+        result
+      end
+    rescue
+      puts $!
+      puts $!.backtrace.join("\n  ")
+      super
+    end
+
+    def to_java_fqn(java_class_name)
+      "#{java_package}.#{java_class_name}"
+    end
+    
+    def depend_on(*java_class_names)
+      java_class_names.each{|java_class_name| self.const_get(java_class_name)}
+    end
+  end
+end

data/lib/rubeus/swing/extensions/box_layout.rb

@@ -0,0 +1,28 @@
+module Rubeus::Swing::Extensions
+  module BoxLayout
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_eval do 
+        alias :new_without_nestable :new
+        alias :new :new_with_nestable
+      end
+    end
+    
+    module ClassMethods
+      def new_with_nestable(*args, &block)
+        if args.length == 1
+          container = Rubeus::Awt::Nestable::Context.container
+          raise ArgumentError, "No container! you must specify a Container and an axis" unless container
+          args.unshift(container.respond_to?(:content_pane) ? container.content_pane : container)
+        end
+        
+        unless args.last.is_a?(Integer)
+          value = args.pop
+          args << const_get(value.to_s)
+        end
+        
+        new_without_nestable(*args, &block)
+      end
+    end
+  end
+end

data/lib/rubeus/swing/extensions/j_applet.rb

@@ -0,0 +1,7 @@
+module Rubeus::Swing::Extensions
+  module JApplet
+    def self.included(klass)
+      klass.perform_as_container
+    end
+  end
+end

data/lib/rubeus/swing/extensions/j_component.rb

@@ -0,0 +1,19 @@
+Rubeus::Awt.depend_on("Container")
+
+module Rubeus::Swing::Extensions
+  module JComponent
+    
+    def self.included(base)
+      base.module_eval do
+        alias_method :set_preferred_size_without_rubeus, :set_preferred_size
+        alias_method :set_preferred_size, :set_preferred_size_with_rubeus
+        alias_method :preferred_size=, :set_preferred_size_with_rubeus
+      end
+    end
+    
+    def set_preferred_size_with_rubeus(*args)
+      set_preferred_size_without_rubeus(Rubeus::Awt::Dimension.create(*args))
+    end
+    
+  end
+end

data/lib/rubeus/swing/extensions/j_frame.rb

@@ -0,0 +1,27 @@
+Rubeus::Awt.depend_on('Container', 'Window', 'Frame')
+Rubeus::Swing.depend_on('JPanel')
+
+module Rubeus::Swing::Extensions
+  module JFrame
+    def self.included(base)
+      base.perform_as_container
+      base.default_attributes = {
+        :size => [400, 300],
+        :default_close_operation => javax.swing.JFrame::EXIT_ON_CLOSE
+      }
+      if ENV_JAVA["java.specification.version"] == "1.6"
+        base.module_eval do
+          alias_method :set_size_without_rubeus, :set_size
+          alias_method :set_size, :set_size_with_rubeus
+          alias_method :size=, :set_size_with_rubeus
+        end
+      end
+    end
+    
+    if ENV_JAVA["java.specification.version"] == "1.6"
+      def set_size_with_rubeus(*args)
+        set_size_without_rubeus(Rubeus::Awt::Dimension.create(*args))
+      end
+    end
+  end
+end

data/lib/rubeus/swing/extensions/j_panel.rb

@@ -0,0 +1,9 @@
+Rubeus::Swing.depend_on("JComponent")
+
+module Rubeus::Swing::Extensions
+  module JPanel
+    def self.included(base)
+      base.perform_as_container
+    end
+  end
+end

data/lib/rubeus/swing/extensions/j_scroll_pane.rb

@@ -0,0 +1,7 @@
+JavaUtilities.extend_proxy('javax.swing.JScrollPane') do
+  perform_as_container
+  
+  def self.add_new_component_to(object, &block)
+    Rubeus::Awt::Nestable::Context.add_new_component_to(object.viewport, :set_view, object, &block)
+  end
+end

data/lib/rubeus/swing/extensions/j_split_pane.rb

@@ -0,0 +1,15 @@
+JavaUtilities.extend_proxy('javax.swing.JSplitPane') do
+  perform_as_container
+
+  def self.add_new_component_to(object, &block)
+    Rubeus::Awt::Nestable::Context.add_new_component_to(object, :append_component, &block)
+  end
+  
+  def append_component(component)
+    append_method =
+      (self.orientation == javax.swing.JSplitPane::VERTICAL_SPLIT) ?
+        (top_component ? :set_bottom_component : :set_top_component) :
+        (left_component ? :set_right_component : :set_left_component)
+    send(append_method, component)
+  end
+end

data/lib/rubeus/swing/extensions/j_text_field.rb

@@ -0,0 +1,5 @@
+JavaUtilities.extend_proxy("javax.swing.JTextField") do
+  def self.default_event_type
+    return :key, :pressed
+  end
+end

data/lib/rubeus/swing/extensions/j_window.rb

@@ -0,0 +1,3 @@
+JavaUtilities.extend_proxy('javax.swing.JWindow') do
+  perform_as_container
+end

data/lib/rubeus/swing/extensions.rb

@@ -0,0 +1,4 @@
+module Rubeus::Swing
+  module Extensions
+  end
+end

data/lib/rubeus/swing.rb

@@ -0,0 +1,42 @@
+require "rubeus/component_loader"
+
+module Rubeus
+  extensions_path = File.join(File.dirname(__FILE__), "swing", "extensions")
+  Swing = ComponentLoader.new("javax.swing", extensions_path) do
+    
+    def self.irb
+      Object.send(:extend, self)
+    end
+  end
+end
+
+require "rubeus/swing/extensions"
+
+require "rubeus/awt/attributes"
+require "rubeus/awt/nestable"
+require "rubeus/awt/event"
+
+
+=begin
+import "javax.swing.JFrame"
+
+require "swing_ext"
+
+frame = JFrame.new("JDBC Query")
+frame.set_size(400, 300)
+frame.default_close_operation = JFrame::EXIT_ON_CLOSE
+frame.events
+frame.event_methods(:key)
+frame.event_methods(:key, :typed)
+frame.event_methods(:key, "typed")
+frame.event_methods(:key, :keyTyped)
+frame.event_methods(:key, :keyTyped)
+frame.event_methods(:key, "key_typed")
+frame.event_methods(:key, "key_Typed")
+
+frame.events.each
+
+frame.visible = true
+
+=end
+

data/lib/rubeus.rb

@@ -0,0 +1,10 @@
+require "rubygems"
+gem "activesupport", ">=2.0.2"
+# require "active_support"
+require "active_support/core_ext/string"
+
+module Rubeus
+  VERSION = "0.0.2"
+  autoload :Awt, "rubeus/awt"
+  autoload :Swing, "rubeus/swing"
+end

metadata

@@ -3,12 +3,38 @@ extensions: []
 homepage: http://code.google.com/p/rubeus/
 executables: []
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 post_install_message: 
-date: 2008-06-20 15:00:00 +00:00
+date: 2008-06-28 15:00:00 +00:00
 files: 
-- lib/swing_ext.rb
-rubygems_version: 1.1.0
+- lib/rubeus
+- lib/rubeus.rb
+- lib/rubeus/awt
+- lib/rubeus/awt.rb
+- lib/rubeus/component_loader.rb
+- lib/rubeus/swing
+- lib/rubeus/swing.rb
+- lib/rubeus/awt/attributes.rb
+- lib/rubeus/awt/event.rb
+- lib/rubeus/awt/extensions
+- lib/rubeus/awt/extensions.rb
+- lib/rubeus/awt/nestable.rb
+- lib/rubeus/awt/setters.rb
+- lib/rubeus/awt/extensions/component.rb
+- lib/rubeus/awt/extensions/container.rb
+- lib/rubeus/awt/extensions/dimension.rb
+- lib/rubeus/swing/extensions
+- lib/rubeus/swing/extensions.rb
+- lib/rubeus/swing/extensions/box_layout.rb
+- lib/rubeus/swing/extensions/j_applet.rb
+- lib/rubeus/swing/extensions/j_component.rb
+- lib/rubeus/swing/extensions/j_frame.rb
+- lib/rubeus/swing/extensions/j_panel.rb
+- lib/rubeus/swing/extensions/j_scroll_pane.rb
+- lib/rubeus/swing/extensions/j_split_pane.rb
+- lib/rubeus/swing/extensions/j_text_field.rb
+- lib/rubeus/swing/extensions/j_window.rb
+rubygems_version: 1.1.1
 rdoc_options: []
 signing_key: 
 cert_chain: []
@@ -34,7 +60,16 @@ require_paths:
 - lib
 specification_version: 2
 test_files: []
-dependencies: []
+dependencies: 
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement
+    version: 
+    requirements: 
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
 description: 
 email: rubeus@googlegroups.com
 authors: 

data/lib/swing_ext.rb

@@ -1,295 +0,0 @@
-class << java.swing
-  def container_class_names
-    @container_class_names ||= []
-  end
-  
-  def container_class_names=(*class_names)
-    @container_class_names = class_names
-  end
-  
-  def register_as_container(*class_names)
-    self.container_class_names.concat(class_names)
-  end
-  
-  def add_component_if_container_exist(component, &block)
-    @container ||= nil
-    @container.send(@action, component) if @container
-  end
-  
-  def add_new_component_to(container, action = :add, block_argument = nil, &block)
-    former_container = @container
-    former_action = @action
-    @container = container
-    @action = action
-    begin
-      yield(block_argument || container)
-    ensure
-      @container = former_container
-      @action = former_action
-    end
-  end
-end
-
-
-java.swing.register_as_container(
-  'javax.swing.JApplet',
-  'javax.swing.JFrame',
-  'javax.swing.JPanel',
-  'javax.swing.JScrollPane',
-  'javax.swing.JSplitPane',
-  'javax.swing.JWindow'
-  )
-
-JavaUtilities.extend_proxy('javax.swing.JComponent') do
-  def set_preferred_size_with_rubeus(*args)
-    values = args
-    if args.length == 1
-      if args.first.is_a?(java.awt.Dimension)
-        return set_preferred_size_without_rubeus(*args)
-      else
-        values = args.first.to_s.split("x", 2)
-      end
-    end
-    set_preferred_size_without_rubeus(java.awt.Dimension.new(*values.map{|s|s.to_i}))
-  end
-  
-  alias_method :set_preferred_size_without_rubeus, :set_preferred_size
-  alias_method :set_preferred_size, :set_preferred_size_with_rubeus
-end
-
-
-JavaUtilities.extend_proxy('java.awt.Component') do
-  def self.new_with_nestable(*args, &block)
-    object = self.new_without_nestable(*args)
-    java.swing.add_component_if_container_exist(object)
-    return object unless block_given?
-    initial_nest(object, &block)
-    return object
-  end
-  
-  self.instance_eval do
-    alias :new_without_nestable :new
-    alias :new :new_with_nestable
-  end
-  
-  def self.constianer?
-    java.swing.container_class_names.include?(self.java_class.name)
-  end
-  
-  def self.perform_as_container
-    @as_container = true
-  end
-  
-  def self.perform_as_containee
-    @as_container = false
-  end
-  
-  def self.initial_nest(object, &block)
-    if self.constianer?
-      self.add_new_component_to(object, &block)
-    elsif object.respond_to?(:listen)
-      object.listen(*self.default_event_type, &block)
-    else
-      raise "#{self.java_class.name} doesn't support initial_nest"
-    end
-  end
-
-  def self.add_new_component_to(object, &block)
-    java.swing.add_new_component_to(object, &block)
-  end
-  
-  def self.default_event_type
-    :action
-  end
-  
-  def self.camelize(str)
-    parts = str.to_s.split('_')
-    parts.map{|part| part[0..0].upcase + part[1..-1].downcase}.join
-  end
-  
-  def self.underscore(camel_cased_word)
-    camel_cased_word.to_s.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-  end
-  
-  def self.uncapitalize(str)
-    str[0..0].downcase + str[1..-1]
-  end
-  
-  def find_java_method(method_name, &block)
-    klass = self.java_class
-    while klass
-      method = klass.declared_instance_methods.detect do |m|
-        (m.name == method_name) and (block_given? ? yield(m) : true)
-      end
-      return method if method
-      klass = klass.superclass
-    end
-    nil
-  end
-  
-  def events
-    self.event_types.inject({}){|dest, event_type|
-      dest[event_type] = event_methods(event_type); dest}
-  end
-  
-  def event_types
-    self.methods.map{|m| /^add\_(.*?)\_listener$/ =~ m ? $1 : nil }.compact.sort
-  end
-  
-  def event_methods(event_type, *methods)
-    listener_interface = listener_interface(event_type)
-    listener_interface.declared_instance_methods.map{|method|
-      self.class.underscore(method.name)}
-  end
-  
-  NULL_METHOD = Proc.new{}
-  
-  private
-  def build_hash_comparision(options, option_key, method, inverse, comparision_options = nil)
-    comparision_options ||= options[option_key]
-    return nil unless comparision_options
-    "#{option_key.inspect} option must be a hash" unless comparision_options.is_a?(Hash)
-    Proc.new do |event|
-      matched = comparision_options.send(method){|key, value| event.send(key) == value}
-      inverse ? !matched : matched
-    end
-  end
-  
-  def build_listener_filters(options)
-    filters = []
-    [:if, :unless].each do |condition|
-      [:any, :all].each do |joiner|
-        filters << build_hash_comparision(options, 
-          "#{condition.to_s}_#{joiner.to_s}".to_sym, 
-          "#{joiner.to_s}?", condition == :unless)
-      end
-    end
-    if filters.empty?
-      filters << build_hash_comparision(options, :if, :all?, false) if options[:if]
-      filters << build_hash_comparision(options, :unless, :all?, true) if options[:unless]
-    end
-    unless filters.empty? and options.empty?
-      filters << build_hash_comparision(nil, :if, :all?, false, options)
-    end
-    filters.compact!
-    filters
-  end
-  
-  public
-  def listen(event_type, *methods, &block)
-    options = methods.last.is_a?(Hash) ? methods.pop : {}
-    filters = build_listener_filters(options)
-    listener_block = filters.empty? ? block :
-      Proc.new do |event|
-        block.call(event) if filters.all?{|filter| filter.call(event)}
-      end
-    
-    listener_interface = listener_interface(event_type)
-    lister_methods = listener_interface.declared_instance_methods.map{|method| method.name}
-    handling_methods = methods.empty? ?
-      lister_methods :
-      methods.map{|method| invokable_method(lister_methods, event_type, method)}.compact
-    mod = Module.new do
-      lister_methods.each do |listener_method|
-        if handling_methods.include?(listener_method) 
-          define_method(listener_method){|*args| listener_block.call(*args)}
-        else
-          define_method(listener_method, &NULL_METHOD)
-        end
-      end
-    end
-    method_name = "add#{self.class.camelize(event_type)}Listener"
-    listener = Object.new
-    listener.extend(mod)
-    send(method_name, listener)
-    listener
-  end
-
-  private
-  def listener_interface(event_type)
-    java_event_name = self.class.camelize(event_type)
-    method_name = "add#{java_event_name}Listener"
-    java_method = 
-      find_java_method(method_name){|m|m.parameter_types.length == 1} || 
-      find_java_method(method_name)
-    raise "unsupported event '#{java_event_name}' for #{self.class.name}" unless java_method
-    if java_method.parameter_types.length != 1
-      method_name = "%s(%s)" % [java_method.name, java_method.parameter_types.map{|t|t.name}.join(',')]
-      raise "unsupported evnet method #{method_name} for #{java_method.declaring_class.name}" 
-    end
-    java_method.parameter_types.first
-  end
-  
-  def invokable_method(java_methods, base_event_type, base_name)
-    base_name = base_name.to_s
-    return base_name if java_methods.include?(base_name)
-    s = self.class.uncapitalize(base_name)
-    return s if java_methods.include?(s)
-    s = self.class.uncapitalize(self.class.camelize(base_name))
-    return s if java_methods.include?(s)
-    even_type = self.class.uncapitalize(self.class.camelize(base_event_type))
-    s = "#{even_type}#{base_name}"
-    return s if java_methods.include?(s)
-    camelized = self.class.camelize(base_name)
-    s = "#{even_type}#{camelized}"
-    return s if java_methods.include?(s)
-    return nil
-  end
-end
-
-JavaUtilities.extend_proxy("javax.swing.JTextField") do
-  def self.default_event_type
-    return :key, :pressed
-  end
-end
-
-JavaUtilities.extend_proxy('javax.swing.JScrollPane') do
-  def self.add_new_component_to(object, &block)
-    java.swing.add_new_component_to(object.viewport, :set_view, object, &block)
-  end
-end
-
-JavaUtilities.extend_proxy('javax.swing.JSplitPane') do
-  def self.add_new_component_to(object, &block)
-    java.swing.add_new_component_to(object, :append_component, &block)
-  end
-  
-  def append_component(component)
-    append_method =
-      (self.orientation == javax.swing.JSplitPane::VERTICAL_SPLIT) ?
-        (top_component ? :set_bottom_component : :set_top_component) :
-        (left_component ? :set_right_component : :set_left_component)
-    send(append_method, component)
-  end
-  
-end
-
-
-
-=begin
-import "javax.swing.JFrame"
-
-require "swing_ext"
-
-frame = JFrame.new("JDBC Query")
-frame.set_size(400, 300)
-frame.default_close_operation = JFrame::EXIT_ON_CLOSE
-frame.events
-frame.event_methods(:key)
-frame.event_methods(:key, :typed)
-frame.event_methods(:key, "typed")
-frame.event_methods(:key, :keyTyped)
-frame.event_methods(:key, :keyTyped)
-frame.event_methods(:key, "key_typed")
-frame.event_methods(:key, "key_Typed")
-
-frame.events.each
-
-frame.visible = true
-
-=end
-