limelight 0.5.5-java → 0.6.14-java

data/lib/limelight/producer.rb

@@ -1,233 +0,0 @@
-#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
-#- Limelight and all included source files are distributed under terms of the GNU LGPL.
-
-require 'limelight/file_loader'
-require 'limelight/dsl/prop_builder'
-require 'limelight/dsl/styles_builder'
-require 'limelight/dsl/stage_builder'
-require 'limelight/casting_director'
-require 'limelight/stage'
-require 'limelight/dsl/build_exception'
-require 'limelight/theater'
-require 'limelight/production'
-require 'limelight/gems'
-require 'limelight/util/downloader'
-require 'limelight/version'
-require 'drb'
-
-module Limelight
-
-  # A Producer has the hefty responsibility of producing Productions.  Given a directory, it will load the neccessary
-  # files and create all the neccessary objects to bring a Production to life.    A producer will produce only
-  # one production.
-  #
-  # For directory structures, see Limelight::Main
-  #
-  class Producer
-
-    class << self
-      # Creates a new Producer and has it open a Production by specified name.
-      #
-      def open(production_name, options={})
-        producer = new(production_name)
-        begin
-          producer.open(options)
-        rescue Exception => e
-          puts e
-          puts e.backtrace
-        end
-      end
-
-      # Returns a hash of all the built-in Limglight Styles
-      #
-      def builtin_styles
-        unless @builtin_styles
-          builtin_styles_file = File.join($LIMELIGHT_LIB, "limelight", "builtin", "styles.rb")
-          @builtin_styles = Limelight.build_styles_from_file(builtin_styles_file)
-        end
-        return @builtin_styles
-      end
-    end
-
-    attr_reader :theater, :production, :drb_service
-    attr_writer :builtin_styles
-
-    # A Production name, or root directory, must be provided. If not Theater is provided, one will be created.
-    # You may also provide an existing Production for which this Producer will interact.
-    #
-    def initialize(root_path, theater=nil, production=nil)
-      if (root_path[-4..-1] == ".lll")
-        url = IO.read(root_path).strip
-        root_path = Util::Downloader.download(url)
-      end
-      if (root_path[-4..-1] == ".llp")
-        root_path = unpack_production(root_path)
-      end
-      @production = production || Production.new(root_path)
-      @theater = theater.nil? ? Theater.new(@production) : theater
-      establish_production
-    end
-
-    # Returns true if the production's minimum_limelight_version is compatible with the current version.
-    #
-    def version_compatible?
-      current_version = Limelight::Util::Version.new(Limelight::VERSION::STRING)
-      required_version = Limelight::Util::Version.new(@production.minimum_limelight_version)
-      return required_version.is_less_than_or_equal(current_version)
-    end
-
-    # Returns the CastingDirector for this Production.
-    #
-    def casting_director
-      @casting_director = CastingDirector.new(@production.root) if not @casting_director
-      return @casting_director
-    end
-
-    # Loads the Production without opening it.  The Production will be created into memory with all it's stages
-    #
-    def load(options = {})
-      Gems.install_gems_in_production(@production)
-      Kernel.load(@production.init_file) if ( !options[:ignore_init] &&  File.exists?(@production.init_file) )
-      load_stages if File.exists?(@production.stages_file)
-    end
-
-    # Returns true if the production is compatible with the current version of Limelight or if the user proceeds
-    # despite the incompatible warning.
-    #
-    def can_proceed_with_compatibility?
-      return true if version_compatible?
-      return true if Context.instance.studio.utilities_production.should_proceed_with_incompatible_version(@production.name, @production.minimum_limelight_version)
-      return false
-    end
-
-    # Opens the Production.
-    #
-    def open(options = {})
-      @production.production_opening
-      load
-      @production.production_loaded
-      if @theater.has_stages?
-        @theater.stages.each do |stage|
-          open_scene(stage.default_scene.to_s, stage) if stage.default_scene
-        end
-      elsif @production.default_scene
-        open_scene(@production.default_scene, @theater.default_stage)
-      end
-      @casting_director = nil
-      @production.production_opened
-    end
-
-    # Opens the specified Scene onto the Spcified Stage.
-    #
-    def open_scene(name, stage, options={})
-      path = @production.scene_directory(name)
-      scene_name = File.basename(path)
-      scene = load_props(options.merge(:production => @production, :casting_director => casting_director, :path => path, :name => scene_name))
-      styles = load_styles(scene)
-      scene.styles = styles
-      stage.open(scene)
-      return scene
-    end
-
-    # Loads the 'stages.rb' file and configures all the Stages in the Production.
-    #
-    def load_stages
-      stages_file = @production.stages_file
-      content = IO.read(stages_file)
-      stages = Limelight.build_stages(@theater) do
-        begin
-          eval content
-        rescue Exception => e
-          raise DSL::BuildException.new(stages_file, content, e)
-        end
-      end
-      return stages
-    end
-
-    # Loads of the 'props.rb' file for a particular Scene and creates all the Prop objects and Scene.
-    #
-    def load_props(options = {})
-      scene = Scene.new(options)
-      if File.exists?(scene.props_file)
-        content = IO.read(scene.props_file)
-        options[:build_loader] = @production.root
-        return Limelight.build_props(scene, options) do
-          begin
-            eval content
-          rescue Exception => e
-            raise DSL::BuildException.new(scene.props_file, content, e)
-          end
-        end
-      else
-        return scene
-      end
-    end
-
-    # Loads the specified 'styles.rb' file and created a Hash of Styles.
-    #
-    def load_styles(context)
-      extendable_styles = Producer.builtin_styles.merge(@production.root_styles)
-      return extendable_styles.dup if not File.exists?(context.styles_file)
-      new_styles = Limelight.build_styles_from_file(context.styles_file, extendable_styles)
-      return extendable_styles.merge(new_styles)
-    end
-
-    # Closes the specified production.  The producer will trigger the hook, production_closing and production_closed,
-    # to keep the production aware of it's status.  The Studio will also be informed of the closure.  If no
-    # production remain opened, then the Limelight runtine will exit.
-    #
-    def close
-      return if @production.closed?
-      @production.closed = true
-      return Thread.new do
-        begin
-          Thread.pass
-          @production.production_closing
-          @production.theater.close
-          @production.production_closed
-          @drb_service.stop_service if @drb_service
-          Context.instance.studio.production_closed(@production)
-        rescue StandardError => e
-          puts e
-          puts e.backtrace
-        end
-      end
-    end
-
-    # Publish the production, using DRb, on the specified port.  This is useful for testing or remotely controling
-    # your production.  Publilshing productions on DRb is typically accomplished by using the --drb_port option
-    # of the open command. eg.
-    #
-    #   jruby -S limelight open --drb_port=9000 my_production
-    #
-    def publish_production_on_drb(port)
-      @drb_service = DRb.start_service("druby://localhost:#{port}", @production)
-    end
-
-    def establish_production #:nodoc:
-      @production.producer = self
-      @production.theater = @theater
-
-      production_file = @production.production_file
-      if File.exists?(production_file)
-        tmp_module = Module.new
-        content = IO.read(production_file)
-        tmp_module.module_eval(content, production_file)
-        production_module = tmp_module.const_get("Production")
-        raise "production.rb should define a module named 'Production'" if production_module.nil?
-        @production.extend(production_module)
-      end
-    end
-
-    private ###############################################
-
-    def unpack_production(production_name)
-      packer = Limelight::Util::Packer.new()
-      dest_dir = File.join(Data.productions_dir, rand.to_s.sub("0.", ""))
-      Dir.mkdir(dest_dir)
-      return packer.unpack(production_name, dest_dir)
-    end
-
-  end
-
-end

