limelight 0.5.5-java → 0.6.14-java

data/{lib → ruby/lib}/limelight/paint_action.rb

@@ -1,5 +1,5 @@
-#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
-#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
 
 require 'limelight/pen'
 
@@ -8,20 +8,20 @@ module Limelight
   # A PaintAction is created by Prop.after_painting.
   #
   class PaintAction #:nodoc:
-    
+
     include UI::Painting::PaintAction
-    
+
     attr_reader :block
-    
+
     def initialize(&block)
       @block = block
     end
-    
+
     def invoke(graphics)
       pen = Pen.new(graphics)
       @block.call(pen)
     end
-    
+
   end
-  
+
 end

data/{lib → ruby/lib}/limelight/pen.rb

@@ -1,5 +1,5 @@
-#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
-#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
 
 module Limelight
 
@@ -7,10 +7,10 @@ module Limelight
   # from which the Pen was acquired.
   #
   # All points used by the Pen are relative to the bounds of the Prop.  The top left corner of the Prop is represented
-  # by the point (0, 0).  If a Prop has margin, border, or padding, the point (0, 0) may appear to be outside the Prop.  
+  # by the point (0, 0).  If a Prop has margin, border, or padding, the point (0, 0) may appear to be outside the Prop.
   #
   class Pen
-    
+
     attr_accessor :context
 
     # It is constructed with a context which is essentially a java.awt.Graphic2D object.  Defaults are set:
@@ -72,12 +72,12 @@ module Limelight
       @context.drawOval(x, y, width, height)
     end
 
-    # Fills an oval specified by the bounding rectangle.  See draw_oval.  
+    # Fills an oval specified by the bounding rectangle.  See draw_oval.
     #
     def fill_oval(x, y, width, height)
       @context.fillOval(x, y, width, height)
     end
-    
+
   end
-  
+
 end

data/ruby/lib/limelight/player.rb

@@ -0,0 +1,148 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+module Limelight
+  class Player < Module
+
+    include Java::limelight.model.api.Player
+
+    def initialize(player_name, player_path)
+      @name = player_name
+      @path = player_path
+      @__event_cache = {}
+    end
+
+    def cast(prop)
+      prop = prop.is_a?(Limelight::Prop) ? prop : prop.proxy
+      unless prop.is_a?(self)
+        prop.extend(self)
+      end
+    end
+
+    def path
+      @path
+    end
+    alias getPath path
+
+    def name
+      @name
+    end
+    alias getName name
+
+    def applyOptions(prop, options)
+      # nothing to do here because options are already applied to mixed in methods
+      options
+    end
+
+    def __add_action(type, action)
+      actions = @__event_cache[type]
+      if actions == nil
+        actions = @__event_cache[type] = []
+      end
+      actions << action
+    end
+
+    def extended(prop)
+      on_cast_actions = @__event_cache[:on_cast]
+      if on_cast_actions
+        on_cast_actions.each do |action|
+          prop.instance_exec(&action)
+        end
+      end
+
+      @__event_cache.each do |event, actions|
+        if actions && event != :on_cast
+          actions.each do |action|
+            prop.peer.event_handler.add(event, Proc.new { |e| prop.instance_exec(e, &action) })
+          end
+        end
+      end
+    end
+
+    def on_cast(& action)
+      __add_action(:on_cast, action)
+    end
+
+    def on_mouse_pressed(& action)
+      __add_action(Java::limelight.ui.events.panel.MousePressedEvent, action)
+    end
+
+    def on_mouse_released(& action)
+      __add_action(Java::limelight.ui.events.panel.MouseReleasedEvent, action)
+    end
+
+    def on_mouse_clicked(& action)
+      __add_action(Java::limelight.ui.events.panel.MouseClickedEvent, action)
+    end
+
+    def on_mouse_entered(& action)
+      __add_action(Java::limelight.ui.events.panel.MouseEnteredEvent, action)
+    end
+
+    def on_mouse_exited(& action)
+      __add_action(Java::limelight.ui.events.panel.MouseExitedEvent, action)
+    end
+
+    def on_mouse_moved(& action)
+      __add_action(Java::limelight.ui.events.panel.MouseMovedEvent, action)
+    end
+
+    def on_mouse_wheel(& action)
+      __add_action(Java::limelight.ui.events.panel.MouseWheelEvent, action)
+    end
+
+    def on_mouse_dragged(& action)
+      __add_action(Java::limelight.ui.events.panel.MouseDraggedEvent, action)
+    end
+
+    def on_key_pressed(& action)
+      __add_action(Java::limelight.ui.events.panel.KeyPressedEvent, action)
+    end
+
+    def on_key_released(& action)
+      __add_action(Java::limelight.ui.events.panel.KeyReleasedEvent, action)
+    end
+
+    def on_char_typed(& action)
+      __add_action(Java::limelight.ui.events.panel.CharTypedEvent, action)
+    end
+
+    def on_focus_gained(& action)
+      __add_action(Java::limelight.ui.events.panel.FocusGainedEvent, action)
+    end
+
+    def on_focus_lost(& action)
+      __add_action(Java::limelight.ui.events.panel.FocusLostEvent, action)
+    end
+
+    def on_button_pushed(& action)
+      __add_action(Java::limelight.ui.events.panel.ButtonPushedEvent, action)
+    end
+
+    def on_value_changed(& action)
+      __add_action(Java::limelight.ui.events.panel.ValueChangedEvent, action)
+    end
+
+    def on_scene_opened(& action)
+      __add_action(Java::limelight.ui.events.panel.SceneOpenedEvent, action)
+    end
+
+    def on_illuminated(& action)
+      __add_action(Java::limelight.ui.events.panel.IlluminatedEvent, action)
+    end
+
+    def prop_reader(*symbols)
+      symbols.each do |sym|
+        module_eval("def #{sym}; return scene.find('#{sym}'); end")
+      end
+    end
+
+    def backstage_reader(*symbols)
+      symbols.each do |sym|
+        name = Java::limelight.util.StringUtil.spearCase(sym.to_s)
+        module_eval("def #{sym}; return backstage['#{name}']; end")
+      end
+    end
+
+  end
+end

