jrubyfx-openjfx.patch 1.2.0-java

data/lib/jrubyfx/module.rb

@@ -0,0 +1,178 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+require_relative 'utils/common_utils'
+
+# This module contains useful methods for defining JavaFX code. Include it in your
+# class to use it, and the JRubyFX::FXImports. JRubyFX::Application and JRubyFX::Controller already include it.
+module JRubyFX
+  include JRubyFX::FXImports
+  include JRubyFX::Utils::CommonUtils
+
+  ##
+  # call-seq:
+  #   with(obj, hash) => obj
+  #   with(obj) { block } => obj
+  #   with(obj, hash) { block }=> obj
+  #
+  # Set properties (e.g. setters) on the passed in object plus also invoke
+  # any block passed against this object.
+  # === Examples
+  #
+  #   with(grid, vgap: 2, hgap: 2) do
+  #     set_pref_size(500, 400)
+  #     children << location << go << view
+  #   end
+  #
+  def with(obj, properties = {}, &block)
+    puts "Warning: calling 'with' on a nil object from #{caller[0]}" if obj.nil?
+    populate_properties(obj, properties)
+
+    if block_given?
+      # cache the proxy - http://wiki.jruby.org/Persistence
+      obj.class.__persistent__ = true if obj.class.ancestors.include? JavaProxy
+      obj.extend(JRubyFX)
+      obj.instance_eval(&block)
+    end
+
+    obj
+  end
+
+  ##
+  # call-seq:
+  #   run_later { block }
+  #
+  # Convenience method so anything can safely schedule to run on JavaFX
+  # main thread.
+  def run_later(&block)
+    Java::javafx.application.Platform.run_later &block
+  end
+
+  ##
+  # call-seq:
+  #   build(class) => obj
+  #   build(class, hash) => obj
+  #   build(class) { block } => obj
+  #   build(class, hash) { block } => obj
+  #
+  # Create "build" a new JavaFX instance with the provided class and
+  # set properties (e.g. setters) on that new instance plus also invoke
+  # any block passed against this new instance.  This also can build a proc
+  # or lambda form in which case the return value of the block will be what
+  # is used to set the additional properties on.
+  # === Examples
+  #
+  #   grid = build(GridPane, vgap: 2, hgap: 2) do
+  #     set_pref_size(500, 400)
+  #     children << location << go << view
+  #   end
+  #
+  #  build(proc { Foo.new }, vgap: 2, hgap: 2)
+  #
+  def build(klass, *args, &block)
+    args, properties = split_args_from_properties(*args)
+
+    obj = if klass.kind_of? Proc
+      klass.call(*args)
+    else
+      klass.new(*attempt_conversion(klass, :new, *args))
+    end
+
+    with(obj, properties, &block)
+  end
+
+  def self.included(mod)
+    mod.extend(JRubyFX::FXMLClassUtils)
+    mod.extend(JRubyFX::FXImports)
+  end
+
+  module FXMLClassUtils
+    def fxml_raw_accessor(symbol_name, type=java::lang::String)
+      # TODO: RDoc
+      # TODO: somebody clean this up
+      # TODO: _reader and _writer
+      send(:define_method, symbol_name.id2name.snake_case + "=") do |val|
+        instance_variable_set("@#{symbol_name}", val)
+      end
+      send(:define_method, symbol_name.id2name.snake_case) do
+        instance_variable_get("@#{symbol_name}")
+      end
+      send(:define_method, symbol_name.id2name.snake_case + "GetType") do
+        return type.java_class
+      end
+      camel = symbol_name.id2name
+      camel = camel[0].upcase + camel[1..-1]
+      send(:define_method, "set" + camel) do |val|
+        instance_variable_set("@#{symbol_name}", val)
+      end
+      send(:define_method, "get" + camel) do
+        instance_variable_get("@#{symbol_name}")
+      end
+      send(:define_method, symbol_name.id2name + "GetType") do
+        return type.java_class
+      end
+    end
+    def fxml_accessor(symbol_name,ptype=Java::javafx.beans.property.SimpleStringProperty, type=nil)
+      # TODO: RDoc
+      # TODO: somebody clean this up
+      # TODO: _reader and _writer ? maybe? not?
+      pname = symbol_name.id2name + "Property"
+      raise "#{ptype} does not inherit from Property." unless ptype.ancestors.include? Java::javafx.beans.property.Property
+      unless type
+        type = ptype.java_class.java_instance_methods.find_all{|x|x.name == "getValue"}.map{|x|x.return_type}.find_all{|x|x != java.lang.Object.java_class}
+        if type.length != 1
+          raise "Unknown property type. Please manually supply a type or report this as a bug"
+        end
+        type = type[0]
+      else
+        type = type.java_class
+      end
+      send(:define_method, symbol_name.id2name.snake_case + "=") do |val|
+        send(pname).setValue val
+      end
+      send(:define_method, symbol_name.id2name.snake_case) do
+        send(pname).getValue
+      end
+      send(:define_method, symbol_name.id2name.snake_case + "GetType") do
+        return type
+      end
+      camel = symbol_name.id2name
+      camel = camel[0].upcase + camel[1..-1]
+      send(:define_method, "set" + camel) do |val|
+        send(pname).setValue val
+      end
+      send(:define_method, "get" + camel) do
+        send(pname).getValue
+      end
+      send(:define_method, symbol_name.id2name + "GetType") do
+        return type
+      end
+      send(:define_method, pname) do
+        unless instance_variable_get("@#{symbol_name}")
+          instance_variable_set("@#{symbol_name}", ptype.new(self, symbol_name.to_s))
+        end
+        return instance_variable_get("@#{symbol_name}")
+      end
+      send(:define_method, pname.snake_case) do
+        send(pname)
+      end
+      add_method_signature pname, [ptype]
+      add_method_signature "set" + camel, [java.lang.Void, type]
+      add_method_signature "get" + camel, [type]
+    end
+  end
+end

