jrubyfx 0.9.1-java

data/lib/jrubyfx/core_ext/transition.rb

@@ -0,0 +1,25 @@
+=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
+
+{:Rotate => :angle, :Scale => [:x, :y, :z], :Translate => [:x, :y, :z],
+  :Fade => :value, :Fill => :value, :Stroke => :value}.each do |clas, anim_props|
+  JavaUtilities.get_proxy_class("javafx.animation.#{clas}Transition").class_eval do
+    extend JRubyFX::Utils::CommonConverters
+
+    animation_converter_for *anim_props
+  end
+end

data/lib/jrubyfx/core_ext/xy_chart.rb

@@ -0,0 +1,53 @@
+=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/dsl'
+
+# JRubyFX DSL extensions for JavaFX XYCharts
+class Java::javafx::scene::chart::XYChart
+  include JRubyFX::DSL
+
+  ##
+  # This will defer to node to construct proper object, but will
+  # optionally add paths primary child automatically if it is a
+  # PathElement.
+  def method_missing(name, *args, &block)
+    super.tap do |obj|
+      data.add(obj) if obj.kind_of? XYChart::Series
+    end
+  end
+end
+
+# JRubyFX DSL extensions for JavaFX XYChart Series
+class Java::javafx::scene::chart::XYChart::Series
+  include JRubyFX::DSL
+
+  ##
+  # This will defer to node to construct proper object, but will
+  # optionally add paths primary child automatically if it is a
+  # PathElement.
+  def method_missing(name, *args, &block)
+    super.tap do |obj|
+      data.add(obj) if obj.kind_of? XYChart::Data
+    end
+  end
+
+end
+
+# JRubyFX DSL extensions for JavaFX XYChart Data
+class Java::javafx::scene::chart::XYChart::Data
+  include JRubyFX::DSL
+end

data/lib/jrubyfx/dsl.rb

