jrubyfx 0.9.1-java → 0.9.2-java

data/lib/jrubyfx/core_ext/path.rb

@@ -14,6 +14,8 @@ 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 Paths
 class Java::javafx::scene::shape::Path
   java_import Java::javafx.scene.shape.PathElement

data/lib/jrubyfx/core_ext/progress_indicator.rb

@@ -14,6 +14,8 @@ 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 Progress *
 class Java::javafx::scene::control::ProgressIndicator
   extend JRubyFX::Utils::CommonConverters
@@ -25,6 +27,7 @@ class Java::javafx::scene::control::ProgressIndicator
   converter_for :new, [], [progress_conv]
 
 end
+
 # JRubyFX DSL extensions for JavaFX Progress *
 class Java::javafx::scene::control::ProgressBar
   extend JRubyFX::Utils::CommonConverters

data/lib/jrubyfx/core_ext/region.rb

@@ -14,6 +14,8 @@ 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 color stops
 class Java::javafx::scene::layout::Region
   extend JRubyFX::Utils::CommonConverters
@@ -36,4 +38,5 @@ class Java::javafx::scene::layout::Region
   converter_for :max_width, [use_sizes]
   converter_for :max_height, [use_sizes]
 
+  converter_for :padding, [:insets]
 end

data/lib/jrubyfx/core_ext/rotate.rb

@@ -14,6 +14,8 @@ 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 color stops
 class Java::javafx::scene::transform::Rotate
   extend JRubyFX::Utils::CommonConverters

data/lib/jrubyfx/core_ext/shape.rb

@@ -14,6 +14,8 @@ 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 Shapes
 class Java::javafx::scene::shape::Shape
   extend JRubyFX::Utils::CommonConverters

data/lib/jrubyfx/core_ext/stop.rb

@@ -14,6 +14,8 @@ 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 color stops
 class Java::javafx::scene::paint::Stop
   extend JRubyFX::Utils::CommonConverters

data/lib/jrubyfx/core_ext/timeline.rb

@@ -14,6 +14,8 @@ 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 animation Timelines
 class Java::javafx::animation::Timeline
   java_import Java::javafx.animation.KeyFrame
@@ -24,6 +26,17 @@ class Java::javafx::animation::Timeline
   include_add :key_frames
   include_method_missing KeyFrame
   
+  # call-seq:
+  #   animate myProperty, from_duration => to_duration, start_value => next_value
+  #   animate myProperty, from_duration => [with_duration, ..., to_duration], start_value => [next_value, ...]
+  #   
+  # Animates a given JavaFX property over the given duration, using the given values
+  # as keyFrames
+  # 
+  # === Examples
+  #   animate translateXProperty, 0.sec => [100.ms, 1.sec], 0 => [500, 200]
+  #   animate translateYProperty, 0.sec => 1.sec, 0 => 200
+  #
   def animate(prop, args)
     time = []
     values = []

data/lib/jrubyfx/core_ext/transition.rb

@@ -15,6 +15,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 =end
 
+#:nodoc:
 {: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

data/lib/jrubyfx/core_ext/tree_item.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
+require 'jrubyfx/dsl'
+
+# JRubyFX DSL extensions for JavaFX Tree items
+class Java::javafx::scene::control::TreeItem
+  include JRubyFX::DSL
+
+  include_add
+  include_method_missing TreeItem
+end

data/lib/jrubyfx/core_ext/tree_item.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
+require 'jrubyfx/dsl'
+
+# JRubyFX DSL extensions for JavaFX TableViews
+class Java::javafx::scene::control::TreeItem
+  include JRubyFX::DSL
+  extend JRubyFX::Utils::CommonConverters
+
+  include_add
+end

data/lib/jrubyfx/core_ext/tree_view.rb

@@ -0,0 +1,40 @@
+=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 Tree views
+class Java::javafx::scene::control::TreeView
+  include JRubyFX::DSL
+
+  ##
+  # get_tree_item interferes with idiomatic construction of a root
+  # tree_item.  We override and users should use get_tree_item(i)
+  # if they want the original method.
+  def tree_item(*args, &block)
+    method_missing(:tree_item, *args, &block)
+  end
+
+  ##
+  # Add any child tree items as the root node.  Note, that there
+  # is only one root and successive tree_items in a tree_view will
+  # keep replacing the root.
+  def method_missing(name, *args, &block)
+    super.tap do |obj|
+      set_root(obj) if obj.kind_of? TreeItem
+    end
+  end
+end

data/lib/jrubyfx/core_ext/tree_view.rb~

@@ -0,0 +1,33 @@
+=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 TableViews
+class Java::javafx::scene::control::TreeView
+  include JRubyFX::DSL
+  extend JRubyFX::Utils::CommonConverters
+
+  include_add
+
+  ##
+  # Make sure we add any nested TreeItem's to this one
+  def method_missing(name, *args, &block)
+    super.tap do |obj|
+      add(obj) if obj.kind_of? TreeItem
+    end
+  end
+end

data/lib/jrubyfx/dsl.rb

@@ -27,10 +27,41 @@ module JRubyFX
     module ClassUtils
       include JRubyFX::FXImports
       
-      # Make sure we are added to the mapping. FIXME: is this ever used?
-      def register_type(name, type)
+      ##
+      # Register your own type for use in the DSL.
+      #
+      #   class MyFooWidget < Region
+      #     #...
+      #   end
+      #   #... 
+      #   register_type(MyFooWidget)
+      #   register_type(MyFooWidget, "aliased_name")
+      #
+      # Note, this also makes it possible to override existing definitions
+      # of built-in components.
+      #
+      def register_type(type, name=nil)
+        name = type.name.snake_case unless name
         JRubyFX::DSL::NAME_TO_CLASSES[name.to_s] = type
       end
+
+      ##
+      # Define a dual-mode method which acts as both a getter and
+      # setter depending on whether it has been supplied an argument
+      # or not.
+      #
+      def getter_setter(name)
+        self.class_eval do
+          # FIXME: Is arity of splat the best way to do this?
+          define_method(name) do |*r|
+            if r.length > 0
+              set_effect *r
+            else
+              get_effect
+            end
+          end
+        end
+      end
       
       # Lots of DSL extensions use these methods, so define them here so multiple classes can use them
       
@@ -75,7 +106,7 @@ module JRubyFX
           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
+              add(obj) if obj.kind_of?(type) && !name.to_s.end_with?('!')
             end
           end
         end
@@ -129,8 +160,16 @@ module JRubyFX
     # you can say
     #   java_class(hash) { ... }
     #
+    # Another major portion of the DSL is the ability to implicitly add new
+    # created components to their parent on construction.  There are a few
+    # places where this is undesirable.  In order to prevent implicit 
+    # construction you can add a '!' on the end:
+    #   circle!(30)
+    # This will construct a Circle but it will not add it into its parent
+    # container.  This is useful for specifying clipping regions in particular.
+    #
     def method_missing(name, *args, &block)
-      clazz = NAME_TO_CLASSES[name.to_s]
+      clazz = NAME_TO_CLASSES[name.to_s.gsub(/!$/, '')]
       super unless clazz
       
       build(clazz, *args, &block)
@@ -206,9 +245,9 @@ module JRubyFX
     # 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
+      rt = "#{File.dirname(__FILE__)}/core_ext"
+      Dir.glob("#{rt}/*.rb") do |file|
+        require file
       end
       
       JRubyFX::DSL.load_enum_converter()

data/lib/jrubyfx/fxml_controller.rb

@@ -23,16 +23,16 @@ class JRubyFX::Controller
   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.
@@ -51,32 +51,32 @@ class JRubyFX::Controller
   # * 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");
@@ -92,7 +92,7 @@ class JRubyFX::Controller
       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)