data/lib/jrubyfx/part_imports.rb

@@ -0,0 +1,141 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+require_relative 'utils'
+
+# Update load path to include the JavaFX runtime and fail nicely if we can't find it
+begin
+  if ENV['JFX_DIR']
+    $LOAD_PATH << ENV['JFX_DIR']
+  else #should we check for 1.7 vs 1.8? oh well, adding extra paths won't hurt anybody (maybe performance loading)
+    jfx_path = ENV_JAVA["sun.boot.library.path"]
+    $LOAD_PATH << if jfx_path.include? ":\\" and !jfx_path.include? "/" # can be tricked, but should work fine
+      #windows
+      jfx_path.gsub(/\\bin[\\]*$/i, "\\lib")
+    else
+      # *nix
+      jfx_path.gsub(/[\/\\][amdix345678_]+$/, "") # strip i386 or amd64 (including variants). TODO: ARM
+    end
+  end
+
+  # Java 8 (after ea-b75) and above has JavaFX as part of the normal distib, only require it if we are 7 or below
+  jre = ENV_JAVA["java.runtime.version"].match %r{^(?<version>(?<major>\d+)\.(?<minor>\d+))\.(?<patch>\d+)(_\d+)?-?(?<release>ea|u\d)?(-?b(?<build>\d+))?}
+  # add OpenJFX support if follow instruction from https://openjfx.io
+  if ENV['JFX_DIR'] or
+    jre[:version].to_f < 1.8 or
+    (jre[:version].to_f == 1.8 and jre[:release] == 'ea' and jre[:build].to_i < 75)
+    require 'jfxrt.jar'
+  elsif ENV['PATH_TO_FX'] # support the OpenJFX installation as in https://openjfx.io/openjfx-docs/#install-javafx as of 15th May 2020
+    Dir.glob(File.join(ENV['PATH_TO_FX'],"*.jar")).each do |jar|
+      require jar
+    end
+  end
+
+  # Java 8 at some point requires explicit toolkit/platform initialization
+  # before any controls can be loaded.
+  JRubyFX.load_fx
+  
+  # Attempt to load a javafx class
+  Java.javafx.application.Application
+rescue  LoadError, NameError
+  # Advice user too about the OpenJFX support
+  puts "JavaFX runtime not found.  Please install Java 7u6 or newer, set environment variable JFX_DIR to the folder that contains jfxrt.jar or set the environment variable PATH_TO_FX that points to the OpenJFX libraries"
+  puts "If you have Java 7u6 or later, this is a bug. Please report to the issue tracker on github. Include your OS version, 32/64bit, and architecture (x86, ARM, PPC, etc)"
+  exit -1
+end
+
+module JRubyFX
+  # If you need JavaFX, just include this module. Its sole purpose in life is to
+  # import all JavaFX stuff, plus a few useful Java classes (like Void)
+  module FXImports
+
+    # If something is missing, just java_import it in your code.
+    # And then ask us to put it in this list
+    ###### IMPORTANT LINE ##### (see rakefile, this is a magic line, don't delete)
+
+    ##
+    # This is the list of all classes in JavaFX that most apps should care about.
+    # It is a hashmaps with the leafs as arrays. Where a leaf also contains more
+    # packages, the hashmap key is "" (empty string). You can utilize this constant
+    # to save yourself some typing when adding code for most/all of the JavaFX
+    # classes by using either `Hash.flat_tree_inject` from jrubyfx/utils.rb or
+    # writing your own traversal function
+    #
+    JFX_CLASS_HIERARCHY = { :javafx => {
+        :animation => %w[Animation AnimationTimer FadeTransition FillTransition Interpolator KeyFrame KeyValue ParallelTransition PathTransition
+        PauseTransition RotateTransition ScaleTransition SequentialTransition StrokeTransition Timeline Transition TranslateTransition],
+        :application => ['Platform'],
+        :beans => {
+          :property => %w[SimpleBooleanProperty SimpleDoubleProperty SimpleFloatProperty SimpleIntegerProperty SimpleListProperty SimpleLongProperty SimpleMapProperty SimpleObjectProperty SimpleSetProperty SimpleStringProperty],
+          #TODO: import more
+          :value => ['ChangeListener']
+        },
+        :collections => ['FXCollections'],
+        :concurrent => %w[Worker Task Service],
+        :event => %w[Event ActionEvent EventHandler],
+        :fxml => ['Initializable', 'LoadException'],
+        :geometry => %w[HorizontalDirection HPos Insets Orientation Pos Rectangle2D Side VerticalDirection VPos],
+        :scene => {
+          '' => %w[Group Node Parent Scene],
+          :canvas => ['Canvas'],
+          :chart => %w[AreaChart Axis BarChart BubbleChart CategoryAxis Chart LineChart NumberAxis
+          PieChart ScatterChart StackedAreaChart StackedBarChart ValueAxis XYChart],
+          :control => %w[Accordion Button Cell CheckBox CheckBoxTreeItem CheckMenuItem ChoiceBox ColorPicker ComboBox ContextMenu Hyperlink
+          Label ListCell ListView Menu MenuBar MenuButton MenuItem Pagination PasswordField PopupControl ProgressBar ProgressIndicator RadioButton
+          RadioMenuItem ScrollBar ScrollPane Separator SeparatorMenuItem Slider SplitMenuButton SplitPane Tab TableView TableCell TableColumn TabPane TextArea
+          TextField TitledPane ToggleButton ToggleGroup ToolBar Tooltip TreeCell TreeItem TreeView ContentDisplay OverrunStyle SelectionMode],
+          :effect => %w[Blend BlendMode Bloom BlurType BoxBlur ColorAdjust ColorInput DisplacementMap DropShadow GaussianBlur Glow ImageInput
+          InnerShadow Lighting MotionBlur PerspectiveTransform Reflection SepiaTone Shadow],
+          :image => %w[Image ImageView PixelReader PixelWriter],
+          :input => %w[Clipboard ClipboardContent ContextMenuEvent DragEvent GestureEvent InputEvent InputMethodEvent KeyCode KeyEvent
+          Mnemonic MouseButton MouseDragEvent MouseEvent RotateEvent ScrollEvent SwipeEvent TouchEvent TransferMode ZoomEvent],
+          :layout => %w[AnchorPane BorderPane ColumnConstraints FlowPane GridPane HBox Pane Priority RowConstraints StackPane TilePane VBox],
+          :media => %w[AudioClip AudioEqualizer AudioTrack EqualizerBand Media MediaException
+          MediaErrorEvent MediaMarkerEvent MediaPlayer MediaView VideoTrack],
+          :paint => %w[Color CycleMethod ImagePattern LinearGradient Paint RadialGradient Stop],
+          :shape => %w[Arc ArcTo ArcType Circle ClosePath CubicCurve CubicCurveTo Ellipse FillRule HLineTo Line LineTo MoveTo Path PathElement
+          Polygon Polyline QuadCurve QuadCurveTo Rectangle Shape StrokeLineCap StrokeLineJoin StrokeType SVGPath VLineTo],
+          :text => %w[Font FontPosture FontSmoothingType FontWeight Text TextAlignment TextBoundsType],
+          :transform => %w[Affine Rotate Scale Shear Translate],
+          :web => ['WebView', 'HTMLEditor']
+        },
+        :stage => %w[DirectoryChooser FileChooser Modality Popup PopupWindow Screen Stage StageStyle Window WindowEvent],
+        :util => ['Duration']
+      }
+    }
+
+    $WRITE_OUT << <<HERE
+    def const_missing(c)
+      if LOCAL_NAME_MAP.has_key? c
+        java_import(LOCAL_NAME_MAP[c])[0]
+      else
+        super
+      end
+    end
+
+HERE
+
+    # Imports all the listed JavaFX classes
+    $WRITE_OUT << "LOCAL_NAME_MAP = { \n  "
+    $WRITE_OUT << (JFX_CLASS_HIERARCHY.flat_tree_inject do |res, name, values|
+        name = "#{name.to_s}."
+        name = "" if name == "."
+        res.concat(values.map{|i| "#{name}#{i}"})
+      end).map{|x| "#{x.split(".").last.to_sym.inspect} => #{x.inspect}"}.join(",\n  ")
+    $WRITE_OUT << "\n}\njava_import 'java.lang.Void'"
+  end
+end

