jrubyfx-fxmlloader-openjfx.patch 0.4.2-java

data/lib/fxmlloader/fxml_jit_info.rb

@@ -0,0 +1,158 @@
+# * Copyright (c) 2013 Patrick Plenefisch
+# * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+# *
+# * This code is free software; you can redistribute it and/or modify it
+# * under the terms of the GNU General Public License version 2 only, as
+# * published by the Free Software Foundation.  Oracle designates this
+# * particular file as subject to the "Classpath" exception as provided
+# * by Oracle in the LICENSE file that accompanied this code.
+# *
+# * This code is distributed in the hope that it will be useful, but WITHOUT
+# * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# * version 2 for more details (a copy is included in the LICENSE file that
+# * accompanied this code).
+# *
+# * You should have received a copy of the GNU General Public License version
+# * 2 along with this work; if not, write to the Free Software Foundation,
+# * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+# *
+
+require 'digest/sha1'
+require 'fileutils'
+
+def javafx
+  Java::javafx
+end
+
+Infinity = 1.0/0.0
+
+class FxmlJitInfo
+  include JRubyFX
+  def self.hash(file)
+    Digest::SHA1.hexdigest(File.read file)
+  end
+  def self.load_aot(file, cache, validate = true)
+    if validate
+      hash = hash(file)
+      f_hash = File.open(cache, "r", &:readline).strip
+      return false if "# #{hash} encoding: utf-8" != f_hash
+    end
+    hash = Digest::SHA1.hexdigest(File.basename file)
+    require cache
+    JRubyFX::GeneratedAssets.const_get("AOT#{hash}").new rescue nil
+  end
+  # TODO: store jit settings in here instead of $RB_* variables
+  attr_accessor :file_name, :raw_code, :jit_settings
+  def initialize(file_name, jit_settings=1, outfile=nil, cache_dir=nil,validate = true, opts = nil)
+    @file_name = file_name
+    @no_write = (opts && opts[:no_write]) || false
+    if @file_name.start_with? "file:"
+      @file_name = @file_name.gsub(/^file\:/, '')
+    elsif @file_name.start_with? "jar:"
+      @no_write = true
+    elsif @file_name.start_with? "compoundjar:"
+      @no_write = true
+    end
+    @jit_settings = jit_settings
+    @run_count = 0
+    @opts = opts
+    @outfile = if @outfile
+      outfile
+    else
+      cache_dir = cache_dir || File.join(File.dirname(@file_name), ".jrubyfx_cache")
+      FileUtils.mkpath(cache_dir) unless File.directory?(cache_dir) or @no_write
+      @f_hash = Digest::SHA1.hexdigest(File.basename @file_name)
+      File.join(cache_dir, "#{@f_hash}.rb")
+    end
+    if File.exist?(@outfile) && !(opts && opts[:force])
+      @compiled = self.class.load_aot(@file_name, @outfile, validate)
+      if @compiled
+        dputs "got #{file_name} from cache"
+      end
+    end
+  end
+  def hash
+    FxmlJitInfo.hash(@file_name)
+  end
+  def should_jit?
+    return false if @jit_settings == :no_jit || compiled?
+    return true if (@run_count += 1) >= @jit_settings
+  end
+  def compiled?
+    !!@compiled
+  end
+  def decompile
+    @compiled = nil
+  end
+  def __build_via_jit(__local_fxml_controller, __local_namespace, __local_jruby_ext)
+    @compiled.__build_via_jit(__local_fxml_controller, __local_namespace, __local_jruby_ext)
+  end
+  def compile(code=@raw_code)
+    @raw_code = code
+    # TODO: begin rescue end
+    full_code =  <<METHOD_DEF
+    def __build_via_jit(__local_fxml_controller, __local_namespace, __local_jruby_ext)
+      __local_fx_id_setter = lambda do |name, __i|
+        __local_namespace[name] = __i
+        __local_fxml_controller.instance_variable_set(("@\#{name}").to_sym, __i)
+      end
+#{code}
+    end
+METHOD_DEF
+    ;#)
+    unless @no_write
+      begin
+        jit_aot_cache(full_code)
+      rescue
+        p $!
+        jit_no_cache(full_code)
+      end
+    else
+      jit_no_cache(full_code)
+    end
+    if @opts && @opts[:compiled_hook]
+      @opts[:compiled_hook].call(@outfile)
+    end
+
+  end
+
+  def jit_no_cache(full_code)
+    dputs "JIT only, no aot for #{@file_name}"
+    self.instance_eval full_code
+    @compiled = true
+  end
+
+  def jit_aot_cache(full_code)
+    File.open(@outfile, "w") do |f|
+      hash = hash()
+      f << <<AOT
+# #{hash} encoding: utf-8
+# @@ 1
+
+########################### DO NOT MODIFY THIS FILE ###########################
+#       This file was automatically generated by JRubyFX-fxmlloader on        #
+# #{Time.now} for #{@file_name}
+########################### DO NOT MODIFY THIS FILE ###########################
+
+module JRubyFX
+  module GeneratedAssets
+    class AOT#{@f_hash}
+      include JRubyFX
+      #{full_code}
+      def hash
+        #{hash.inspect}
+      end
+      def compiled?
+        true
+      end
+    end
+  end
+end
+AOT
+    end
+    puts "saved #{@outfile} to cache"
+    require @outfile
+    @compiled = JRubyFX::GeneratedAssets.const_get("AOT#{@f_hash}").new rescue nil
+  end
+end

