jrubyfx 0.9.1-java

data/lib/jrubyfx/fxml_module.rb

@@ -0,0 +1,98 @@
+=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'
+require 'jrubyfx/utils/common_utils'
+
+# This module contains useful methods for defining JavaFX code. Include it in your
+# class to use it, and the JRubyFX::FXImports. JRubyFX::Application and JRubyFX::Controller already include it.
+module JRubyFX
+  include JRubyFX::FXImports
+  include JRubyFX::Utils::CommonUtils
+
+  ##
+  # call-seq:
+  #   with(obj, hash) => obj
+  #   with(obj) { block } => obj
+  #   with(obj, hash) { block }=> obj
+  #   
+  # Set properties (e.g. setters) on the passed in object plus also invoke
+  # any block passed against this object.
+  # === Examples
+  #
+  #   with(grid, vgap: 2, hgap: 2) do
+  #     set_pref_size(500, 400)
+  #     children << location << go << view
+  #   end
+  #
+  def with(obj, properties = {}, &block)
+    populate_properties(obj, properties)
+
+    if block_given?
+      # cache the proxy - http://wiki.jruby.org/Persistence
+      obj.class.__persistent__ = true if obj.class.ancestors.include? JavaProxy
+      obj.extend(JRubyFX)
+      obj.instance_eval(&block)
+    end
+    
+    obj
+  end
+
+  ##
+  # call-seq:
+  #   run_later { block }
+  # 
+  # Convenience method so anything can safely schedule to run on JavaFX
+  # main thread.
+  def run_later(&block)
+    Platform.run_later &block
+  end
+
+  ##
+  # call-seq:
+  #   build(class) => obj
+  #   build(class, hash) => obj
+  #   build(class) { block } => obj
+  #   build(class, hash) { block } => obj
+  #   
+  # Create "build" a new JavaFX instance with the provided class and
+  # set properties (e.g. setters) on that new instance plus also invoke
+  # any block passed against this new instance.  This also can build a proc
+  # or lambda form in which case the return value of the block will be what 
+  # is used to set the additional properties on.
+  # === Examples
+  #
+  #   grid = build(GridPane, vgap: 2, hgap: 2) do
+  #     set_pref_size(500, 400)
+  #     children << location << go << view
+  #   end
+  #
+  #  build(proc { Foo.new }, vgap: 2, hgap: 2)
+  #
+  def build(klass, *args, &block)
+    args, properties = split_args_from_properties(*args)
+
+    obj = if klass.kind_of? Proc
+      klass.call(*args)
+    else
+      klass.new(*attempt_conversion(klass, :new, *args))
+    end
+
+    with(obj, properties, &block)
+  end
+end
+

data/lib/jrubyfx/java_fx_impl.rb

