Module: JRubyFX::Controller

Includes:
DSL
Defined in:
lib/jrubyfx/controller.rb

Overview

Inherit from this class for FXML controllers

Defined Under Namespace

Modules: ClassMethods

Constant Summary collapse

DEFAULT_SETTINGS = 
{
  width: -1,
  height: -1,
  fill: :white,
  depth_buffer: false,
  root_dir: nil,
  initialized: nil
}

Constants included from DSL

DSL::NAME_TO_CLASSES

Constants included from JRubyFX

VERSION

Constants included from FXImports

FXImports::JFX_CLASS_HIERARCHY

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from DSL

compile_dsl, load_dsl, #logical_lookup, #method_missing, #self_test_lookup, write_color_method_converter, write_enum_converter, write_enum_method_converter

Methods included from JRubyFX

#build, #run_later, #with

Methods included from Utils::CommonUtils

#attempt_conversion, #populate_properties, #split_args_from_properties

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class JRubyFX::DSL

Instance Attribute Details

#scene=(value) ⇒ Object (writeonly)

Controllers usually need access to the stage.



46
47
48
 
# File 'lib/jrubyfx/controller.rb', line 46

def scene=(value)
  @scene = value
end

#stage=(value) ⇒ Object (writeonly)

Controllers usually need access to the stage.



46
47
48
 
# File 'lib/jrubyfx/controller.rb', line 46

def stage=(value)
  @stage = value
end

Class Method Details

.get_fxml_loader(filename, controller = nil, root_dir = nil) ⇒ Object

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"));



291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
 
# File 'lib/jrubyfx/controller.rb', line 291

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 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
  # we must set this here for JFX to call our events
  fx.controller = controller
  fx
end

.included(base) ⇒ Object 



48
49
50
51
52
53
 
# File 'lib/jrubyfx/controller.rb', line 48

def self.included(base)
  base.extend(ClassMethods)
  base.extend(JRubyFX::FXMLClassUtils)
  # register ourselves as a control. overridable with custom_fxml_control
  register_type base if base.is_a? Class
end

.load_fxml_only(filename, stage, settings = {}) ⇒ Object

Loads a controller-less file



252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/jrubyfx/controller.rb', line 252

def self.load_fxml_only(filename, stage, settings={})
  # Inherit from default settings
  settings = DEFAULT_SETTINGS.merge({root_dir: fxml_root,
      filename: filename}).merge settings

  # load the FXML file
  root = Controller.get_fxml_loader(settings[:filename], nil, settings[:root_dir]).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

Instance Method Details

#css(css_selector) ⇒ Object

return an array of matched nodes



247
248
249
 
# File 'lib/jrubyfx/controller.rb', line 247

def css(css_selector)
  @scene.get_root.lookup_all(css_selector).to_a
end

#find(css_selector) ⇒ Object

return first matched node or nil



235
236
237
 
# File 'lib/jrubyfx/controller.rb', line 235

def find(css_selector)
  @scene.lookup(css_selector)
end

#find!(css_selector) ⇒ Object

Return first matched node or throw exception



240
241
242
243
244
 
# File 'lib/jrubyfx/controller.rb', line 240

def find!(css_selector)
  res = find(css_selector)
  raise "Selector(#{css_selector}) returned no results!" unless res
  res
end

#finish_initialization(*args, &block) ⇒ Object 



215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/jrubyfx/controller.rb', line 215

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

#initialize_controller(options = {}, *args, &block) ⇒ Object

Initialize all controllers



198
199
200
201
202
203
204
205
206
207
 
# File 'lib/jrubyfx/controller.rb', line 198

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

#java_ctor(ctor, initialize_arguments) ⇒ Object

default java ctor, override for arguments



193
194
195
 
# File 'lib/jrubyfx/controller.rb', line 193

def java_ctor(ctor, initialize_arguments)
  ctor.call
end

#load_fxml(filename, root_dir = nil) ⇒ Object 



209
210
211
212
213
 
# File 'lib/jrubyfx/controller.rb', line 209

def load_fxml(filename, root_dir=nil)
  fx = Controller.get_fxml_loader(filename, self, root_dir)
  fx.root = self
  fx.load
end