data/lib/fxmlloader/j8_expression_value.rb

@@ -0,0 +1,290 @@
+#/*
+# * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
+# * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+# *
+# * This code is free software; you can redistribute it and/or modify it
+# * under the terms of the GNU General Public License version 2 only, as
+# * published by the Free Software Foundation.  Oracle designates this
+# * particular file as subject to the "Classpath" exception as provided
+# * by Oracle in the LICENSE file that accompanied this code.
+# *
+# * This code is distributed in the hope that it will be useful, but WITHOUT
+# * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# * version 2 for more details (a copy is included in the LICENSE file that
+# * accompanied this code).
+# *
+# * You should have received a copy of the GNU General Public License version
+# * 2 along with this work; if not, write to the Free Software Foundation,
+# * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+# *
+# * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+# * or visit www.oracle.com if you need additional information or have any
+# * questions.
+# */
+
+
+#/**
+# * Class representing an observable expression value.
+# */
+class RRExpressionValue < Java::javafx.beans.value.ObservableValueBase
+  #// Monitors a namespace for changes along a key path
+
+
+
+  def initialize(namespace, expression, type)
+    super()
+    if (namespace == nil)
+      raise "NullPointerException.new();"
+    end
+
+    if (expression == nil)
+      raise "NullPointerException.new();"
+    end
+
+    if (type == nil)
+      raise "NullPointerException.new();"
+    end
+
+    @listenerCount = 0;
+
+    @namespace = namespace;
+    @expression = expression;
+    @type = type;
+
+    arguments = expression.getArguments();
+    @argumentMonitors = java.util.ArrayList.new(arguments.size());
+
+    for  argument in arguments
+      @argumentMonitors.add(KeyPathMonitor.new(self, argument.iterator()));
+    end
+  end
+
+
+  def getValue()
+    return RubyWrapperBeanAdapter.coerce(@expression.evaluate(@namespace), @type);
+  end
+
+  def addListener( listener)
+    if (@listenerCount == 0)
+      monitorArguments();
+    end
+
+    super(listener);
+    @listenerCount += 1
+  end
+
+  def removeListener( listener)
+    super(listener);
+    @listenerCount-=1
+
+    if (@listenerCount == 0)
+      unmonitorArguments();
+    end
+  end
+
+  def monitorArguments()
+    for  argumentMonitor in @argumentMonitors
+      argumentMonitor.monitor(@namespace);
+    end
+  end
+
+  def unmonitorArguments()
+    for  argumentMonitor in   @argumentMonitors
+      argumentMonitor.unmonitor();
+    end
+  end
+end
+
+
+class KeyPathMonitor
+  @key = nil;
+  @next = nil
+
+  @namespace = nil;
+
+
+  class ListChangeImpl
+    include ListChangeListener
+
+    def initialize(this)
+      @this = this
+    end
+
+    def onChanged(change)
+      @this.list_changed(change)
+    end
+  end
+
+
+  class MapChangeImpl
+    include MapChangeListener
+
+    def initialize(this)
+      @this = this
+    end
+
+    def onChanged(change)
+      @this.map_changed(change)
+    end
+  end
+
+
+
+  class ChangeListenerImpl
+    include ChangeListener
+
+    def initialize(this)
+      @this = this
+    end
+
+    def changed(ov, old, new)
+      @this.normal_changed(ov, old, new)
+    end
+  end
+
+  def initialize(this, keyPathIterator)
+    @key = keyPathIterator.next();
+    @this = this
+
+
+    @listChangeListener = ListChangeImpl.new(self)
+
+
+    @mapChangeListener = MapChangeImpl.new(self)
+
+
+    @propertyChangeListener = ChangeListenerImpl.new(self)
+
+    if (keyPathIterator.hasNext())
+      @next = KeyPathMonitor.new(this, keyPathIterator);
+    else
+      @next = nil;
+    end
+  end
+
+  def list_changed(change)
+    while (change.next())
+      index = @key.to_i
+
+      if (index >= change.getFrom() && index < change.getTo())
+        @this.fireValueChangedEvent();
+        remonitor();
+      end
+    end
+  end
+
+  def map_changed(change)
+    if (@key == (change.getKey()))
+      @this.fireValueChangedEvent();
+      remonitor();
+    end
+  end
+
+  def normal_changed(observable, oldValue, newValue)
+    if (@key == (observable.getName()))
+
+      @this.fireValueChangedEvent();
+      remonitor();
+    end
+  end
+
+  def monitor(namespace)
+    if (namespace.is_a? ObservableList)
+      old_verbose = $VERBOSE
+      begin
+        $VERBOSE = nil
+        namespace.addListener @listChangeListener
+      ensure
+        # always re-set to old value, even if block raises an exception
+        $VERBOSE = old_verbose
+      end
+    elsif (namespace.is_a? ObservableMap)
+      old_verbose = $VERBOSE
+      begin
+        $VERBOSE = nil
+        namespace.addListener @mapChangeListener
+      ensure
+        # always re-set to old value, even if block raises an exception
+        $VERBOSE = old_verbose
+      end
+    else
+      namespaceAdapter = RubyWrapperBeanAdapter.for(namespace);
+      propertyModel = namespaceAdapter.getPropertyModel(@key).to_java
+      if (propertyModel != nil)
+        old_verbose = $VERBOSE
+        begin
+          $VERBOSE = nil
+          propertyModel.addListener @propertyChangeListener
+        ensure
+          # always re-set to old value, even if block raises an exception
+          $VERBOSE = old_verbose
+        end
+      end
+
+      @namespace = namespaceAdapter;
+    end
+
+    @namespace = namespace;
+
+    if (@next != nil)
+      value = Expression.get(@namespace, @key)
+      if (value != nil)
+        @next.monitor(value);
+      end
+    end
+  end
+
+  def unmonitor()
+    if (@namespace.is_a? ObservableList)
+      old_verbose = $VERBOSE
+      begin
+        $VERBOSE = nil
+        @namespace.removeListener @listChangeListener
+      ensure
+        # always re-set to old value, even if block raises an exception
+        $VERBOSE = old_verbose
+      end
+    elsif (@namespace.is_a? ObservableMap)
+      old_verbose = $VERBOSE
+      begin
+        $VERBOSE = nil
+        @namespace.removeListener @mapChangeListener
+      ensure
+        # always re-set to old value, even if block raises an exception
+        $VERBOSE = old_verbose
+      end
+    elsif (@namespace != nil)
+      namespaceAdapter = @namespace;
+      propertyModel = namespaceAdapter.getPropertyModel(@key);
+
+      if (propertyModel != nil)
+        old_verbose = $VERBOSE
+        begin
+          $VERBOSE = nil
+          propertyModel.removeListener @propertyChangeListener
+        ensure
+          # always re-set to old value, even if block raises an exception
+          $VERBOSE = old_verbose
+        end
+      end
+    end
+
+    @namespace = nil;
+
+    if (@next != nil)
+      @next.unmonitor();
+    end
+  end
+
+  def remonitor()
+    if (@next != nil)
+      @next.unmonitor();
+      value = Expression.get(@namespace, @key);
+      if (value != nil)
+        @next.monitor(value);
+      end
+    end
+  end
+end
+

