jrubyfx-openjfx.patch 1.2.0-java

data/bin/jrubyfx-jarify

@@ -0,0 +1,115 @@
+#!/usr/bin/env jruby
+=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 'jrubyfx_tasks'
+
+def usage
+  puts "#{$0} {options} project-folder [output.jar]"
+  puts <<THEOPTIONS
+  project-folder should contain rb files and supporting files
+
+  -m|--main FILE     ruby script to launch when the jar is executed.
+                     Defaults to jar-bootstrap.rb or main.rb
+  -j|--include-jars  Include jars in the jar. (off by default to prevent including
+                     the jar you are building)
+  --native           Create native application packages and installers. (Requires JDK8)
+  -v|--verbose       Turns on the native packagers verbose mode. Useful for
+                     customizing icons, licenses, etc.
+  --name STRING      Name for your native package.
+THEOPTIONS
+  exit -1
+end
+
+if ARGV.length < 1
+  usage
+end
+
+main = ["jar-bootstrap.rb", "main.rb"]
+include_jars = false
+native_bundle = false
+app_name = ""
+verbose = false
+nargs = []
+default_on_next = on_next = ->(arg){true}
+
+# split the args manually
+ARGV.each do |arg|
+  # some args have multiple parts. this is a cheap way to do that (lambdas)
+  next unless on_next.call(arg)
+  case arg
+  when "-m", "--main"
+    on_next = ->(arg){
+      main = [arg]
+      on_next = default_on_next
+      false
+    }
+    next
+  when "-j", "--include-jars"
+    include_jars = true
+    next
+  when "--native"
+    native_bundle = true
+    next
+  when "--name"
+    on_next = ->(arg){
+      app_name = [arg]
+      on_next = default_on_next
+      false
+    }
+    next
+  when "-v", "--verbose"
+    verbose = true
+  when "-h", "--help"
+    usage
+    exit 0
+  when /^-/
+    puts "ERROR! Unrecognized option '#{arg}'!"
+    exit -2
+  end
+  # no flag? must be positional arg
+  nargs << arg
+end
+# set jar default if none passed in
+if nargs.length <= 1
+  nargs << File.basename(nargs[0]) + ".jar"
+end
+# set positional args
+project_folder, output_jar = nargs
+
+# Download the current running JRuby version
+JRubyFX::Tasks::download_jruby(JRUBY_VERSION)
+
+# set the main script to the first (must be passed in), or tries to find
+# a file that does exists. Silently fails if it fails.
+main_script = main[0]
+if main.length > 1
+  main.each do |scrpt|
+    ps = project_folder + "/" + scrpt
+    if File.exists? ps
+      main_script = ps
+      break
+    end
+  end
+end
+
+# Jarify!
+JRubyFX::Tasks::jarify_jrubyfx(project_folder + "/*", main_script, nil, output_jar, :file_filter => ->(filename){!filename.end_with?(".jar") or include_jars})
+
+if native_bundle
+  JRubyFX::Tasks::native_bundles(Dir.pwd, output_jar, verbose, app_name[0])
+end

data/lib/jrubyfx.rb

@@ -0,0 +1,41 @@
+=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
+
+if RUBY_VERSION.include? "1.8" or !JRUBY_VERSION
+  puts "JRubyFX requires JRuby to be in 1.9 mode"
+  exit -2
+end
+if Gem::Version.new(JRUBY_VERSION) < Gem::Version.new("1.7.4")
+  puts "Warning: JRuby 1.7.3 and prior have bugs that can cause strange errors. Do not submit any bug reports. Please use JRuby 1.7.4 or later."
+end
+
+require 'java' # for java_import
+require 'jruby/core_ext' # for the become_java!
+
+unless File.size? "#{File.dirname(__FILE__)}/jrubyfx/imports.rb"
+  puts "Please run `rake reflect` to generate the imports"
+  exit -1
+end
+# JRubyFX includes
+require_relative 'jrubyfx/imports'
+require_relative 'jrubyfx/module'
+require_relative 'jrubyfx/dsl'
+require_relative 'jrubyfx/dsl_control'
+JRubyFX::DSL.load_dsl # load it after we require the dsl package to not loop around
+require_relative 'jrubyfx/application'
+require_relative 'jrubyfx/controller'
+require_relative 'jrubyfx/java_fx_impl'

data/lib/jrubyfx/application.rb