data/ruby/lib/limelight/player_recruiter.rb

@@ -0,0 +1,54 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+require 'limelight/player'
+require 'limelight/builtin/players'
+
+module Limelight
+
+  # The PlayerRecruiter is responsible for finding Players for Props within a Production.
+  # Each scene has a unique instance of a PlayerRecruiter
+  #
+  # Users of Limelight need not be concerned with this class.
+  #
+  class PlayerRecruiter
+
+    attr_reader :cast
+
+    def initialize()
+      @cast = Module.new
+      @fs = Java::limelight.Context.fs
+    end
+
+    def can_recruit?(player_name, players_path)
+      @cast.const_defined?(player_name.camelized) || @fs.exists(player_filename(player_name, players_path))
+    end
+
+    alias :canRecruit :can_recruit?
+
+    def recruit_player(player_name, players_path)
+      module_name = player_name.camelized
+      if @cast.const_defined?(module_name)
+        @cast.const_get(module_name)
+      else
+        player_filename = player_filename(player_name, players_path)
+        src = @fs.read_text_file(player_filename)
+
+        player = Player.new(player_name, player_filename)
+        player.module_eval(src, player_filename)
+        @cast.const_set(module_name, player)
+        player
+      end
+    end
+
+    alias :recruitPlayer :recruit_player
+
+    private ###############################################
+
+    def player_filename(player_name, players_path)
+      "#{@fs.join(players_path, player_name.underscored)}.rb"
+    end
+
+  end
+
+end

data/ruby/lib/limelight/production.rb