data/lib/limelight/production.rb

@@ -1,203 +0,0 @@
-#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
-#- Limelight and all included source files are distributed under terms of the GNU LGPL.
-
-require 'limelight/limelight_exception'
-require 'limelight/file_loader'
-require 'limelight/dsl/styles_builder'
-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 UI::Api::Production
-
-    class << self
-
-      def [](name) #:nodoc:
-        return Studio[name]
-      end
-
-    end
-
-    attr_reader :name, :root
-    attr_accessor :producer, :theater
-    attr_accessor :closed #:nodoc:
-
-
-    # Users typically need not create Production objects.
-    #
-    def initialize(path)
-      @root = FileLoader.for_root(path)
-      @name = File.basename(path)
-    end
-
-    # Sets the name of the Production.  The name must be unique amongst all Productions in memory.
-    #
-    def name=(value)
-      Context.instance.studio.error_if_duplicate_name(value)
-      @name = value
-    end
-
-    # Return the path to the root directory of the production
-    #
-    def path
-      return @root.root
-    end
-
-    # Returns the path to the production's init file
-    #
-    def init_file
-      return @root.path_to("init.rb")
-    end
-
-    # Returns the path to the production's production.rb file
-    #
-    def production_file
-      return @root.path_to("production.rb")
-    end
-
-    # Returns the path to the production's stages file
-    #
-    def stages_file
-      return @root.path_to("stages.rb")
-    end
-
-    # Returns the path to the production's styles file
-    #
-    def styles_file
-      return @root.path_to("styles.rb")
-    end
-
-    # Returns the path to the production's gems directory
-    #
-    def gems_directory
-      return @root.path_to("__resources/gems/gems")
-    end
-
-    # Returns the path to the productions gems root
-    #
-    def gems_root
-      return @root.path_to("__resources/gems")
-    end
-
-    # Returns the path to the named Scene's directory within the Production
-    #
-    def scene_directory(name)
-      return @root.root if name == :root
-      return @root.path_to(name)
-    end
-
-    # Returns the minimum version of limelight required to run this production.  Default: "0.0.0"
-    # If the version of limelight used to open this production is less than the minimum,
-    # an error will be displayed (starting with version 0.4.0).
-    #
-    def minimum_limelight_version
-      return "0.0.0"
-    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?
-      return true
-    end
-
-    # Called when the production is about to be opened.  The default implementation does nothing but you may re-implement
-    # it in the production.rb file.
-    #
-    def production_opening
-    end
-
-    # Called when the production has been loaded.  That is, when all the gems have been loaded stages have been
-    # instantiated.
-    #
-    def production_loaded
-    end
-
-    # Called when the production is fully opened.  The default implementation does nothing but you may re-implement
-    # it in the production.rb file.
-    #
-    def production_opened
-    end
-
-    # Called when the production is about to be closed.  The default implementation does nothing but you may re-implement
-    # it in the production.rb file.
-    #
-    def production_closing
-    end
-
-    # Called when the production is fully closed.  The default implementation does nothing but you may re-implement
-    # it in the production.rb file.
-    #
-    def production_closed
-    end
-
-    # returns true if the production has been closed.
-    #
-    def closed?
-      return @closed
-    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
-      @producer.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
-
-    # Called when the last stage in this production's theater is closed.  If the allow_close? returns true
-    # this production will be closed.
-    #
-    def theater_empty!
-      close if allow_close? && !closed?
-    end
-
-    # Returned the name of the default scene.  This is only used when there are not stages defined in the production.
-    # Defaults to :root, the production's root directory is the default scene.  Return nil if there are not defaults.
-    #
-    def default_scene
-      return :root
-    end
-
-    # A production with multiple Scenes may have a 'styles.rb' file in the root directory.  This is called the
-    # root_styles.  This method loads the root_styles, if they haven't already been loaded, and returns them.
-    #
-    def root_styles
-      unless @root_styles
-        if File.exists?(styles_file)
-          @root_styles = Limelight.build_styles_from_file(styles_file)
-        else
-          @root_styles = {}
-        end
-      end
-      return @root_styles
-    end
-
-    alias :getName :name #:nodoc:
-    alias :setName :name= #:nodoc:
-    alias :allowClose :allow_close? #:nodoc: 
-
-    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
-
-  end
-
-end