@@ -0,0 +1,139 @@
+=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
+#:nodoc: all
+require 'jrubyfx'
+
+# Due to certain bugs in JRuby 1.7 (namely some newInstance mapping bugs), we
+# are forced to re-create the Launcher if we want a pure ruby wrapper
+# I can't wait to delete this. The _ONLY_ code that should use this is
+# JRubyFX::Application.launch. Do _NOT_ use this code anywhere else.
+module JavaFXImpl #:nodoc: all
+  java_import 'com.sun.javafx.application.PlatformImpl'
+  java_import 'javafx.stage.Stage'
+  
+  #JRuby, you make me have to create real classes!
+  class FinisherInterface
+    include PlatformImpl::FinishListener
+    
+    def initialize(&block)
+      @exitBlock = block
+    end
+    
+    def idle(someBoolean)
+      @exitBlock.call
+    end
+    
+    def exitCalled()
+      @exitBlock.call
+    end
+  end
+  
+  class Launcher
+    java_import 'java.util.concurrent.atomic.AtomicBoolean'
+    java_import 'java.util.concurrent.CountDownLatch'
+    java_import 'java.lang.IllegalStateException'
+    
+    @@launchCalled = AtomicBoolean.new(false) # Atomic boolean go boom on bikini
+    
+    def self.launch_app(classObj, args=nil)
+      #prevent multiple!
+      if @@launchCalled.getAndSet(true)
+        throw IllegalStateException.new "Application launch must not be called more than once"
+      end
+      
+      begin
+        #create a java thread, and run the real worker, and wait till it exits
+        count_down_latch = CountDownLatch.new(1)
+        thread = Java.java.lang.Thread.new do
+          begin
+            launch_app_from_thread(classObj)
+          rescue => ex
+            puts "Exception starting app:"
+            p ex
+            p ex.backtrace
+          end
+          count_down_latch.countDown #always count down
+        end
+        thread.name = "JavaFX-Launcher"
+        thread.start
+        count_down_latch.await
+      rescue => ex
+        puts "Exception launching JavaFX-Launcher thread:"
+        p ex
+        puts ex.backtrace
+      end
+    end
+    
+    def self.launch_app_from_thread(classO)
+      #platformImpl startup?
+      finished_latch = CountDownLatch.new(1)
+      PlatformImpl.startup do
+        finished_latch.countDown
+      end
+      finished_latch.await
+      
+      begin
+        launch_app_after_platform(classO) #try to launch the app
+      rescue => ex
+        puts "Error running Application:"
+        p ex
+        puts ex.backtrace
+      end
+      
+      #kill the toolkit and exit
+      PlatformImpl.tkExit
+    end
+    
+    def self.launch_app_after_platform(classO)
+      #listeners - for the end
+      finished_latch = CountDownLatch.new(1)
+      
+      # register for shutdown
+      PlatformImpl.addListener(FinisherInterface.new {
+          # this is called when the stage exits
+          finished_latch.countDown
+        })
+    
+      app = classO.new
+      # do we need to register the params if there are none? - apparently not
+      app.init()
+      
+      error = false
+      #RUN! and hope it works!
+      PlatformImpl.runAndWait do
+        begin
+          stage = Stage.new
+          stage.impl_setPrimary(true)
+          app.start(stage)
+          # no countDown here because its up top... yes I know
+        rescue => ex
+          puts "Exception running Application:"
+          p ex
+          puts ex.backtrace
+          error = true
+          finished_latch.countDown # but if we fail, we need to unlatch it
+        end
+      end
+        
+      #wait for stage exit
+      finished_latch.await
+      
+      # call stop on the interface
+      app.stop() unless error
+    end
+  end
+end

data/lib/jrubyfx/jfx_imports.rb