@@ -0,0 +1,42 @@
+=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
+
+##
+# Inherit from this class for FXML Applications. You must use this class for both
+# raw JavaFX and FXML as it contains the launch method.
+class JRubyFX::Application < Java.javafx.application.Application
+  include JRubyFX
+  include JRubyFX::DSL
+
+  ##
+  # Are we packaged in a jar? This does some comparison, and may get false positives
+  # and, if jruby changes, false negatives. If you are using this, it might be a
+  # very bad idea... (though it is handy)
+  def self.in_jar?()
+    $LOAD_PATH.inject(false) { |res,i| res || i.include?("/META-INF/jruby.home/lib/ruby/")}
+  end
+
+  ##
+  # call-seq:
+  #   launch()
+  #
+  # When called on a subclass, this is effectively our main method.
+  def self.launch(*args)
+    #call our custom launcher to avoid a java shim
+    JavaFXImpl::Launcher.launch_app(self, *args)
+  end
+end

data/lib/jrubyfx/compiler_app.rb

@@ -0,0 +1,51 @@
+=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 'jrubyfx'
+
+# This class is used by the rake task to compile fxml files
+class CompilerApp < JRubyFX::Application
+  def start(stage)
+    begin
+      args = parameters.raw.to_a
+      if args.include? "--"
+        ar, requires = split(args, "--")
+        requires.each {|x| require x}
+        ar
+      else
+        args
+      end.each do |arg|
+        loader = FxmlLoader.new
+        loader.location = URL.new "file:#{arg}"
+        loader.controller = Object.new
+        puts "Compiling #{arg}..."
+        loader.load(jruby_ext: {jit: 0, dont_load: true, jit_opts: {force: true}})
+      end
+      puts "done"
+    rescue java.lang.Throwable, Exception => e
+      $JRUBYFX_AOT_ERROR = e
+    ensure
+      Platform.exit
+    end
+  end
+
+  def split(arr, delim)
+    index = arr.index(delim)
+    first = arr[0...index]
+    second = arr[(index+1)..-1]
+    return first, second
+  end
+end

data/lib/jrubyfx/controller.rb