data/lib/jrubyfx/utils.rb

@@ -0,0 +1,86 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+# This feels kinda like a hack. If anyone has a better idea, please let me know
+
+# Standard ruby Hash class extensions
+class Hash
+
+  # call-seq:
+  #   flat_tree_inject() {|results, key, value| block} => array
+  #   flat_tree_inject(Hash) {|results, key, value| block} => hash
+  #
+  # Execute given block against all nodes in the hash tree, returning `results`.
+  # Similar to Hash#each except goes into all sub-Hashes
+  #
+  def flat_tree_inject(klass=Array,&block)
+    self.inject(klass.new) do |lres, pair|
+      if pair[1].is_a? Hash
+        pair[1] = pair[1].flat_tree_inject(klass, &block)
+      end
+      block.call(lres, *pair)
+    end
+  end
+end
+
+# Standard ruby String class extensions
+class String
+  # call-seq:
+  #   snake_case(ignore_prefix_namespace=false) => string
+  #
+  # Converts a CamelCaseString to a snake_case_string
+  #
+  #   "JavaFX".snake_case #=> "java_fx"
+  #
+  # If ignore_prefix_namespace is specified it will strip
+  # any preceding modules/classes off front of string before
+  # snake casing:
+  #   Foo::BigBar #=> "big_bar"
+  #
+  # By default it will separate modules with a "/":
+  #   Foo::BigBar #=> "foo/big_bar"
+  #
+  def snake_case(ignore_prefix_namespace=false)
+    base = ignore_prefix_namespace ?
+             self.gsub(/.*::/, '') : self.gsub(/::/, '/')
+    base.
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+
+module Enumerable
+  def map_find(&block)
+    m = {}
+    m[self.find do |i|
+      m[i] = block.call(i)
+    end]
+  end
+end
+
+module JRubyFX
+  def self.load_fx(force=false)
+    return if @already_loaded_fx and !force
+    @already_loaded_fx = true
+    java.util.concurrent.CountDownLatch.new(1).tap do |latch|
+      com.sun.javafx.application.PlatformImpl.startup { latch.countDown }
+      latch.await
+    end
+  end
+end