@@ -0,0 +1,107 @@
+=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'
+
+# Update load path to include the JavaFX runtime and fail nicely if we can't find it
+begin
+  if ENV['JFX_DIR']
+    $LOAD_PATH << ENV['JFX_DIR']
+  else #should we check for 1.7 vs 1.8? oh well, adding extra paths won't hurt anybody (maybe performance loading)
+    jfx_path = ENV_JAVA["sun.boot.library.path"]
+    $LOAD_PATH << if jfx_path.include? ":\\" and !jfx_path.include? "/" # can be tricked, but should work fine
+      #windows
+      jfx_path.gsub(/\\bin[\\]*$/i, "\\lib")
+    else
+      # *nix
+      jfx_path.gsub(/[\/\\][amdix345678_]+$/, "") # strip i386 or amd64 (including variants). TODO: ARM
+    end
+  end
+  require 'jfxrt.jar'
+rescue  LoadError
+  puts "JavaFX runtime not found.  Please install Java 7u6 or newer or set environment variable JFX_DIR to the folder that contains jfxrt.jar "
+  puts "If you have Java 7u6 or later, this is a bug. Please report to the issue tracker on github. Include your OS version, 32/64bit, and architecture (x86, ARM, PPC, etc)"
+  exit -1
+end
+
+module JRubyFX
+  # If you need JavaFX, just include this module. Its sole purpose in life is to
+  # import all JavaFX stuff, plus a few useful Java classes (like Void)
+  module FXImports
+  
+    # If something is missing, just java_import it in your code.
+    # And then ask us to put it in this list
+  
+    ## 
+    # This is the list of all classes in JavaFX that most apps should care about.
+    # It is a hashmaps with the leafs as arrays. Where a leaf also contains more 
+    # packages, the hashmap key is "" (empty string). You can utilize this constant
+    # to save yourself some typing when adding code for most/all of the JavaFX
+    # classes by using either `Hash.flat_tree_inject` from jrubyfx/utils.rb or
+    # writing your own traversal function
+    #
+    JFX_CLASS_HIERARCHY = { :javafx => {
+        :animation => %w[Animation AnimationTimer FadeTransition FillTransition Interpolator KeyFrame KeyValue ParallelTransition PathTransition 
+        PauseTransition RotateTransition ScaleTransition SequentialTransition StrokeTransition Timeline Transition TranslateTransition],
+        :application => ['Platform'],
+        :beans => {
+          :property => ['SimpleDoubleProperty'],
+          #TODO: import more
+          :value => ['ChangeListener']  
+        },
+        :collections => ['FXCollections'],
+        :event => %w[Event ActionEvent EventHandler],
+        :fxml => ['Initializable', 'LoadException'],
+        :geometry => %w[HorizontalDirection HPos Insets Orientation Pos Side VerticalDirection VPos], 
+        :scene => {
+          '' => %w[Group Node Parent Scene],
+          :canvas => ['Canvas'],
+          :chart => %w[Axis CategoryAxis Chart LineChart NumberAxis XYChart],
+          # TODO: import more of these
+          :control => %w[Accordion Button Cell CheckBox CheckBoxTreeItem CheckMenuItem ChoiceBox ColorPicker ComboBox ContextMenu Hyperlink 
+          Label ListCell ListView Menu MenuBar MenuButton MenuItem Pagination PasswordField PopupControl ProgressBar ProgressIndicator RadioButton 
+          RadioMenuItem ScrollBar ScrollPane Separator SeparatorMenuItem Slider SplitMenuButton SplitPane Tab TableView TableColumn TabPane TextArea 
+          TextField TitledPane ToggleButton ToggleGroup ToolBar Tooltip TreeItem TreeView ContentDisplay OverrunStyle SelectionMode],
+          :effect => %w[Blend BlendMode Bloom BlurType BoxBlur ColorAdjust ColorInput DisplacementMap DropShadow GaussianBlur Glow ImageInput 
+          InnerShadow Lighting MotionBlur PerspectiveTransform Reflection SepiaTone Shadow],
+          :image => %w[Image ImageView PixelReader PixelWriter],
+          :input => %w[Clipboard ContextMenuEvent DragEvent GestureEvent InputEvent InputMethodEvent KeyEvent 
+          Mnemonic MouseDragEvent MouseEvent RotateEvent ScrollEvent SwipeEvent TouchEvent ZoomEvent],
+          :layout => %w[AnchorPane BorderPane ColumnConstraints FlowPane GridPane HBox Pane Priority RowConstraints StackPane TilePane VBox],
+          :media => %w[Media MediaPlayer MediaView],
+          # TODO: fill this out
+          :paint => %w[Color CycleMethod ImagePattern LinearGradient Paint RadialGradient Stop],
+          :shape => %w[Arc ArcTo ArcType Circle ClosePath CubicCurve CubicCurveTo Ellipse FillRule HLineTo Line LineTo MoveTo Path PathElement 
+          Polygon Polyline QuadCurve QuadCurveTo Rectangle Shape StrokeLineCap StrokeLineJoin StrokeType SVGPath VLineTo],
+          :text => %w[Font FontPosture FontSmoothingType FontWeight Text TextAlignment TextBoundsType],
+          :transform => %w[Affine Rotate Scale Shear Translate],
+          :web => ['WebView', 'HTMLEditor']
+        },
+        :stage => %w[DirectoryChooser FileChooser Modality Popup PopupWindow Screen Stage StageStyle Window WindowEvent],
+        :util => ['Duration']
+      }
+    }
+  
+    # Imports all the listed JavaFX classes
+    java_import *(JFX_CLASS_HIERARCHY.flat_tree_inject do |res, name, values|
+        name = "#{name.to_s}."
+        name = "" if name == "."
+        res.concat(values.map{|i| "#{name}#{i}"})
+      end)
+    java_import 'java.lang.Void'
+  end
+end

data/lib/jrubyfx/utils.rb

@@ -0,0 +1,56 @@
+=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
+
+# This feels kinda like a hack. If anyone has a better idea, please let me know
+
+# Standard ruby Hash class extensions
+class Hash
+
+  # call-seq:
+  #   flat_tree_inject() {|results, key, value| block} => array
+  #   flat_tree_inject(Hash) {|results, key, value| block} => hash
+  #   
+  # Execute given block against all nodes in the hash tree, returning `results`.
+  # Similar to Hash#each except goes into all sub-Hashes
+  #
+  def flat_tree_inject(klass=Array,&block)
+    self.inject(klass.new) do |lres, pair|
+      if pair[1].is_a? Hash
+        pair[1] = pair[1].flat_tree_inject(klass, &block)
+      end
+      block.call(lres, *pair)
+    end
+  end
+end
+
+# Standard ruby String class extensions
+class String
+  # call-seq:
+  #   snake_case() => string
+  #   
+  # Converts a CamelCaseString to a snake_case_string
+  # 
+  #   "JavaFX".snake_case #=> "java_fx"
+  #
+  def snake_case
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/jrubyfx/utils/__ignore_java_stupid_rdoc.rb