@@ -0,0 +1,257 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+require 'limelight/limelight_exception'
+require 'limelight/dsl/styles_builder'
+require 'limelight/theater'
+require 'limelight/dsl/stage_builder'
+require 'limelight/dsl/prop_builder'
+require 'limelight/dsl/styles_builder'
+require 'limelight/util/hashes'
+require 'limelight/scene'
+require 'drb'
+
+
+module Limelight
+
+  # The root object of Limelight Production.  Every Prop in a production has access to its Production object.
+  # Therefore it is typical to store reasources in the Production.
+  #
+  # Productions are configured, and attributes are added, by the ProductionBuilder.
+  #
+  class Production
+
+    include Java::limelight.model.api.ProductionProxy
+
+    attr_reader :peer
+    attr_accessor :theater
+
+    alias :getTheater :theater
+    alias :getPeer :peer
+
+    # Users typically need not create Production objects.
+    #
+    def initialize(production)
+      @peer = production
+      @theater = Theater.new(self, @peer.theater)
+
+      @peer.proxy = self
+      @fs = Java::limelight.Context.fs
+    end
+
+    # returns the productions "backstage" storage. (A map of map to store stuff)
+    #
+    def backstage
+      if @backstage == nil
+        value = @peer.backstage
+        @backstage = Util::Hashes.for_ruby(value)
+      end
+      @backstage
+    end
+
+    # returns true if the production has been opened, and not yet closed.
+    #
+    def open?
+      @peer.open?
+    end
+
+    # Returns the name of the Production
+    #
+    def name
+      @peer.name
+    end
+
+    # Sets the name of the Production.  The name must be unique amongst all Productions in memory.
+    #
+    def name=(value)
+      @peer.name = value
+    end
+
+    # Return the path to the root directory of the production
+    #
+    def path
+      @peer.path
+    end
+
+    # Returns the path to the production's production.rb file
+    #
+    def production_file
+      @fs.path_to(path, "production.rb")
+    end
+
+    # Returns the path to the production's stages file
+    #
+    def stages_file
+      @fs.path_to(path, "stages.rb")
+    end
+
+    # Returns the path to the production's styles file
+    #
+    def styles_file
+      @fs.path_to(path, "styles.rb")
+    end
+
+    # Returns the path to the production's gems directory
+    #
+    def gems_directory
+      @fs.path_to(path, "__resources/gems/gems")
+    end
+
+    # Returns the path to the productions gems root
+    #
+    def gems_root
+      @fs.path_to(path, "__resources/gems")
+    end
+
+    # Returns the path to the named Scene's directory within the Production
+    #
+    def scene_directory(name)
+      name == nil ? path : @fs.path_to(path, name)
+    end
+
+    # Returns true if the production allows itself to be closed.  The system will call this methods when
+    # it wishes to close the production, perhaps when the user quits the application.  By default the production
+    # will always return true.
+    #
+    def allow_close?
+      @peer.allow_close?
+    end
+
+    # Specifies whether this production will allow itself to be closed.  It should be noted that permanently setting
+    # this to false could keep the entire Limelight runtime from shutting down.
+    #
+    def allow_close=(value)
+      @peer.allow_close = value
+    end
+
+    # Specifies the minimum required version of Limelight that should be used to open this production.
+    # Defaults to zero, meaning any version of Limelight may open the production.
+    #
+    def minimum_limelight_version=(value)
+      @peer.minimum_limelight_version = value
+    end
+
+    # Closes the production. If there are no more productions open, the Limelight runtime will shutdown.
+    # The production will actually delegate to it's producer and the producer will close the production down.
+    #
+    def close
+      @peer.close
+    end
+
+    # Publish this production using DRb on the specified port.  The production will delegate to its producer to
+    # actually do the publishing.
+    #
+    def publish_on_drb(port)
+      @producer.publish_production_on_drb(port)
+    end
+
+    def on_production_created(&action)
+      @peer.event_handler.add(Java::limelight.model.events.ProductionCreatedEvent, action)
+    end
+
+    def on_production_loaded(&action)
+      @peer.event_handler.add(Java::limelight.model.events.ProductionLoadedEvent, action)
+    end
+
+    def on_production_opened(&action)
+      @peer.event_handler.add(Java::limelight.model.events.ProductionOpenedEvent, action)
+    end
+
+    def on_production_closing(&action)
+      @peer.event_handler.add(Java::limelight.model.events.ProductionClosingEvent, action)
+    end
+
+    def on_production_closed(&action)
+      @peer.event_handler.add(Java::limelight.model.events.ProductionClosedEvent, action)
+    end
+
+    def backstage_pass(name)
+      instance_eval "def #{name}=(value); backstage[:#{name}] = value; end;"
+      instance_eval "def #{name}; backstage[:#{name}]; end;"
+    end
+
+    def callMethod(name, java_obj_array) #:nodoc:
+      args = []
+      java_obj_array.length.times { |i| args << java_obj_array[i] }
+      send(name.to_sym, * args)
+    end
+
+    def open_scene(scene_path, options={})
+      stage_name = options[:stage]
+      if(stage_name)
+        scene_peer = @peer.open_scene(scene_path, stage_name, Util::Hashes.for_java(options))
+      else
+        scene_peer = @peer.open_scene(scene_path, Util::Hashes.for_java(options))
+      end
+      scene_peer.proxy
+    end
+
+    def illuminate
+      path = production_file
+      return unless @fs.exists?(path)
+      content = @fs.read_text_file(path)
+      path = path[5..-1] if path[0...5] == "file:"
+      self.instance_eval(content, path)
+    end
+
+    def load_libraries
+      # use bundler here
+    end
+
+    alias :loadLibraries :load_libraries
+
+    def load_stages
+      return unless @fs.exists?(stages_file)
+      content = @fs.read_text_file(stages_file)
+      prod = self
+      Limelight.build_stages(theater) do
+        begin
+          eval content
+        rescue Exception => e
+          puts e.backtrace
+          raise DSL::BuildException.new(prod.stages_file, content, e)
+        end
+      end
+    end
+
+    alias :loadStages :load_stages
+
+    def load_scene(scene_path, options={})
+      options = Util::Hashes.for_ruby(options)
+      instance_variables = options.delete(:instance_variables)
+      log.debug "production.rb - scene options: #{options.inspect}"
+      scene = Scene.new(options)
+      scene.production = self
+      if @fs.exists?(scene.props_file)
+        log.debug "production.rb - loading props: #{scene.props_file}"
+        content = @fs.read_text_file(scene.props_file)
+        options[:root_path] = self.path
+        Limelight.build_props(scene, options.merge(:instance_variables => instance_variables)) do
+          begin
+            eval content
+          rescue Exception => e
+            raise DSL::BuildException.new(scene.props_file, content, e)
+          end
+        end
+      else
+        log.debug "production.rb - props file doesn't exist': #{scene.props_file}"
+      end
+      scene
+    end
+
+    alias :loadScene :load_scene
+
+    def load_styles(source, extendable_styles)
+      result = {}
+      styles_path = @fs.join(source.path, "styles.rb")
+      if @fs.exists?(styles_path)
+        Limelight.build_styles_from_file(styles_path, :styles => result, :extendable_styles => extendable_styles)
+      end
+      result
+    end
+
+    alias :loadStyles :load_styles
+
+  end
+
+end