@@ -0,0 +1,217 @@
+=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 'java'
+require 'jrubyfx'
+
+module JRubyFX
+  # Defines a nice DSL for building JavaFX applications. Include it in a class for
+  # access to the DSL. JRubyFX::Application and JRubyFX::Controller include it already.
+  module DSL
+    include JRubyFX
+
+    # Contains methods to be defined inside all classes that include JRubyFX
+    module ClassUtils
+      include JRubyFX::FXImports
+      
+      # Make sure we are added to the mapping. FIXME: is this ever used?
+      def register_type(name, type)
+        JRubyFX::DSL::NAME_TO_CLASSES[name.to_s] = type
+      end
+      
+      # Lots of DSL extensions use these methods, so define them here so multiple classes can use them
+      
+      ##
+      # call-seq:
+      #   include_add
+      #   include_add :child_getter
+      # 
+      # Include a function to add to child list (optional argument) without need
+      # to ask for children
+      #   include_add
+      #   include_add :elements
+      #
+      def include_add(adder = :get_children)
+        self.class_eval do
+          define_method :add do |value|
+            self.send(adder) << value
+          end
+        end
+      end
+      
+      ##
+      # Adds a function to the class that Adds rotate to transform (manually 
+      # added ebcause there is a getRotate on Node already.  Use get_rotate
+      # to get property
+      def include_rotate
+        self.class_eval do
+          def rotate(*args) #:nodoc:
+            transforms << build(Rotate, *args)
+          end
+        end
+      end
+    
+      ##
+      # Adds a method_missing that automatically calls add if the DSL builds it
+      # as the given type.
+      # This will defer to node to construct proper object, but will
+      # optionally add paths primary child automatically if it is a
+      # PathElement.
+      def include_method_missing(type)
+        self.class_eval do
+          define_method :method_missing do |name, *args, &block|
+            # we must manually call super otherwise it will call super(type)
+            super(name, *args, &block).tap do |obj|
+              add(obj) if obj.kind_of? type
+            end
+          end
+        end
+      end
+    end
+
+    # When a class includes JRubyFX, extend (add to the metaclass) ClassUtils
+    def self.included(mod)
+      mod.extend(JRubyFX::DSL::ClassUtils)
+    end
+
+    #--
+    # FIXME: This should be broken up with nice override for each type of 
+    # fx object so we can manually create static overrides.
+    #++
+    # The list of snake_case names mapped to full java classes to use for DSL mapping.
+    # This list is dynamically generated using JRubyFX::FXImports::JFX_CLASS_HIERARCHY and
+    # Hash.flat_tree_inject.
+    NAME_TO_CLASSES = {
+      # observable structs
+      'observable_array_list' => proc { |*args| FXCollections.observable_array_list(*args) },
+      'double_property' => SimpleDoubleProperty,
+      'xy_chart_series' => Java::javafx.scene.chart.XYChart::Series,
+      'xy_chart_data' => Java::javafx.scene.chart.XYChart::Data,
+    }.merge(JFX_CLASS_HIERARCHY.flat_tree_inject(Hash) do |res, name, values|
+        # Merge in auto-generated list of classes from all the imported classes
+        unless values.is_a? Hash
+          values.map do |i|
+            # this regexp does snake_casing
+            # TODO: Anybody got a better way to get the java class instead of evaling its name?
+            res.merge!({i.snake_case.gsub(/(h|v)_(line|box)/, '\1\2') => eval(i)})
+          end
+          res
+        else
+          # we are not at a leaf node anymore, merge in previous work
+          res.merge!(values)
+        end
+      end)
+    
+    # List of known overrides for enums.
+    ENUM_OVERRIDES = {PathTransition::OrientationType => {:orthogonal_to_tangent => :orthogonal},
+      BlendMode => {:src_over => :over, :src_atop => :atop, :color_dodge => :dodge, :color_burn => :burn},
+      ContentDisplay => {:graphic_only => :graphic, :text_only => :text},
+      BlurType => {:one_pass_box => [:one, :one_pass], :two_pass_box => [:two, :two_pass], :three_pass_box => [:three, :three_pass]},
+      Modality => {:window_modal => :window, :application_modal => [:application, :app]}}
+
+    # This is the heart of the DSL. When a method is missing and the name of the
+    # method is in the NAME_TO_CLASSES mapping, it calls JRubyFX.build with the
+    # Java class. This means that instead of saying
+    #   build(JavaClass, hash) { ... }
+    # you can say
+    #   java_class(hash) { ... }
+    #
+    def method_missing(name, *args, &block)
+      clazz = NAME_TO_CLASSES[name.to_s]
+      super unless clazz
+      
+      build(clazz, *args, &block)
+    end
+
+    alias :node_method_missing :method_missing
+    
+    # Loads the special symbol to enum converter functions into all methods 
+    # and enums
+    def self.load_enum_converter
+      # load overrides
+      ENUM_OVERRIDES.each do |cls, overrides|
+        JRubyFX::Utils::CommonConverters.set_overrides_for cls, overrides
+      end
+      
+      # use reflection to load all enums into all_enums and methods that use them
+      # into enum_methods
+      mod_list = {
+        :methods => [],
+        :all => []
+      }
+      JRubyFX::DSL::NAME_TO_CLASSES.each do |n,cls|
+        cls.java_class.java_instance_methods.each do |method|
+          args = method.argument_types.find_all(&:enum?).tap {|i| mod_list[:all] <<  i }
+          
+          # one and only, must be a setter style
+          if method.argument_types.length == 1 and (args.length == method.argument_types.length)
+            mod_list[:methods] << [method.name, cls]
+          end
+        end if cls.respond_to? :ancestors and cls.ancestors.include? JavaProxy # some are not java classes. ignore those
+      end
+      
+      # Get the proper class (only need them once)
+      mod_list[:all] = mod_list[:all].flatten.uniq.map {|i| JavaUtilities.get_proxy_class(i) }
+      
+      # Inject our converter into each enum/class
+      mod_list[:all].each do |enum|
+        inject_symbol_converter enum
+      end
+      
+      # finally, "override" each method
+      mod_list[:methods].each do |method|
+        inject_enum_method_converter *method
+      end
+    end
+    
+    # Adds `parse_ruby_symbols` method to given enum/class to enable symbol conversion
+    def self.inject_symbol_converter(jclass)
+      # inject!
+      class << jclass
+        define_method :parse_ruby_symbols do |const|
+          # cache it. It could be expensive
+          @map = JRubyFX::Utils::CommonConverters.map_enums(self) if @map == nil
+          @map[const.to_s] || const
+        end
+      end
+    end
+    
+    # "overrides" given function name in given class to parse ruby symbols into
+    # proper enums. Rewrites method name as `my_method=` from `setMyMethod`
+    def self.inject_enum_method_converter(jfunc, in_class)
+      jclass = in_class.java_class.java_instance_methods.find_all {|i| i.name == jfunc.to_s}[0].argument_types[0]
+      jclass = JavaUtilities.get_proxy_class(jclass)
+      
+      # Define the conversion function as the snake cased assignment, calling parse_ruby
+      in_class.class_eval do
+        define_method "#{jfunc.to_s.gsub(/^set/i,'').snake_case}=" do |rbenum|
+          java_send jfunc, [jclass], jclass.parse_ruby_symbols(rbenum)
+        end
+      end
+    end
+    
+    # This loads the entire DSL. Call this immediately after requiring 
+    # this file, but not inside this file, or it requires itself twice.
+    def self.load_dsl
+      rt = "#{File.dirname(__FILE__)}/core_ext/"
+      Dir.foreach rt do |file|
+        require_relative "core_ext/#{file}" unless [".", ".."].include? file
+      end
+      
+      JRubyFX::DSL.load_enum_converter()
+    end
+  end
+end

