epall-limelight 0.5.0-java

data/lib/limelight/paint_action.rb

@@ -0,0 +1,27 @@
+#- 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/pen'
+
+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/limelight/pen.rb

@@ -0,0 +1,83 @@
+#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+module Limelight
+
+  # The Pen is acquired from Prop.pen.  It is used to draw directly on the screen withing the bounds of the prop
+  # 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.  
+  #
+  class Pen
+    
+    attr_accessor :context
+
+    # It is constructed with a context which is essentially a java.awt.Graphic2D object.  Defaults are set:
+    # * color = "black"
+    # * width = 1
+    # * smooth = false
+    #
+    def initialize(context)
+      @context = context
+      self.color = "black"
+      self.width = 1
+      self.smooth = false
+    end
+
+    # Sets the color of the Pen.  The passed value should be a string that either names a known color or specifies
+    # a hex color value.
+    #
+    def color=(value)
+      resolve_color = Util::Colors.resolve(value)
+      @context.setColor(resolve_color)
+    end
+
+    # Sets the width, in pixels, of the pen.
+    #
+    def width=(value)
+      @context.setStroke(java.awt.BasicStroke.new(value))
+    end
+
+    # Specifies whether the pen will use anti-aliasing to draw smooth shapes or not.  Shapes will appear pixilated when
+    # smooth is set to false.
+    #
+    def smooth=(value)
+      hint = value ? java.awt.RenderingHints::VALUE_ANTIALIAS_ON : java.awt.RenderingHints::VALUE_ANTIALIAS_OFF
+      @context.setRenderingHint(java.awt.RenderingHints::KEY_ANTIALIASING, hint)
+    end
+
+    # Draws a line from the point (x1, y1) to the point (x2, y2)
+    #
+    def draw_line(x1, y1, x2, y2)
+      @context.drawLine(x1, y1, x2, y2)
+    end
+
+    # Draws a rectangle with the top left corner at (x, y).
+    #
+    def draw_rectangle(x, y, width, height)
+      @context.drawRect(x, y, width, height)
+    end
+
+    # Fills a rectangle with the current color of the Pen.  The top left corner of the rectangle is (x, y).
+    #
+    def fill_rectangle(x, y, width, height)
+      @context.fillRect(x, y, width, height)
+    end
+
+    # Draws the largest oval that will fit in the specified rectangle.  The top left corner of the bounding
+    # rectangle is at (x, y).  The center of the oval will be at (x + width/2, y + height/2).
+    #
+    def draw_oval(x, y, width, height)
+      @context.drawOval(x, y, width, height)
+    end
+
+    # 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/lib/limelight/producer.rb

@@ -0,0 +1,179 @@
+#- 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'
+
+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.
+  #
+  # For directory structures, see Limelight::Main
+  #
+  class Producer
+
+    # Creates a new Producer and has it open a Production by specified name.
+    #
+    def self.open(production_name, options={})
+      producer = new(production_name)
+      begin
+        producer.open(options)
+      rescue Exception => e
+        puts e
+        puts e.backtrace
+      end
+    end
+
+    attr_reader :theater, :production
+    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 : 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
+
+    # Opens the Production.
+    #
+    def open(options = {})
+      return unless version_compatible? || Studio.utilities_production.proceed_with_incompatible_version?(@production.name, @production.minimum_limelight_version)
+      @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 = Studio.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
+
+    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

@@ -0,0 +1,169 @@
+#- 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/studio'
+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
+
+    class << self
+
+      def [](name) #:nodoc:
+        return Studio[name]
+      end
+
+    end
+
+    attr_reader :name, :root
+    attr_accessor :producer, :theater
+
+    # 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)
+      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
+
+    # Closes the production. If there are no more productions open, the Limelight runtime will shutdown.
+    #
+    def close
+      self.production_closing
+      Studio.production_closed(self)
+      self.production_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
+
+  end
+
+end