@@ -0,0 +1,375 @@
+=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 'jrubyfx/utils/string_utils'
+# If fxmlloader is installed, require it here
+begin
+  require 'jrubyfx-fxmlloader'
+rescue LoadError
+  # no fxmlloader, ignore it
+end
+
+# Special methods for fxml loading
+module Kernel
+  @@jrubyfx_res_dir = {}
+  @@jrubyfx_fxml_res_cl = nil
+  def fxml_root(value=nil, jar_value=nil, class_loader = nil)
+  	@@jrubyfx_fxml_res_cl = class_loader if class_loader
+    if value or jar_value
+      @@jrubyfx_fxml_dir = (JRubyFX::Application.in_jar? and jar_value) ? jar_value : File.expand_path(value)
+    else
+      @@jrubyfx_fxml_dir
+    end
+  end
+  def resource_root(res_name, value=nil, jar_value=nil)
+    if value or jar_value
+      @@jrubyfx_res_dir[res_name.to_sym] = (JRubyFX::Application.in_jar? and jar_value) ? jar_value : File.expand_path(value)
+    else
+      @@jrubyfx_res_dir[res_name.to_sym]
+    end
+  end
+  def get_fxml_resource_class_loader
+  	@@jrubyfx_fxml_res_cl || JRuby.runtime.jruby_class_loader.method("get_resource")
+  end
+  def resource_url(type, relative_path)
+    if JRubyFX::Application.in_jar?
+      get_fxml_resource_class_loader.call("#{resource_root(type)}/#{relative_path}")
+    else
+      java.net.URL.new("file:" + File.join(resource_root(type), relative_path))
+    end
+  end
+end
+
+# Inherit from this class for FXML controllers
+module JRubyFX::Controller
+  include JRubyFX::DSL
+  include JRubyFX::FXImports
+
+  java_import 'java.net.URL'
+
+  DEFAULT_SETTINGS = {
+    width: -1,
+    height: -1,
+    fill: :white,
+    depth_buffer: false,
+    root_dir: nil,
+    initialized: nil
+  }
+
+  # Controllers usually need access to the stage.
+  attr_writer :stage, :scene
+
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.extend(JRubyFX::FXMLClassUtils) if defined? JRubyFX::FXMLClassUtils
+    base.extend(JRubyFX::FXImports)
+    # register ourselves as a control. overridable with custom_fxml_control
+    register_type base if base.is_a? Class
+  end
+
+  # class methods for FXML controllers
+  module ClassMethods
+    include JRubyFX::DSL
+
+    #nested including, TODO: don't duplicate this
+    def included(base)
+      base.extend(JRubyFX::Controller::ClassMethods)
+      # register ourselves as a control. overridable with custom_fxml_control
+      JRubyFX::DSL::ClassUtils.register_type base if base.is_a? Class
+    end
+
+    # Load given fxml file onto the given stage. `settings` is an optional hash of:
+    # * :initialize => [array of arguments to pass to the initialize function]
+    # * :width => Default width of the Scene
+    # * :height => Default height of the Scene
+    # * :fill => Fill color of the Scene's background
+    # * :depth_buffer => JavaFX Scene DepthBuffer argument (look it up)
+    # * :root_dir =>  filename search for fxml realtive to this file
+    #
+    # === Examples
+    #
+    #   controller = MyFXController.new "Demo.fxml", stage
+    #
+    # === Equivalent Java
+    #   Parent root = FXMLLoader.load(getClass().getResource("Demo.fxml"));
+    #   Scene scene = new Scene(root);
+    #   stage.setScene(scene);
+    #   controller = root.getController();
+
+    def load_into(stage, settings={})
+      # Inherit from default settings
+      settings = DEFAULT_SETTINGS.merge({root_dir: (self.instance_variable_get("@fxml_root_dir") || fxml_root),
+          class_loader: (get_fxml_resource_class_loader),
+          filename: self.instance_variable_get("@filename")}).merge settings
+
+      # Custom controls don't always need to be pure java, but oh well...
+      become_java!
+
+      # like new, without initialize
+      ctrl = allocate
+
+      # Set the stage so we can reference it if needed later
+      ctrl.stage = stage
+
+      # load the FXML file
+      root = Controller.get_fxml_loader(settings[:filename], ctrl, settings[:root_dir], settings[:class_loader]).load
+
+      # Unless the FXML root node is a scene, wrap that node in a scene
+      if root.is_a? Scene
+        scene = root
+      else
+        scene = Scene.new root, settings[:width], settings[:height], settings[:depth_buffer]
+        scene.fill = settings[:fill]
+      end
+
+      # set the controller and stage scene
+      ctrl.scene = stage.scene = scene
+
+      ctrl.finish_initialization *settings[:initialize].to_a
+    end
+
+    # This is the default override for custom controls
+    # Normal FXML controllers will use Control#new
+    def new(*args, &block)
+      if @preparsed && @preparsed.length > 0
+        return @preparsed.pop.finish_initialization(*args, &block)
+      end
+      # Custom controls don't always need to be pure java, but oh well...
+      become_java! if @filename
+
+      # like new, without initialize
+      ctrl = allocate
+
+      ctrl.initialize_controller(DEFAULT_SETTINGS.merge({root_dir: @fxml_root_dir || fxml_root,
+            filename: @filename}),
+        *args, &block) if @filename
+
+      # return the controller
+      ctrl
+    end
+
+    def preparse_new(num=3)
+      become_java! if @filename
+      @preparsed ||= []
+      num.times do
+        ctrl = allocate
+        ctrl.pre_initialize_controller(DEFAULT_SETTINGS.merge({root_dir: @fxml_root_dir || fxml_root,
+              filename: @filename})) if @filename
+        @preparsed << ctrl
+      end
+    end
+
+    #decorator to force becoming java class
+    def become_java
+      @force_java = true
+    end
+
+    # Set the filename of the fxml this control is part of
+    def fxml(fxml=nil, name = nil, root_dir = nil)
+      @filename = fxml
+      # snag the filename from the caller
+      @fxml_root_dir = root_dir
+      register_type(self, name) if name
+    end
+
+    ##
+    # Event Handlers
+    ##
+
+    ##
+    # call-seq:
+    #   on(callback, ...) { |event_info| block } => Method
+    #
+    # Registers a function of name `name` for a FXML defined event with the body in the block.
+    # Note you can also just use normal methods
+    #
+    # === Examples
+    #   on :click do
+    #     puts "button clicked"
+    #   end
+    #
+    #   on :moved, :pressed do |event|
+    #     puts "Mouse Moved or Key Pressed"
+    #     p event
+    #   end
+    #
+    # === Equivalent Java
+    #   @FXML
+    #   private void click(ActionEvent event) {
+    #     System.out.println("button clicked");
+    #   }
+    #
+    #   @FXML
+    #   private void moved(MouseEvent event) {
+    #     System.out.println("Mouse Moved or Key Pressed");
+    #   }
+    #
+    #   @FXML
+    #   private void keypress(KeyEvent event) {
+    #     System.out.println("Key Pressed or Key Pressed");
+    #   }
+    #
+    def on(names, &block)
+      [names].flatten.each do |name|
+        class_eval do
+          # must define this way so block executes in class scope, not static scope
+          define_method name, block
+        end
+      end
+    end
+  end
+
+  #default java ctor, override for arguments
+  def java_ctor(ctor, initialize_arguments)
+    ctor.call
+  end
+
+  # Initialize all controllers
+  def initialize_controller(options={}, *args, &block)
+
+    # JRuby complains loudly (probably broken behavior) if we don't call the ctor
+    java_ctor self.class.superclass.instance_method(:initialize).bind(self), args
+
+    # load the FXML file with the current control as the root
+    load_fxml options[:filename], options[:root_dir]
+
+    finish_initialization *args, &block
+  end
+
+  # Initialize all controllers
+  def pre_initialize_controller(options={})
+
+    # JRuby complains loudly (probably broken behavior) if we don't call the ctor
+    java_ctor self.class.superclass.instance_method(:initialize).bind(self), [] #TODO: do we need to call this now with []?
+
+    # load the FXML file with the current control as the root
+    load_fxml options[:filename], options[:root_dir]
+  end
+
+  def load_fxml(filename, root_dir=nil)
+    fx = Controller.get_fxml_loader(filename, self, root_dir || @fxml_root_dir || fxml_root, get_fxml_resource_class_loader)
+    fx.root = self
+    fx.load
+  end
+
+  def finish_initialization(*args, &block)
+    @nodes_by_id = {}
+
+    # custom controls are their own scene
+    self.scene = self unless @scene
+
+    # Everything is ready, call initialize
+    if private_methods.include? :initialize
+      self.send :initialize, *args, &block
+    end
+
+    #return ourself
+    self
+  end
+
+  ##
+  #  Node Lookup Methods
+  ##
+
+  # return first matched node or nil
+  def find(css_selector)
+    @scene.lookup(css_selector)
+  end
+
+  # Return first matched node or throw exception
+  def find!(css_selector)
+    res = find(css_selector)
+    raise "Selector(#{css_selector}) returned no results!" unless res
+    res
+  end
+
+  # return an array of matched nodes
+  def css(css_selector)
+    @scene.get_root.lookup_all(css_selector).to_a
+  end
+
+  # Loads a controller-less file
+  def self.load_fxml_only(filename, stage, settings={})
+    # Inherit from default settings
+    settings = DEFAULT_SETTINGS.merge({root_dir: fxml_root,
+    	class_loader: get_fxml_resource_class_loader,
+        filename: filename}).merge settings
+
+    # load the FXML file
+    root = Controller.get_fxml_loader(settings[:filename], nil, settings[:root_dir], settings[:class_loader]).load
+
+    # TODO: de-duplicate this code
+
+    # Unless the FXML root node is a scene, wrap that node in a scene
+    if root.is_a? Scene
+      scene = root
+    else
+      scene = Scene.new root, settings[:width], settings[:height], settings[:depth_buffer]
+      scene.fill = settings[:fill]
+    end
+
+    # set the controller and stage scene
+    stage.scene = scene
+  end
+
+
+  ##
+  # call-seq:
+  #   get_fxml_loader(filename) => FXMLLoader
+  #   get_fxml_loader(filename, controller_instance) => FXMLLoader
+  #   get_fxml_loader(filename, controller_instance, root_dir) => FXMLLoader
+  #
+  # Load a FXML file given a filename and a controller and return the loader
+  # root_dir is a directory that the file is relative to.
+  # === Examples
+  #   root = JRubyFX::Controller.get_fxml_loader("Demo.fxml").load
+  #
+  #   root = JRubyFX::Controller.get_fxml_loader("Demo.fxml", my_controller).load
+  #
+  # === Equivalent Java
+  #   Parent root = FXMLLoader.load(getClass().getResource("Demo.fxml"));
+  #
+  def self.get_fxml_loader(filename, controller = nil, root_dir = nil, class_loader = JRuby.runtime.jruby_class_loader.method("get_resource"))
+    fx = FxmlLoader.new
+    fx.location = get_fxml_location(root_dir, filename, class_loader)
+    # we must set this here for JFX to call our events
+    fx.controller = controller
+    fx
+  end
+  
+  def self.get_fxml_location(root_dir, filename, class_loader)
+    if JRubyFX::Application.in_jar? and filename.match(/^[^.\/]/)
+      # If we are in a jar file, use the class loader to get the file from the jar (like java)
+      # TODO: should just be able to use URLs
+      
+      # According to how class loader works, the correct path for a file inside a jar is NOT "/folder/file.fxml" 
+      # but "folder/file.fxml" (without starting "/" or ".", which would both make the path to be seen as a filesystem 
+      # reference) so we assume that if root_dir is set to "" or to any other path not starting with "." or "/" then 
+      # we want to point to a folder inside the jar, otherwise to a filesystem's one. According to this we format and 
+      # feed the right path to the class loader.
+      
+      location = class_loader.call(File.join(root_dir, filename))
+      
+      # fall back if not found
+      return location if location
+    end
+    
+    root_dir ||= fxml_root
+    # If we are in the normal filesystem, create a file url path relative to relative_to or this file
+    URL.new "file:#{File.join root_dir, filename}"
+  end
+end