@@ -119,44 +119,97 @@ class JRubyFX::Controller
       end
     end
   end
-  
+
+  # When FXMLLoader detects a method called initialze taking 0 args, then it calls it
+  # We don't want this, as ruby new calls initialize
+  # Override new to avoid calling initialize
+  def self.new(*args, &block)
+    obj = self.allocate
+    obj.send(:initialize_ruby, *args, &block) if defined? obj.initialize_ruby
+    obj
+  end
+
+  # this is the default initialize that the FXML loader will call
+  def initialize()
+  end
+  # this is the default initialized method so we can always call it
+  def initialize_fxml(*args)
+    self.send(:initialize_fxml_warn, *args) if defined? initialize_fxml_warn
+  end
+  alias_method :initialize_orig, :initialize
+
+  # When initialize is defined, rename it to initialized, and restore
+  # initialize to default so java does not double call us
+  def self.method_added(name)
+    if name == :initialize && !@in_alias
+      puts <<WARNIT
+*****************************************************************************
+*****************************************************************************
+**                   WARNING! WARNING! WARNING! WARNING!                   **
+** WARNING! WARNING! WARNING! WARNING! WARNING! WARNING! WARNING! WARNING! **
+**                   WARNING! WARNING! WARNING! WARNING!                   **
+*****************************************************************************
+**                                                                         **
+** You probably meant to define `initialize_fxml` instead of `initialize`  **
+** `initialize` is ambiguous in JavaFX controllers as FXMLLoader will call **
+**  it if it has 0 arguments in addition to it being ruby's constructor.   **
+**  If you need access to FXML elements (defined with `fx_id :myEltId`),   **
+**   then use `initialize_fxml`. If you need the ruby constructor, which   **
+**     does not have access to FXML yet, use `initialize_ruby` instead     **
+**                                                                         **
+**            Assuming you wanted `initialize_fxml` for this run           **
+**                                                                         **
+*****************************************************************************
+**                   WARNING! WARNING! WARNING! WARNING!                   **
+** WARNING! WARNING! WARNING! WARNING! WARNING! WARNING! WARNING! WARNING! **
+**                   WARNING! WARNING! WARNING! WARNING!                   **
+*****************************************************************************
+*****************************************************************************
+WARNIT
+      @in_alias = true
+      alias_method :initialize_fxml_warn, :initialize
+      alias_method :initialize, :initialize_orig
+      @in_alias = false
+    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.
@@ -177,20 +230,20 @@ class JRubyFX::Controller
       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]
@@ -204,7 +257,7 @@ class JRubyFX::Controller
   # === Examples
   #
   #   controller = MyFXController.load_fxml("Demo.fxml", stage)
-  #   
+  #
   # === Equivalent Java
   #   Parent root = FXMLLoader.load(getClass().getResource("Demo.fxml"));
   #   Scene scene = new Scene(root);
@@ -213,7 +266,7 @@ class JRubyFX::Controller
   #
   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] || [])
+    ctrl = self.new_java *settings[:initialize_ruby].to_a
     # save the stage so we can reference it if needed later
     ctrl.stage = stage
     # load the FXML file
@@ -226,25 +279,27 @@ class JRubyFX::Controller
     else
       Scene.new(parent, settings[:width] || -1, settings[:height] || -1, settings[:depth_buffer] || settings[:depthBuffer] || false)
     end
+    # instead of using the initializable interface, roll our own so we don't have to deal with java.
+    ctrl.initialize_fxml(*settings[:initialize_fxml].to_a)
     # 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 
+  # 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"));
   #