data/lib/jrubyfx/utils/__ignore_java_stupid_rdoc.rb

@@ -0,0 +1,30 @@
+module Java #:nodoc: all
+  module javafx
+    module animation
+    end
+    module beans
+      module value
+      end
+    end
+    module scene
+      module chart
+      end
+      module control
+      end
+      module effect
+      end
+      module layout
+      end
+      module media
+      end
+      module paint
+      end
+      module shape
+      end
+      module transform
+      end
+    end
+    module stage
+    end
+  end
+end

data/lib/jrubyfx/utils/common_converters.rb

@@ -0,0 +1,223 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+false # Do NOT delete this or it will make RDOC associate the copyright header with JRubyFX module
+
+module JRubyFX
+  module Utils
+    # Contains conversion utilities to ease Ruby => JavaFX coding
+    module CommonConverters
+      java_import 'javafx.scene.paint.Color'
+      java_import 'javafx.geometry.Insets'
+      java_import 'javafx.geometry.Rectangle2D'
+
+      # argument converter method name suffix
+      ARG_CONVERTER_SUFFIX = '_arg_converter'
+
+      # map of snake_cased colors to JavaFX Colors
+      NAME_TO_COLORS = {
+        'darkyellow' => Color.web('0xc0c000'),
+        'lightmagenta' => Color.web('0xffc0ff'),
+        'lightred' => Color.web('0xffc0c0'),
+      }.merge(Color.java_class.fields.inject({}) {|final, field|
+          final[field.name.downcase] = field.value(nil) # TODO: what is nil supposed to be?
+          final
+        })
+
+      ##
+      # Generate a converter for a map of supplied values.
+      def map_converter(map)
+        lambda do |value|
+          map.key?(value) ? map[value] : value
+        end
+      end
+
+      ##
+      # Generate a converter for an enum of the given class
+      def enum_converter(enum_class)
+        lambda do |value|
+          (JRubyFX::Utils::CommonConverters.map_enums(enum_class)[value.to_s] || value)
+        end
+      end
+
+      ##
+      # call-seq:
+      #   animation_converter_for :property_name, ...
+      #
+      # Generates an animation adapter for the given properties so you can specify
+      # transformations, etc with a hashmap of from, to values
+      # === Examples
+      #   animation_converter_for :value
+      #
+      #   ...
+      #
+      #   _my_type_(value: {0 => 360})
+      #
+      def animation_converter_for(*prop_names)
+        prop_names.each do |prop_name|
+          self.__send__(:define_method, prop_name.to_s + "=") do |hash|
+            method("from_#{prop_name}=").call hash.keys[0]
+            method("to_#{prop_name}=").call hash.values[0]
+          end
+        end
+      end
+
+      ##
+      # Allows you to specify you want a converter method created for the
+      # specified method where each listed converter corresponds to each
+      # argument for that method.  You can have n-arity lists for all
+      # matching Java overloads.  This mechanism means you may not always
+      # be able to specify all coercions you want.
+      # === Examples
+      #
+      #    coverter_for :new, [:none, :color]
+      #
+      # This method will define a method on the current class called
+      # *new_arg_converter* which will perform no argument coercion on
+      # the first argument and a color coercion on the second argument.
+      #
+      #    e = enum_converter(Java::javafx::scene::input::TransferMode)
+      #    converter_for :accept_transfer_modes &e
+      #
+      # This method will allow a catch-all converter to be used for all
+      # arities not specified.  In this case since no arities are given
+      # all arities will pass through this enum_converter.  This form
+      # is useful for single var_args signatures.
+      #
+      def converter_for(method_name, *converters, &default)
+       # puts "[converter for #{self}, #{method_name}]"
+        sheep = lambda do |direct, this, *values|
+          converter = converters.find { |e| e.length == values.length }
+          converter = Array.new(values.length, default) unless converter
+
+          # FIXME: Better error reporting on many things which can fail
+          i = 0
+          values = values.inject([]) do |s, value|
+            conv = converter[i]
+            if conv.kind_of? Proc
+              s << conv.call(value)
+            else
+              s << CONVERTERS[converter[i]].call(value)
+            end
+            i += 1
+            s
+          end
+          if direct
+            return this.method("set_" + method_name.to_s).call(*values)
+          else
+            return values
+          end
+        end
+        # define a setter for normal usage
+        unless method_name == :new
+          self.__send__(:define_method, method_name.to_s + "=") do |*values|
+            sheep.call(true, self, *values)
+          end
+        end
+        # define a build/with usage
+        self.__send__(:define_method, method_name.to_s + ARG_CONVERTER_SUFFIX) do |*values|
+          sheep.call(false, self, *values)
+        end
+      end
+
+      # Map of different kinds of known converters
+      CONVERTERS = {
+        :none => lambda { |value|
+          value
+        },
+        :color => lambda { |value|
+          new_value = NAME_TO_COLORS[value.to_s.gsub(/_/, "")]
+          if !new_value && value.kind_of?(Symbol)
+            raise ArgumentError.new("No such color: #{value.to_s}") 
+          end
+          new_value ? new_value : value
+        },
+        :rectangle2d => lambda { |value|
+          if value == :empty
+            Rectangle2D::EMPTY
+          elsif value.is_a? Array
+            Rectangle2D.new(*value)
+          else
+            value
+          end
+        },
+        :insets => lambda { |value|
+          if value == :empty
+            Insets::EMPTY
+          elsif value.is_a? Numeric
+            Insets.new(value)
+          elsif value.is_a? Array
+            # top/bottom, left/right
+            value = [value[0], value[1], value[0], value[1]] if value.size == 2
+            Insets.new(*value)
+          else
+            value
+          end
+        },
+      }
+
+      ENUM_CACHE = {}
+
+      # Store enum mapping overrides
+      ENUM_OVERRIDES = {Java::JavafxAnimation::PathTransition::OrientationType => {:orthogonal_to_tangent => :orthogonal},
+        Java::JavafxSceneEffect::BlendMode => {:src_over => :over, :src_atop => :atop, :color_dodge => :dodge, :color_burn => :burn},
+        Java::JavafxSceneControl::ContentDisplay => {:graphic_only => :graphic, :text_only => :text},
+        Java::JavafxSceneEffect::BlurType => {:one_pass_box => [:one, :one_pass], :two_pass_box => [:two, :two_pass], :three_pass_box => [:three, :three_pass]},
+        Java::JavafxStage::Modality => {:window_modal => :window, :application_modal => [:application, :app]}}
+
+      # sets the given overrides for the given class/enum
+      def self.set_overrides_for(enum_class,ovr)
+        ENUM_OVERRIDES[enum_class] = ovr
+      end
+
+      # Given a class, returns a hash of lowercase strings mapped to Java Enums
+      def self.map_enums(enum_class)
+        res = Hash[enum_class.java_class.enum_constants.map {|i| [i.to_s.downcase, i] }]
+        (ENUM_OVERRIDES[enum_class]||[]).each do |oldk, newks|
+          [newks].flatten.each do |newk|
+            res[newk.to_s] = res[oldk.to_s]
+          end
+        end
+        res
+      end
+
+      def self.parse_ruby_symbols(const, enum)
+        ENUM_CACHE[enum] = JRubyFX::Utils::CommonConverters.map_enums(enum) if  ENUM_CACHE[enum] == nil
+        ENUM_CACHE[enum][const.to_s] || const
+      end
+
+      def self.convert_args(values, converters)
+        converter = converters.find { |e| e.length == values.length }
+        converter = Array.new(values.length) unless converter
+
+        # FIXME: Better error reporting on many things which can fail
+        i = 0
+        values = values.inject([]) do |s, value|
+          conv = converter[i]
+          if conv.kind_of? Proc
+            s << conv.call(value)
+          else
+            s << CONVERTERS[converter[i]].call(value)
+          end
+          i += 1
+          s
+        end
+        return values
+      end
+    end
+
+  end
+end