data/lib/jrubyfx/fxml_application.rb

@@ -0,0 +1,44 @@
+=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'
+
+##
+# 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?(".jar!/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/fxml_controller.rb

@@ -0,0 +1,270 @@
+=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'
+
+# Inherit from this class for FXML controllers
+class JRubyFX::Controller
+  include JRubyFX
+  include JRubyFX::DSL
+  java_import 'java.net.URL'
+  java_import 'javafx.fxml.FXMLLoader'
+  
+  # Controllers usually need access to the stage.
+  attr_accessor :stage
+  
+  ##
+  # call-seq:
+  #   fx_handler(callback) { |event_info| block } => Method
+  #   fx_handler(callback, EventType) { |event_info| block } => Method
+  #   fx_type_handler(callback) { |event_info| block } => Method
+  # 
+  # Registers a function of name `name` for a FXML defined event with the body in the block
+  # Note: there are overrides for most of the default types, so you should never
+  # need to manually specify the `type` argument unless you have custom events.
+  # The overrides are in the format fx_*_handler where * is the event type (ex:
+  # fx_key_handler for KeyEvent).
+  # === Overloads
+  # * fx_key_handler is for KeyEvent
+  # * fx_mouse_handler is for MouseEvent
+  # * fx_touch_handler is for TouchEvent
+  # * fx_gesture_handler is for GestureEvent
+  # * fx_context_handler is for ContextMenuEvent
+  # * fx_context_menu_handler is for ContextMenuEvent
+  # * fx_drag_handler is for DragEvent
+  # * fx_ime_handler is for InputMethodEvent
+  # * fx_input_method_handler is for InputMethodEvent
+  # * fx_window_handler is for WindowEvent
+  # * fx_action_handler is for ActionEvent
+  # * fx_generic_handler is for Event
+  # 
+  # === Examples
+  #   fx_handler :click do
+  #     puts "button clicked"
+  #   end
+  #   
+  #   fx_mouse_handler :moved do |event|
+  #     puts "Mouse Moved"
+  #     p event
+  #   end
+  #   
+  #   fx_key_handler :keypress do
+  #     puts "Key Pressed"
+  #   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");
+  #   }
+  #   
+  #   @FXML
+  #   private void keypress(KeyEvent event) {
+  #     System.out.println("Key Pressed");
+  #   }
+  #
+  def self.fx_handler(names, type=ActionEvent, &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)
+        #the first arg is the return type, the rest are params
+        add_method_signature name, [Void::TYPE, type]
+      end
+    end
+  end
+  
+  # Get the singleton class, and add special overloads as fx_EVENT_handler
+  # This funky syntax allows us to define methods on self (like define_method("self.method"),
+  # except that does not work)
+  class << self
+    include JRubyFX::FXImports
+    {:key => KeyEvent,
+      :mouse => MouseEvent,
+      :touch => TouchEvent,
+      :gesture => GestureEvent,
+      :context => ContextMenuEvent,
+      :context_menu => ContextMenuEvent,
+      :drag => DragEvent,
+      :ime => InputMethodEvent,
+      :input_method => InputMethodEvent,
+      :window => WindowEvent,
+      :action => ActionEvent,
+      :generic => Event}.each do |method, klass|
+      #instance_eval on the self instance so that these are defined as class methods
+      self.instance_eval do
+        # define the handy overloads that just pass our arguments in
+        define_method("fx_#{method}_handler") do |name, &block|
+          fx_handler(name, klass, &block)
+        end
+      end
+    end
+  end
+  
+  # FXML linked variable names by subclass
+  @@fxml_linked_args = {}
+  
+  ##
+  # call-seq:
+  #   fx_id :name, ...
+  #   
+  # Register one or more variable names to bind to a fx:id in the FXML file.
+  # === Example
+  #   fx_id :myVar
+  # 
+  # === Equivalent Java
+  #   @FXML
+  #   private ClassName myVar;
+  # 
+  def self.fx_id(*name)
+    # we must distinguish between subclasses, hence self.
+    (@@fxml_linked_args[self] ||= []).concat(name)
+  end
+  
+  ##
+  # call-seq:
+  #   fx_id_optional :name, ...
+  #   
+  # Register one or more variable name to bind to a fx:id in the FXML file if it exists.
+  # If the name cannot be found, don't complain.
+  # === Example
+  #   fx_id_optional :myVar
+  # 
+  # === Equivalent Java
+  #   @FXML
+  #   private ClassName myVar;
+  # 
+  def self.fx_id_optional(*names)
+    fx_id *names.map {|i| {i => :quiet} }
+  end
+  
+  ##
+  # Set scene object (setter), and update fxml-injected values. If you are manually
+  # loading FXML, you MUST call this to link `fx_id` specified names.
+  def scene=(s)
+    @scene = s
+    (@@fxml_linked_args[self.class] ||= []).each do |name|
+      quiet = false
+      # you can specify name => [quiet/verbose], so we need to check for that
+      if name.is_a? Hash
+        quiet = name.values[0] == :quiet
+        name = name.keys[0]
+      end
+      # set each instance variable from the lookup on the scene
+      val = s.lookup("##{name}")
+      if val == nil && !quiet
+        puts "[WARNING] fx_id not found: #{name}. Is id set to a different value than fx:id? (if this is expected, use fx_id_optional)"
+      end
+      instance_variable_set("@#{name}".to_sym, val)
+    end
+  end
+  
+  ##
+  # Return the scene object (getter)
+  def scene()
+    @scene
+  end
+  
+  ##
+  # Magic self-java-ifying new call. (Creates a Java instance)
+  def self.new_java(*args)
+    self.become_java!
+    self.new(*args)
+  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)
+  # * :relative_to => number of calls back, or filename. `filename` is evaluated
+  #   as being relative to this. Default is relative to caller (1)
+  # Returns a scene, either a new one, or the FXML root if its a Scene.
+  # === Examples
+  #
+  #   controller = MyFXController.load_fxml("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 self.load_fxml(filename, stage, settings={})
+    # Create our class as a java class with any arguments it wants
+    ctrl = self.new_java *(settings[:initialize] || [])
+    # save the stage so we can reference it if needed later
+    ctrl.stage = stage
+    # load the FXML file
+    parent = load_fxml_resource(filename, ctrl, settings[:relative_to] || 1)
+    # set the controller and stage scene, so that all the fx_id variables are hooked up
+    ctrl.scene = stage.scene = if parent.is_a? Scene
+      parent
+    elsif settings.has_key? :fill
+      Scene.new(parent, settings[:width] || -1, settings[:height] || -1, settings[:fill] || Color::WHITE)
+    else
+      Scene.new(parent, settings[:width] || -1, settings[:height] || -1, settings[:depth_buffer] || settings[:depthBuffer] || false)
+    end
+    # return the controller. If they want the new scene, they can call the scene() method on it
+    return ctrl
+  end
+  
+  ##
+  # call-seq:
+  #   load_fxml_resource(filename) => Parent
+  #   load_fxml_resource(filename, controller_instance) => Parent
+  #   load_fxml_resource(filename, controller_instance, relative_to) => Parent
+  #   
+  # Load a FXML file given a filename and a controller and return the root element
+  # relative_to can be a file that this should be relative to, or an index
+  # of the caller number. If you are calling this from a function, pass 0 
+  # as you are the immediate caller of this function.
+  # === Examples
+  #   root = JRubyFX::Controller.load_fxml_resource("Demo.fxml")
+  # 
+  #   root = JRubyFX::Controller.load_fxml_resource("Demo.fxml", my_controller)
+  # 
+  # === Equivalent Java
+  #   Parent root = FXMLLoader.load(getClass().getResource("Demo.fxml"));
+  #
+  def self.load_fxml_resource(filename, ctrlr=nil, relative_to=0)
+    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)
+      JRuby.runtime.jruby_class_loader.get_resource(filename)
+    else
+      if relative_to.is_a? Fixnum or relative_to == nil
+        # caller[0] returns a string like so:
+        # "/home/user/.rvm/rubies/jruby-1.7.1/lib/ruby/1.9/irb/workspace.rb:80:in `eval'"
+        # and then we use a regex to filter out the filename
+        relative_to = caller[relative_to||0][/(.*):[0-9]+:in /, 1] # the 1 is the first match, aka everything up to the :
+      end
+      # If we are in the normal filesystem, create a normal file url path relative to the main file
+      URL.new(URL.new("file:"), "#{File.dirname(relative_to)}/#{filename}")
+    end
+    # we must set this here for JFX to call our events
+    fx.controller = ctrlr
+    return fx.load()
+  end
+end