@@ -0,0 +1,24 @@
+module Java #:nodoc: all
+  module javafx
+    module animation
+    end
+    module beans
+      module value
+      end
+    end
+    module scene
+      module chart
+      end
+      module control
+      end
+      module layout
+      end
+      module paint
+      end
+      module shape
+      end
+    end
+    module stage
+    end
+  end
+end

data/lib/jrubyfx/utils/common_converters.rb

@@ -0,0 +1,140 @@
+=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
+module JRubyFX
+  module Utils
+    # Contains conversion utilities to ease Ruby => JavaFX coding
+    module CommonConverters
+      java_import 'javafx.scene.paint.Color'
+
+      # argument converter method name suffix
+      ARG_CONVERTER_SUFFIX = '_arg_converter'
+      
+      # map of snake_cased colors to JavaFX Colors
+      NAME_TO_COLORS = {
+        'darkyellow' => Color.web('0xc0c000'),
+        'lightmagenta' => Color.web('0xffc0ff'),
+        'lightred' => Color.web('0xffc0c0'),
+      }.merge(Color.java_class.fields.inject({}) {|final, field|
+          final[field.name.downcase] = field.value(nil) # TODO: what is nil supposed to be?
+          final
+        })
+
+      ##
+      # Generate a converter for a map of supplied values.
+      def map_converter(map)
+        lambda do |value|
+          map.key?(value) ? map[value] : value
+        end
+      end
+      
+      ##
+      # Generate a converter for an enum of the given class
+      def enum_converter(enum_class)
+        lambda do |value|
+          (JRubyFX::Utils::CommonConverters.map_enums(enum_class)[value.to_s] || value)
+        end
+      end
+      
+      def animation_converter_for(*prop_names)
+        prop_names.each do |prop_name|
+          self.__send__(:define_method, prop_name.to_s + "=") do |hash|
+            method("from_#{prop_name}=").call hash.keys[0]
+            method("to_#{prop_name}=").call hash.values[0]
+          end
+        end
+      end
+
+      ##
+      # Allows you to specify you want a converter method created for the
+      # specified method where each listed converter corresponds to each
+      # argument for that method.  You can have n-arity lists for all
+      # matching Java overloads.  This mechanism means you may not always
+      # be able to specify all coercions you want.
+      # === Examples
+      #
+      #    coverter_for :new, [:none, :color]
+      #
+      # This method will define a method on the current class called
+      # *new_arg_converter* which will perform no argument coercion on
+      # the first argument and a color coercion on the second argument.
+      #
+      def converter_for(method_name, *converters)
+        sheep = lambda do |direct, this, *values|
+          converter = converters.find { |e| e.length == values.length }
+
+          # FIXME: Better error reporting on many things which can fail
+          i = 0
+          values = values.inject([]) do |s, value|
+            conv = converter[i]
+            if conv.kind_of? Proc
+              s << conv.call(value)
+            else
+              s << CONVERTERS[converter[i]].call(value)
+            end
+            i += 1
+            s
+          end
+          if direct
+            return this.method("set_" + method_name.to_s).call(*values)
+          else
+            return values
+          end
+        end
+        # define a setter for normal usage
+        unless method_name == :new
+          self.__send__(:define_method, method_name.to_s + "=") do |*values|
+            sheep.call(true, self, *values)
+          end
+        end
+        # define a build/with usage
+        self.__send__(:define_method, method_name.to_s + ARG_CONVERTER_SUFFIX) do |*values|
+          sheep.call(false, self, *values)
+        end
+      end
+
+      # Map of different kinds of known converters
+      CONVERTERS = {
+        :none => lambda { |value|
+          value
+        },
+        :color => lambda { |value|
+          new_value = NAME_TO_COLORS[value.to_s.gsub(/_/, "")]
+          new_value ? new_value : value
+        },
+      }
+      
+      # Store enum mapping overrides
+      @overrides = {}
+      
+      # sets the given overrides for the given class/enum
+      def self.set_overrides_for(enum_class,ovr)
+        @overrides[enum_class] = ovr
+      end
+      
+      # Given a class, returns a hash of lowercase strings mapped to Java Enums
+      def self.map_enums(enum_class)
+        res = enum_class.java_class.enum_constants.inject({}) {|res, i| res[i.to_s.downcase] = i; res }
+        (@overrides[enum_class]||[]).each do |oldk, newks|
+          [newks].flatten.each do |newk|
+            res[newk.to_s] = res[oldk.to_s]
+          end
+        end
+        res
+      end
+    end
+  end
+end