data/lib/fxmlloader/real_elts.rb

@@ -0,0 +1,708 @@
+class OBJFXBuilderWrapper < Java::java.util.AbstractMap
+  include Java::javafx.util.Builder
+  def initialize(safeobj, type)
+    super()
+    @type = type
+    @obj = safeobj
+  end
+
+  def wrapped_class
+    @type
+  end
+
+  def on_put(&on_put)
+    @on_put = on_put
+  end
+
+  def build
+    @obj.build.tap{|x| rmorph self, x}
+  end
+
+  def containsKey(o)
+    @obj.containsKey(o)
+  end
+
+  def get(o)
+    @obj.get(o)
+  end
+
+  def put(k, v)
+    @on_put.call(k, v) if @on_put
+    @obj.put(k, v)
+  end
+
+  def [](o)
+    get(o)
+  end
+  def []=(k, v)
+    put(k, v)
+  end
+
+  def entrySet
+    java.util.HashMap.new({}).entrySet
+  end
+
+  def ==(rhs)
+    self.equal? rhs # do pointer comparison
+  end
+
+  def inspect
+    "#<ObjectBuilderWrapper:#{self.object_id.to_s 16} type=#{@type}, child=#{@obj.class.inspect}>"
+  end
+end
+
+class InstanceDeclarationElement < ValueElement
+  attr_accessor :type, :constant, :factory
+
+  def initialize(current, xmlStreamReader, loadListener, parentLoader, type)
+    super(current, xmlStreamReader, loadListener, parentLoader)
+    @type = type;
+    @constant = nil;
+    @factory = nil;
+  end
+
+  def processAttribute( prefix,  localName,  value)
+    if (prefix != nil				&& prefix == (FXL::FX_NAMESPACE_PREFIX))
+      if (localName == (FXL::FX_VALUE_ATTRIBUTE))
+        @value = value;
+      elsif (localName == (FXL::FX_CONSTANT_ATTRIBUTE))
+        @constant = value;
+      elsif (localName == (FXL::FX_FACTORY_ATTRIBUTE))
+        @factory = value;
+      else
+        super(prefix, localName, value);
+      end
+    else
+      super(prefix, localName, value);
+    end
+  end
+
+  def constructValue()
+    value = nil
+    if (@value != nil)
+      value = RubyWrapperBeanAdapter.coerce(@value, type);
+    elsif (constant != nil)
+      value = RubyWrapperBeanAdapter.getConstantValue(type, constant);
+    elsif (factory != nil)
+      factoryMethod = nil
+      begin
+        factoryMethod = MethodUtil.getMethod(type, factory, []);
+      rescue NoSuchMethodException => exception
+        raise LoadException.new(exception);
+      end
+
+      begin
+        value = MethodUtil.invoke(factoryMethod, nil, []);
+      rescue IllegalAccessException => exception
+        raise LoadException.new(exception);
+      rescue InvocationTargetException => exception
+        raise LoadException.new(exception);
+      end
+    else
+      value = (parentLoader.builderFactory == nil) ? nil : parentLoader.builderFactory.getBuilder(type);
+      if (value.is_a? Builder or (value.respond_to?(:java_object) && value.java_object.is_a?(Builder)))
+        begin
+          value.size
+        rescue java.lang.UnsupportedOperationException => ex
+          dputs "########################## WARNING #############################3"
+          value = OBJFXBuilderWrapper.new(value, type)
+          value.on_put {|k, v| rctor value, k, v }
+        end
+      end
+      if (value == nil)
+        begin
+          #TODO: does this work?
+          value = type.ruby_class.new
+        rescue InstantiationException => exception
+          raise LoadException.new(exception);
+        rescue IllegalAccessException => exception
+          raise LoadException.new(exception);
+        end
+      else
+     end
+    end
+    if factory
+      rputs value, "build(FactoryBuilderBuilder, #{type.ruby_class}, #{factory.inspect}) do"
+    elsif @value
+      rno_show(value)
+      rputs value, value.inspect
+    else
+      rputs value, "build(#{type.ruby_class}) do"
+    end
+    rnest 1
+    return value;
+  end
+end
+
+# Element representing an unknown type
+class UnknownTypeElement < ValueElement
+
+  def initialize()
+    dputs "oh no...."
+  end
+  # TODO: cleanup
+  # Map type representing an unknown value
+  #		def UnknownValueMap extends AbstractMap<String, Object>
+  #			def<?> items = ArrayList.new<Object>();
+  #			def<String, Object> values = HashMap.new<String, Object>();
+  #
+  #			def get(Object key)
+  #				if (key == nil)
+  #					raise NullPointerException.new();
+  #				end
+  #
+  #				return (key == (java_class().getAnnotation(DefaultProperty.java_class).value()))
+  #					   ? items : values.get(key);
+  #			end
+  #
+  #			def put(String key, Object value)
+  #				if (key == nil)
+  #					raise NullPointerException.new();
+  #				end
+  #
+  #				if (key == (java_class().getAnnotation(DefaultProperty.java_class).value()))
+  #					raise IllegalArgumentException.new();
+  #				end
+  #
+  #				return values.put(key, value);
+  #			end
+  #
+  #			def entrySet()
+  #				return Collections.emptySet();
+  #			end
+  #		end
+
+  def processEndElement()
+    # No-op
+  end
+
+  def constructValue()
+    return UnknownValueMap.new();
+  end
+end
+
+# Element representing an include
+class IncludeElement < ValueElement
+  # TODO: cleanup
+  attr_accessor :source, :resources, :charset
+  def initialize(current, xmlStreamReader, loadListener, parentLoader)
+    super
+    @source = nil;
+    @resources = parentLoader.resources;
+    @charset = parentLoader.charset;
+  end
+
+  def processAttribute(prefix,  localName,  value)
+
+    if (prefix == nil)
+      if (localName == (FXL::INCLUDE_SOURCE_ATTRIBUTE))
+        if (loadListener != nil)
+          loadListener.readInternalAttribute(localName, value);
+        end
+
+        source = value;
+      elsif (localName == (FXL::INCLUDE_RESOURCES_ATTRIBUTE))
+        if (loadListener != nil)
+          loadListener.readInternalAttribute(localName, value);
+        end
+
+        resources = ResourceBundle.getBundle(value, Locale.getDefault(),
+          parentLoader.resources.java_class().getClassLoader());
+      elsif (localName == (FXL::INCLUDE_CHARSET_ATTRIBUTE))
+        if (loadListener != nil)
+          loadListener.readInternalAttribute(localName, value);
+        end
+
+        charset = Charset.forName(value);
+      else
+        super(prefix, localName, value);
+      end
+    else
+      super(prefix, localName, value);
+    end
+  end
+
+  def constructValue()
+    if (source == nil)
+      raise LoadException.new(FXL::INCLUDE_SOURCE_ATTRIBUTE + " is required.");
+    end
+
+    location = nil
+    if (source[0] == '/')
+      location = classLoader.getResource(source[1..-1]);
+    else
+      if (location == nil)
+        raise LoadException.new("Base location is undefined.");
+      end
+
+      location = URL.new(location, source);
+    end
+
+    fxmlLoader = FxmlLoader.new(location, controller, resources,
+      parentLoader.builderFactory, charset,
+      loaders);
+    fxmlLoader.parentLoader = parentSelf
+
+    if (isCyclic(parentSelf, fxmlLoader))
+      raise IOException.new(
+        String.format(
+					"Including \"%s\" in \"%s\" created cyclic reference.",
+					fxmlLoader.location.toExternalForm(),
+					parentSelf.location.toExternalForm()));
+    end
+    fxmlLoader.setClassLoader(classLoader);
+    fxmlLoader.setStaticLoad(staticLoad);
+
+    value = fxmlLoader.load();
+
+    if (fx_id != nil)
+      id = fx_id + FXL::CONTROLLER_SUFFIX;
+      controller = fxmlLoader.getController();
+
+      namespace.put(id, controller);
+
+      if (parentLoader.controller != nil)
+        field = getControllerFields().get(id);
+
+        if (field != nil)
+          begin
+            field.set(parentLoader.controller, controller);
+          rescue IllegalAccessException => exception
+            raise LoadException.new(exception);
+          end
+        end
+      end
+    end
+
+    return value;
+  end
+end
+
+# Element representing a reference
+class ReferenceElement < ValueElement
+  attr_accessor :source
+  @source = nil;
+
+  def processAttribute(prefix, localName, value)
+    if (prefix == nil)
+      if (localName == (FXL::REFERENCE_SOURCE_ATTRIBUTE))
+        if (loadListener != nil)
+          loadListener.readInternalAttribute(localName, value);
+        end
+        @source = value;
+      else
+        super(prefix, localName, value);
+      end
+    else
+      super(prefix, localName, value);
+    end
+  end
+
+  def constructValue()
+    if (source == nil)
+      raise LoadException.new(FXL::REFERENCE_SOURCE_ATTRIBUTE + " is required.");
+    end
+
+    path = KeyPath.parse(source);
+    if (!Expression.isDefined(parentLoader.namespace, path))
+      raise LoadException.new("Value \"" + source + "\" does not exist.");
+    end
+
+    return Expression.get(parentLoader.namespace, path);
+  end
+end
+
+# Element representing a copy
+class CopyElement < ValueElement
+  attr_accessor :source
+  @source = nil;
+
+  def processAttribute(prefix,  localName,  value)
+
+    if (prefix == nil)
+      if (localName == (FXL::COPY_SOURCE_ATTRIBUTE))
+        if (loadListener != nil)
+          loadListener.readInternalAttribute(localName, value);
+        end
+
+        @source = value;
+      else
+        super(prefix, localName, value);
+      end
+    else
+      super(prefix, localName, value);
+    end
+  end
+
+  def constructValue()
+    if (source == nil)
+      raise LoadException.new(FXL::COPY_SOURCE_ATTRIBUTE + " is required.");
+    end
+
+    path = KeyPath.parse(source);
+    if (!Expression.isDefined(namespace, path))
+      raise LoadException.new("Value \"" + source + "\" does not exist.");
+    end
+
+    sourceValue = Expression.get(namespace, path);
+    sourceValueType = sourceValue.java_class();
+
+    constructor = nil;
+    begin
+      constructor = ConstructorUtil.getConstructor(sourceValueType, [sourceValueType]);
+    rescue NoSuchMethodException => exception
+      # No-op
+    end
+
+    value=nil
+    if (constructor != nil)
+      begin
+        #TODO: try to do evil things here
+        ReflectUtil.checkPackageAccess(sourceValueType);
+        value = constructor.newInstance(sourceValue);
+      rescue InstantiationException => exception
+        raise LoadException.new(exception);
+      rescue IllegalAccessException => exception
+        raise LoadException.new(exception);
+      rescue InvocationTargetException => exception
+        raise LoadException.new(exception);
+      end
+    else
+      raise LoadException.new("Can't copy value " + sourceValue + ".");
+    end
+
+    return value;
+  end
+end
+
+# Element representing a predefined root value
+class RootElement < ValueElement
+  @type = nil
+
+  def processAttribute( prefix,  localName,  value)
+
+    if (prefix == nil)
+      if (localName == (FXL::ROOT_TYPE_ATTRIBUTE))
+        if (loadListener != nil)
+          loadListener.readInternalAttribute(localName, value);
+        end
+
+        @type = value;
+      else
+        super(prefix, localName, value);
+      end
+    else
+      super(prefix, localName, value);
+    end
+  end
+
+  def constructValue()
+    if (@type == nil)
+      raise LoadException.new(FXL::ROOT_TYPE_ATTRIBUTE + " is required.");
+    end
+
+    type = parentLoader.getType(@type);
+
+    if (type == nil)
+      raise LoadException.new(@type + " is not a valid type.");
+    end
+
+    value=nil
+    root = parentLoader.root
+    if (root == nil)
+      if $JRUBYFX_AOT_COMPILING
+        root = parentLoader.root = type.ruby_class.new
+        value = root
+      else
+        raise LoadException.new("Root hasn't been set. Use method setRoot() before load.");
+      end
+    else
+      if (!type.isAssignableFrom(root.java_class()))
+        raise LoadException.new("Root is not an instance of "										+ type.getName() + ".");
+      end
+
+      value = root;
+    end
+    rputs value, "with(__local_fxml_controller) do"
+    rnest 1
+    return value;
+  end
+end
+
+# Element representing a property
+class PropertyElement < Element
+  attr_accessor :name, :sourceType, :readOnly
+
+  def initialize(current, xmlStreamReader, loadListener, parentLoader, name,  sourceType)
+
+    @name = nil
+    @sourceType = nil
+    @readOnly = nil
+    super(current, xmlStreamReader, loadListener, parentLoader)
+    if (parent == nil)
+      raise LoadException.new("Invalid root element.");
+    end
+
+    if (parent.value == nil)
+      raise LoadException.new("Parent element does not support property elements.");
+    end
+
+    @name = name;
+    @sourceType = sourceType;
+
+    if (sourceType == nil)
+      # The element represents an instance property
+      if (name.start_with?(FXL::EVENT_HANDLER_PREFIX))
+        raise LoadException.new("\"" + name + "\" is not a valid element name.");
+      end
+
+      parentProperties = parent.getProperties();
+      if (parent.isTyped())
+        @readOnly = parent.getValueAdapter().read_only?(name);
+      else
+        # If the map already defines a value for the property, assume
+        # that it is read-only
+        @readOnly = parentProperties.has_key?(name);
+      end
+
+      if (@readOnly)
+        value = parentProperties[name]
+        if (value == nil)
+          raise LoadException.new("Invalid property.");
+        end
+        updateValue(value);
+      end
+    else
+      # The element represents a static property
+      @readOnly = false;
+    end
+  end
+
+  def isCollection()
+    return (@readOnly) ? super() : false;
+  end
+
+  def add( element)
+    @pushd = true
+    rp = nil
+    # Coerce the element to the list item type
+    if (parent.isTyped())
+      listType = parent.getValueAdapter().getGenericType(name);
+      lit = RubyWrapperBeanAdapter.getListItemType(listType)
+      # FIXME: HACK!
+      if element.class.inspect == "Java::JavaNet::URL"
+        lit = Java::java.lang.String.java_class
+        rp = rget(element).match(/build\(FxmlBuilderBuilder, \{"value"=>(.*)\}, Java::JavaNet::URL\) do\n( )*end/)[1]
+      end
+      element = RubyWrapperBeanAdapter.coerce(element, lit);
+    end
+
+    # Add the item to the list
+    super(element, name, rp);
+  end
+
+  def set( value)
+    @pushd = true
+    # Update the value
+    updateValue(value);
+
+    if (sourceType == nil)
+      # Apply value to parent element's properties
+      parent.getProperties[name] = value
+    else
+      if (parent.value.is_a? Builder)
+        # Defer evaluation of the property
+        parent.staticPropertyElements.add(self);
+      else
+        # Apply the static property value
+        RubyWrapperBeanAdapter.put3(parent.value, sourceType, name, value);
+      end
+    end
+  end
+
+  def processAttribute( prefix,  localName,  value)
+    if (!readOnly)
+      raise LoadException.new("Attributes are not supported for writable property elements.");
+    end
+
+    super(prefix, localName, value);
+  end
+
+  def processEndElement()
+    super();
+    if (readOnly)
+      processInstancePropertyAttributes();
+      processEventHandlerAttributes();
+      unless @pushd
+        rputs parent.value, "with(get#{@name[0].upcase}#{@name[1..-1]}) do\n#{rget(@value)||@value.inspect}\nend" unless parent.value == @value
+      end
+    end
+  end
+
+  def processCharacters()
+    if (!readOnly)
+      text = xmlStreamReader.getText();
+      #TODO: normal regexes
+      text = extraneousWhitespacePattern.matcher(text).replaceAll(" ");
+
+      set(text.strip());
+    else
+      super();
+    end
+  end
+end
+
+# Element representing an unknown static property
+class UnknownStaticPropertyElement < Element
+  def initialize
+    if (parent == nil)
+      raise LoadException.new("Invalid root element.");
+    end
+
+    if (parent.value == nil)
+      raise LoadException.new("Parent element does not support property elements.");
+    end
+  end
+
+  def isCollection()
+    return false;
+  end
+
+  def set( value)
+    updateValue(value);
+  end
+
+  def processCharacters()
+    text = xmlStreamReader.getText();
+    # TODO: REGEX!
+    text = extraneousWhitespacePattern.matcher(text).replaceAll(" ");
+
+    updateValue(text.strip());
+  end
+end
+
+# Element representing a script block
+class ScriptElement < Element
+  def initialize(current, xmlStreamReader, loadListener, parentLoader)
+    super
+    @source = nil;
+    @charset = parentLoader.charset;
+  end
+
+  def isCollection()
+    return false;
+  end
+
+  def processStartElement()
+    super();
+
+    if (@source != nil && !staticLoad)
+      i = @source.rindex(".");
+      if (i == nil)
+        raise ("Cannot determine type of script \""											+ @source + "\".");
+      end
+      extension = @source[(i + 1)..-1];
+      scriptEngine = nil
+      #TODO: use JRUBY stuff
+      oldLoader = Thread.currentThread().getContextClassLoader();
+      begin
+        Thread.currentThread().setContextClassLoader(classLoader);
+        scriptEngineManager = getScriptEngineManager();
+        scriptEngine = scriptEngineManager.getEngineByExtension(extension);
+      ensure
+        Thread.currentThread().setContextClassLoader(oldLoader);
+      end
+
+      if (scriptEngine == nil)
+        raise ("Unable to locate scripting engine for"											+ " extension " + extension + ".");
+      end
+
+      scriptEngine.setBindings(scriptEngineManager.getBindings(), ScriptContext.ENGINE_SCOPE);
+
+      begin
+        location = nil
+        if (@source[0] == '/')
+          location = classLoader.getResource(@source[(1)..-1]);
+        else
+          if (parentLoader.location == nil)
+            raise LoadException.new("Base location is undefined.");
+          end
+
+          location = URL.new(parentLoader.location, @source);
+        end
+
+        InputStreamReader scriptReader = nil;
+        begin
+          scriptReader = InputStreamReader.new(location.openStream(), @charset);
+          scriptEngine.eval(scriptReader);
+        rescue ScriptException => exception
+          exception.printStackTrace();
+        ensure
+          if (scriptReader != nil)
+            scriptReader.close();
+          end
+        end
+      rescue IOException => exception
+        raise LoadException.new(exception);
+      end
+    end
+  end
+
+  def processEndElement()
+    super();
+    if (value != nil && !parentLoader.staticLoad)
+      # Evaluate the script
+      begin
+        rputs nil, "__local_sem_lang_inst_#{rget_sem(parentLoader.scriptEngine)}.eval(#{value.to_s.inspect})"
+        parentLoader.scriptEngine.eval( value.to_s);
+      rescue ScriptException => exception
+        STDERR.puts (exception.getMessage());
+      end
+    end
+  end
+
+  def processCharacters()
+    if (@source != nil)
+      raise LoadException.new("Script source already specified.");
+    end
+
+    if (parentLoader.scriptEngine == nil && !parentLoader.staticLoad)
+      raise LoadException.new("Page language not specified.");
+    end
+    updateValue(xmlStreamReader.getText());
+  end
+
+  def processAttribute(prefix, localName, value)
+    if (prefix == nil        && localName == (FXL::SCRIPT_SOURCE_ATTRIBUTE))
+      if (loadListener != nil)
+        loadListener.readInternalAttribute(localName, value);
+      end
+
+      @source = value;
+    elsif (localName == (FXL::SCRIPT_CHARSET_ATTRIBUTE))
+      if (loadListener != nil)
+        loadListener.readInternalAttribute(localName, value);
+      end
+
+      @charset = Charset.forName(value);
+    else
+      raise LoadException.new(prefix == nil ? localName : prefix + ":" + localName        + " is not a valid attribute.");
+    end
+  end
+end
+
+# Element representing a define block
+class DefineElement < Element
+  def isCollection()
+    return true;
+  end
+
+  def add(element)
+    rputs parent.value, rget(element)
+    # No-op
+  end
+
+  def processAttribute(prefix, localName, value)
+    raise LoadException.new("Element does not support attributes.");
+  end
+end