jrubyfx 1.1.0-java → 2.0.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2663b39ced8255fd70b6666efcf58ad87133d4a385f5f01dc8fd6d9797ebf298
+  data.tar.gz: ec875fdd53ca592f9023004b83595d902d8dd74a680a2b3830df71a744369b4c
+SHA512:
+  metadata.gz: dee292568c4247cff866bccffab39a1f2ee1928c95c776649540a459a3edb5f3d4b90ae49a17b50906f38e96a24f4ca0d0ecf3235d3d6c1ce702c606fefb2170
+  data.tar.gz: f3e259057d479843db42ed9e9582a2e3acbd64fa214221a639dbc6d965fa86f456e3e4b96e0e734971a1c4989829d335600457ec9be61b7dd373675535d61c6b

data/README.md

@@ -1,24 +1,34 @@
 JRubyFX
 =======
-JRubyFX is a pure ruby wrapper for JavaFX 2.2+ with FXML support
+JRubyFX is a pure ruby wrapper for JavaFX 2.2+ with FXML support. Currently supported: Java 8+, JRuby 9.3+.
 
 Status
 ------
-JRubyFX master should be usable in its current form and able to run simple FXML apps if used properly (see Issues).
-FXML syntax in master/1.0 is very different from 0.9 series. Please see the [JRubyFX github wiki](https://github.com/jruby/jrubyfx/wiki/) for more details.
+JRubyFX master should be usable in its current form and able to run most FXML apps.
+As of JRubyFX 2.0, the Java FXML Loader is used. This requires JRuby 9.3+. 
+Please see the [JRubyFX github wiki](https://github.com/jruby/jrubyfx/wiki/) for upgrading from 1.x.
 
 Install
 -----
+
+For JRuby 9.3.4+:
+
 ```text
 gem install jrubyfx
 ```
+For older JRuby versions:
+
+```text
+gem install jrubyfx -v 1.2
+```
+
+If you are using Java 9+, additionally append the contents of `module-opens.txt` to `bin/.jruby.java_opts` in your jruby install. If you fail to do this, you may get inscruitable "method X not found, did you mean X?" errors.
 
 Manual Build and Install
 -----
-Build is done using rake/gem/bundler/rdoc. You need JRuby >1.7.4 (in 1.9 mode), Java >1.6 with JavaFX 2.2, but Java 7 is recommended. Building native application packages requires JDK 8.
+Build is done using rake/gem/bundler/rdoc. You need JRuby >= 9.3.4.0, Java >= 8 with JavaFX 11 modules installed (only required for `reflect` task). Building native application packages requires JDK 8+.
 
 ```text
-gem install jrubyfx-fxmlloader
 rake install
 ```
 Once the gem is installed, just run a ruby file that uses it normally.
@@ -26,7 +36,11 @@ Once the gem is installed, just run a ruby file that uses it normally.
 **NOTE:** If you don't have JRuby installed as the `ruby` command, use `jruby -S rake` instead of `rake`. If
 you are using RVM, this does not apply to you (though make sure you `rvm use jruby`).
 
-**If you are reporting bugs or encountering fxml issues:** please install [master jrubyfx-fxmlloader](https://github.com/byteit101/JRubyFX-FXMLLoader/) instead of from rubygems
+**If you are reporting bugs or encountering fxml issues:** please ensure you are using JRubyFX 2.0. Prior version relied on a ported fxml parser and had many known issues.
+
+Updating the Imports
+--------------
+JRubyFX currently uses the 11-based classes for the default imports (part_imports.rb). In the future, this list may change. See `gen_tree.rb` for a script to help automate finding the classes to import. 
 
 Creating a Jar
 --------------
@@ -94,16 +108,13 @@ If you want rdoc, run `rake rdoc`. Please note that there are lots of generated
 
 Issues
 ------
-* Use JRubyFX-FxmlLoader's FxmlLoader instead of javafx.fxml.FXMLLoader for maximum Ruby support.
-* FXML support in master for very complex documents is untested. Report bugs against JRubyFX-FxmlLoader with the FXML file if it fails.
-* You must use the provided JavaFXImpl::Launcher to launch the app (aka: call _yourFXApplicationClass_.launch())
 * Errors loading JavaFX are bugs. Please report if you encounter this issue, tell us your platform, OS, and version of JRuby
 * Jarify command needs the `jar` executable in your path.
 * Any other difficulties are bugs. Please report them
 
 Contact
 -------
-Find us in #jruby on freenode.
+Find us in #jruby on matrix.
 
 License
 -------

data/lib/jrubyfx/application.rb

@@ -27,7 +27,7 @@ class JRubyFX::Application < Java.javafx.application.Application
   # 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?(".jar!/META-INF/jruby.home/lib/ruby/")}
+    $LOAD_PATH.inject(false) { |res,i| res || i.include?("/META-INF/jruby.home/lib/ruby/")}
   end
 
   ##
@@ -36,7 +36,7 @@ class JRubyFX::Application < Java.javafx.application.Application
   #
   # 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)
+    # Note: object args are no longer allowed
+    Java.javafx.application.Application.launch(self.become_java!, args.map(&:to_s).to_java(:string))
   end
 end

data/lib/jrubyfx/compiler_app.rb

@@ -35,6 +35,8 @@ class CompilerApp < JRubyFX::Application
         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

data/lib/jrubyfx/controller.rb

@@ -15,28 +15,39 @@ See the License for the specific language governing permissions and
 limitations under the License.
 =end
 
-require 'jrubyfx-fxmlloader'
+require 'jrubyfx/utils/string_utils'
+require 'jrubyfx/fxml_helper'
+require 'jruby/core_ext'
 
 # Special methods for fxml loading
 module Kernel
   @@jrubyfx_res_dir = {}
-  def fxml_root(value=nil, jar_value=nil)
+  @@jrubyfx_fxml_res_cl = nil
+  def fxml_root(value=nil, jar_value=nil, get_resources: nil, fxml_class_loader: nil)
+  	@@jrubyfx_fxml_res_cl = get_resources if get_resources
+  	@@jrubyfx_fxml_main_cl = fxml_class_loader if fxml_class_loader
     if value or jar_value
-      @@jrubyfx_fxml_dir = JRubyFX::Application.in_jar? ? jar_value : File.expand_path(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? ? jar_value : File.expand_path(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 get_fxml_classes_class_loader
+  	@@jrubyfx_fxml_main_cl ||= JRubyFX::PolyglotClassLoader.new
+  end
   def resource_url(type, relative_path)
     if JRubyFX::Application.in_jar?
-      JRuby.runtime.jruby_class_loader.get_resource("#{resource_root(type)}/#{relative_path}");
+      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
@@ -64,8 +75,12 @@ module JRubyFX::Controller
 
   def self.included(base)
     base.extend(ClassMethods)
-    base.extend(JRubyFX::FXMLClassUtils)
+    base.extend(JRubyFX::FXMLClassUtils) if defined? JRubyFX::FXMLClassUtils
     base.extend(JRubyFX::FXImports)
+    base.configure_java_class ctor_name: "java_ctor" do
+      dispatch :initialize, :fx_initialize # we want to load our code before calling user code
+      # un-exclude "initialize"
+    end
     # register ourselves as a control. overridable with custom_fxml_control
     register_type base if base.is_a? Class
   end
@@ -102,10 +117,20 @@ module JRubyFX::Controller
     def load_into(stage, settings={})
       # Inherit from default settings
       settings = DEFAULT_SETTINGS.merge({root_dir: (self.instance_variable_get("@fxml_root_dir") || fxml_root),
+          get_resources: get_fxml_resource_class_loader,
+          fxml_class_loader: get_fxml_classes_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!
+          
+      raise "JRubyFX 1.x style class loader argument passed into 'load_into'. Replace 'class_loader' with either 'get_resources' (likely) or 'fxml_class_loader' (less likely)" if settings.has_key? :class_loader
+          
+      unless @built
+        ## Use the temporary loader to reformat AController
+        JRubyFX::FxmlHelper.transform self, Controller.get_fxml_location(settings[:root_dir], settings[:filename], settings[:get_resources])
+  
+        # Custom controls don't always need to be pure java, but oh well...
+        become_java!
+        @built = true
+      end
 
       # like new, without initialize
       ctrl = allocate
@@ -114,7 +139,7 @@ module JRubyFX::Controller
       ctrl.stage = stage
 
       # load the FXML file
-      root = Controller.get_fxml_loader(settings[:filename], ctrl, settings[:root_dir]).load
+      root = Controller.get_fxml_loader(settings[:filename], ctrl, settings[:root_dir], settings[:get_resources], settings[:fxml_class_loader]).load
 
       # Unless the FXML root node is a scene, wrap that node in a scene
       if root.is_a? Scene
@@ -136,14 +161,24 @@ module JRubyFX::Controller
       if @preparsed && @preparsed.length > 0
         return @preparsed.pop.finish_initialization(*args, &block)
       end
+      
+      settings = DEFAULT_SETTINGS.merge({root_dir: @fxml_root_dir || fxml_root, get_resources: get_fxml_resource_class_loader,
+          fxml_class_loader: get_fxml_classes_class_loader, filename: @filename})
+      
       # Custom controls don't always need to be pure java, but oh well...
-      become_java! if @filename
+      if @filename && !@built
+        @built = true # TODO: move later if no new :bake call
+        ## Use the temporary loader to reformat AController
+        JRubyFX::FxmlHelper.transform self, Controller.get_fxml_location(settings[:root_dir], settings[:filename], settings[:get_resources])
+  
+        # Custom controls don't always need to be pure java, but oh well...
+        become_java!
+      end
 
       # like new, without initialize
       ctrl = allocate
 
-      ctrl.initialize_controller(DEFAULT_SETTINGS.merge({root_dir: @fxml_root_dir || fxml_root,
-            filename: @filename}),
+      ctrl.initialize_controller(settings,
         *args, &block) if @filename
 
       # return the controller
@@ -220,17 +255,22 @@ module JRubyFX::Controller
       end
     end
   end
+  
+  # java initialize is redirected to here
+  def fx_initialize()
+    # Do nothing, as we already control initialization
+  end
 
   #default java ctor, override for arguments
-  def java_ctor(ctor, initialize_arguments)
-    ctor.call
+  def java_ctor(*initialize_arguments)
+    super()
   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
+    __jallocate!() # TODO: args? TODO: non-java controllers?*args) # TODO: remove
 
     # load the FXML file with the current control as the root
     load_fxml options[:filename], options[:root_dir]
@@ -242,14 +282,14 @@ module JRubyFX::Controller
   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 []?
+    java_ctor self.class.instance_method(:__jallocate!).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)
+    fx = Controller.get_fxml_loader(filename, self, root_dir || @fxml_root_dir || fxml_root, get_fxml_resource_class_loader, get_fxml_classes_class_loader)
     fx.root = self
     fx.load
   end
@@ -261,7 +301,7 @@ module JRubyFX::Controller
     self.scene = self unless @scene
 
     # Everything is ready, call initialize
-    if private_methods.include? :initialize
+    if private_methods.include? :initialize or methods.include? :initialize
       self.send :initialize, *args, &block
     end
 
@@ -294,10 +334,14 @@ module JRubyFX::Controller
   def self.load_fxml_only(filename, stage, settings={})
     # Inherit from default settings
     settings = DEFAULT_SETTINGS.merge({root_dir: fxml_root,
+    	get_resources: get_fxml_resource_class_loader,
+        fxml_class_loader: get_fxml_classes_class_loader,
         filename: filename}).merge settings
-
+          
+    raise "JRubyFX 1.x style class loader argument passed into 'load_fxml_only'. Replace 'class_loader' with either 'get_resources' (likely) or 'fxml_class_loader' (less likely)" if settings.has_key? :class_loader
+    
     # load the FXML file
-    root = Controller.get_fxml_loader(settings[:filename], nil, settings[:root_dir]).load
+    root = Controller.get_fxml_loader(settings[:filename], nil, settings[:root_dir], settings[:get_resources], settings[:fxml_class_loader]).load
 
     # TODO: de-duplicate this code
 
@@ -330,20 +374,33 @@ module JRubyFX::Controller
   # === Equivalent Java
   #   Parent root = FXMLLoader.load(getClass().getResource("Demo.fxml"));
   #
-  def self.get_fxml_loader(filename, controller = nil, root_dir = nil)
-    fx = FxmlLoader.new
-    fx.location =
-      if JRubyFX::Application.in_jar?
-      # 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
-      JRuby.runtime.jruby_class_loader.get_resource File.join(root_dir, filename)
-    else
-      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
+  def self.get_fxml_loader(filename, controller = nil, root_dir = nil, get_resources = JRuby.runtime.jruby_class_loader.method("get_resource"), fxml_class_loader=nil)
+    fx = javafx.fxml.FXMLLoader.new(get_fxml_location(root_dir, filename, get_resources))
+	fx.class_loader = fxml_class_loader unless fxml_class_loader.nil?
     # we must set this here for JFX to call our events
     fx.controller = controller
     fx
   end
+  
+  def self.get_fxml_location(root_dir, filename, get_resources)
+    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 = get_resources.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

data/lib/jrubyfx/core_ext/exts.yml

@@ -16,6 +16,9 @@
 "Java::JavafxSceneControl::TreeItem":
    method_missing: "Java::JavafxSceneControl::TreeItem"
    add: get_children
+"Java::JavafxSceneControl::TreeTableView":
+   method_missing: "Java::JavafxSceneControl::TreeItem"
+   add: get_children
 "Java::JavafxSceneControl::TableView":
    method_missing: "Java::JavafxSceneControl::TableColumn"
    add: get_columns
@@ -39,6 +42,8 @@
 "Java::JavafxAnimation::Timeline":
    method_missing: "Java::JavafxAnimation::KeyFrame"
    add: key_frames
+"Java::JavafxSceneLayout::BackgroundFill":
+   new_converter: [[color, none, none]]
 "Java::JavafxSceneShape::Path":
    add: elements
    rotate: []
@@ -51,7 +56,10 @@
    logical_children: panes
 "Java::JavafxSceneShape::Circle":
    new_converter: [[], [none], [none, color], [none, none, none], [none, none, none, color]]
+"Java::JavafxSceneShape::Rectangle":
+   new_converter: [[], [none, none], [none, none, none, none], [none, none, color]]
 "Java::JavafxScenePaint::Stop":
    new_converter: [[none, color]]
 "Java::JavafxSceneShape::Shape":
-   getter_setter: fill
+   getter_setter: fill
+

data/lib/jrubyfx/core_ext/observable_value.rb

@@ -131,6 +131,24 @@ module Java::javafx::collections::ObservableMap
   # stores the listeners.
 end
 
+module Java::javafx::beans::binding::NumberExpression
+  def - x
+    subtract x
+  end
+  def / x
+    divide x
+  end
+  def * x
+    multiply x
+  end
+  def + x
+    add x
+  end
+  def -@ x
+    negate x
+  end
+end
+
 class Class
   def property_writer(*symbol_names)
     symbol_names.each do |symbol_name|
@@ -147,8 +165,8 @@ class Class
     end
   end
   def property_accessor(*symbol_names)
-    property_reader *symbol_names
-    property_writer *symbol_names
+    property_reader(*symbol_names)
+    property_writer(*symbol_names)
     symbol_names.each do |symbol_name|
       send(:define_method, symbol_name.id2name + "_property") do
         instance_variable_get("@#{symbol_name}")