data/lib/limelight/prop.rb

@@ -1,367 +0,0 @@
-#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
-#- Limelight and all included source files are distributed under terms of the GNU LGPL.
-
-require 'limelight/java_util'
-require 'limelight/pen'
-require 'limelight/paint_action'
-require 'limelight/animation'
-
-module Limelight
-
-  # Prop is the fundamental building block of a scene.  A prop represents a rectangular area in the scene, of almost any dimension.
-  # It may have borders, backgrounds, margin, padding, and it may contain other props or text.  However it is the props'
-  # Styles that determine their size and appearance.
-  #
-  # A Prop may have one parent and many children.  Hense, when put together, they form a tree structure.  The Scene is
-  # the root Prop of a tree.
-  #
-  class Prop
-
-    class << self
-
-      def event(event_symbol)
-        @events ||= []
-        @events << event_symbol unless @events.include?(event_symbol)
-        define_method(event_symbol) { |event|  } # do nothing by default
-      end
-
-      def events
-        return @events
-      end
-
-      def event2(event_symbol)
-        @events ||= []
-        @events << event_symbol unless @events.include?(event_symbol)
-        define_method("accepts_#{event_symbol}".to_sym) { return self.respond_to?(event_symbol) }
-      end
-
-    end
-
-    include UI::Api::Prop
-
-    attr_accessor :style, :hover_style
-    attr_reader :panel #:nodoc:
-    attr_reader :children, :parent, :name, :id, :players
-    getters :panel, :style, :hover_style, :name, :scene, :loader #:nodoc:
-
-    # When creating a Prop, an optional Hash is accepted. These are called initialization options.
-    # The key/value pairs in the initialiaztion options will be used to
-    # set properties on the Prop, it Style, or included Player properties. These properties are not set
-    # until the prop is added to a Prop tree with a Scene.
-    #
-    def initialize(hash = {})
-      @options = hash || {}
-      @children = []
-      @style = Styles::ScreenableStyle.new
-      @panel = UI::Model::Panel.new(self)
-    end
-
-    # Add a Prop as a child of this Prop.
-    #
-    def add(child)
-      child.set_parent(self)
-      @children << child
-      @panel.add(child.panel)
-    end
-
-    # Same as add.  Returns self so adding may be chained.
-    #
-    #   prop << child1 << child2 << child3
-    #
-    def <<(child)
-      add(child)
-      return self
-    end
-
-    # Allows the adding of child Props using the PropBuilder DSL.
-    #
-    #    prop.build do
-    #      child1 do
-    #        grand_child
-    #      end
-    #      child2
-    #    end
-    #
-    def build(options = {}, &block)
-      require 'limelight/dsl/prop_builder'
-      builder = Limelight::DSL::PropBuilder.new(self)
-      builder.__install_instance_variables(options)
-      builder.__loader__ = scene.loader
-      builder.instance_eval(&block)
-    end
-
-    # Removes a child Prop.  The child Prop will be parentless after removal.
-    #
-    def remove(child)
-      if children.delete(child)
-        scene.unindex_prop(child) if scene
-        @panel.remove(child.panel)
-      end
-    end
-
-    # Removes all child Props.
-    #
-    def remove_all
-      @panel.remove_all
-      @children.each { |child| scene.unindex_prop(child) } if scene
-      @children = []
-    end
-
-    # Injects the behavior of the specified Player into the Prop.  The Player must be a Module.
-    #
-    def include_player(player_module)
-      unless self.is_a?(player_module)
-        extend player_module
-        self.casted if player_module.instance_methods.include?("casted")
-      end 
-    end
-
-    def update #:nodoc:
-      return if (scene.nil? || !scene.visible)
-      @panel.doLayout
-      @panel.repaint
-    end
-
-    def update_now #:nodoc:
-      return if (scene.nil? || !scene.visible)
-      @panel.doLayout()
-      @panel.paintImmediately(0, 0, @panel.width, @panel.height)
-    end
-
-    # A hook to invoke behavior after a Prop is painted.
-    #
-    def after_painting(flag = true, &block)
-      if flag
-        @panel.after_paint_action = PaintAction.new(&block)
-      else
-        @panel.after_paint_action = nil
-      end
-    end
-
-    # Searches all descendant of the Prop (including itself) for Props with the specified name.
-    # Returns an Array of matching Props. Returns an empty Array if none are found.
-    #
-    def find_by_name(name, results = [])
-      results << self if @name == name
-      @children.each { |child| child.find_by_name(name, results) }
-      return results
-    end
-
-    # Sets the text of this Prop.  If a prop is given text, it will become sterilized (it may not have any more children).
-    # Some Players such as text_box, will cause the text to appear in the text_box.
-    #
-    def text=(value)    
-      @panel.text = value.to_s
-    end
-
-    # Returns the text of the Prop.
-    #
-    def text
-      return panel.text
-    end
-
-    # Returns the scene to which this prop belongs to.
-    #
-    def scene 
-      return nil if @parent.nil?
-      @scene = @parent.scene if @scene.nil?
-      return @scene
-    end
-
-    # TODO get rid of me.... The Java Prop interface declares this method.
-    def loader
-      return scene.production.root;
-    end
-
-    # Returns the current Production this Prop lives in.
-    #
-    def production
-      return scene.production
-    end
-
-    def to_s #:nodoc:
-      return "#{self.class.name}[id: #{@id}, name: #{@name}]"
-    end
-
-    def inspect #:nodoc:
-      return self.to_s
-    end
-
-    # unusual name because it's not part of public api
-    def set_parent(parent) #:nodoc:
-      @parent = parent
-      if @parent.illuminated?
-        illuminate
-      end
-    end
-
-    # Allows the addition of extra initialization options.  Will raise an exception if the Prop has already been
-    # illuminated (added to a scene).
-    #
-    def add_options(more_options)
-      raise "Too late to add options" if illuminated?
-      @options.merge!(more_options)
-    end
-
-    # Returns a Box representing the relative bounds of the Prop. Is useful with usign the Pen.
-    #
-    #   box = prop.area
-    #   box.x, box.y # represents the Prop's location within its parent Prop
-    #   box.width, box.height # represents the Prop's dimensions
-    #
-    def area
-      return panel.get_bounding_box.clone
-    end
-
-    # Returns a Box representing the bounds inside the borders of the prop.  If the Prop's style has no margin or
-    # border_width, then this will be equivalant to area.
-    #
-    def bordered_area
-      return panel.get_box_inside_borders.clone
-    end
-
-    # Returns a Box representing the bounds inside the padding of the prop.  This is the area where child props may
-    # be located
-    #
-    def child_area
-      return panel.getChildConsumableArea().clone
-    end
-
-    # Returns a Pen object. Pen objects allow to you to draw directly on the screen, withing to bounds of this Prop.
-    #
-    def pen
-      return Pen.new(panel.getGraphics)
-    end
-
-    # Initiate an animation loop.  Options may include :name (string), :updates_per_second (int: defaults to 60)
-    # An Animation object is returned.
-    # The provided block will be invoked :updates_per_second times per second until the Animation is stopped.
-    #
-    #    @animation = prop.animate(:updates_per_second => 20) do
-    #      prop.style.border_width = (prop.style.top_border_width.to_i + 1).to_s
-    #      @animation.stop if prop.style.top_border_width.to_i > 60
-    #    end
-    #
-    # This above example will cause the Prop's border to grow until it is 60 pixels wide.
-    #
-    def animate(options={}, &block)
-      animation = Animation.new(self, block, options)
-      animation.start
-      return animation
-    end
-
-    # Plays a sound on the computers audio output.  The parameter is the filename of a .au sound file.
-    # This filename should relative to the root directory of the current Production, or an absolute path.
-    #
-    def play_sound(filename)
-      @panel.play_sound(scene.loader.path_to(filename))
-    end
-
-    # Luanches the spcified URL using the OS's default handlers. For example, opening a URL in a browser:
-    #
-    #   launch('http://www.google.com')
-    #
-    # To create a link prop add an accessor on the player (say url) and use that in the prop definition
-    # Ex:
-    #
-    #   link :text => "I am a link", :url => "http://www.8thlight.com"
-    def launch(url)
-      Context.instance.os.launch(url)
-    end
-
-    # GUI Events ##########################################
-
-    # TODO MDM - This may be very inefficient.  If seems like these methods are generated for each instance of prop.
-    event2 :mouse_clicked
-    event :mouse_entered
-    event :mouse_exited
-    event2 :mouse_pressed
-    event2 :mouse_released
-    event :mouse_dragged
-    event :mouse_moved
-    event :key_typed
-    event :key_pressed
-    event :key_released
-    event :focus_gained
-    event :focus_lost
-    event :button_pressed
-    event :value_changed
-
-    # TODO Try to get me out of public scope
-    #
-    def illuminate #:nodoc:
-      if illuminated?
-        scene.index_prop(self) if @id
-      else
-        set_id(@options.delete(:id))
-        @name = @options.delete(:name)
-        @players = @options.delete(:players)
-        @additional_styles = @options.delete(:styles)
-
-        inherit_styles
-        scene.casting_director.fill_cast(self)
-        apply_options
-
-        @options = nil
-      end
-      
-      children.each do |child|
-        child.illuminate
-      end
-    end
-
-    def illuminated? #:nodoc:
-      return @options.nil?
-    end  
-
-    private ###############################################
-
-    def set_id(id)
-      return if id.nil? || id.to_s.empty?
-      @id = id.to_s
-      scene.index_prop(self)
-    end
-
-    def apply_options
-      @options.each_pair do |key, value|
-        setter_sym = "#{key.to_s}=".to_sym
-        if self.respond_to?(setter_sym)
-          self.send(setter_sym, value)
-        elsif self.style.respond_to?(setter_sym)
-          self.style.send(setter_sym, value.to_s)
-        elsif is_event_setter(key)
-          define_event(key, value)
-        end
-      end
-    end
-
-    def is_event_setter(symbol)
-      string_value = symbol.to_s
-      return string_value[0..2] == "on_" && self.class.events.include?(string_value[3..-1].to_sym)
-    end
-
-    def define_event(symbol, value)
-      event_name = symbol.to_s[3..-1]
-      self.instance_eval "def #{event_name}(event); #{value}; end"
-    end
-
-    def inherit_styles
-      style_names = []
-      style_names << @name unless @name.nil?
-      style_names += @additional_styles.gsub(',', ' ').split(' ') unless @additional_styles.nil?   
-      style_names.each do |style_name|    
-        new_style = scene.styles[style_name]
-        @style.add_extension(new_style) if new_style
-        new_hover_style = scene.styles["#{style_name}.hover"]
-        if new_hover_style
-          if @hover_style.nil?
-            @hover_style = new_hover_style
-          else
-            @hover_style.add_extension(new_hover_style)
-          end
-        end
-      end
-    end
-
-  end
-end