limelight 0.2.1-java → 0.3.0-java

data/lib/limelight/dsl/stage_builder.rb

@@ -0,0 +1,105 @@
+#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+require 'limelight/stage'
+require 'limelight/limelight_exception'
+
+module Limelight
+
+  # A trigger to build/configure Stage objects using the StageBuilder DSL.
+  #
+  # See Limelight::Stagesbuilder, Limelight::Stagebuilder
+  #
+  def self.build_stages(theater, &block)
+    builder = DSL::StagesBuilder.new(theater)
+    builder.instance_eval(&block) if block
+    return builder.__stages__
+  end
+
+  module DSL
+
+    # The basis of the DSL for building Stage objects.
+    #
+    #  stage "inspector" do
+    #    default_scene "inspector"
+    #    title "Limelight Composer Inspector"
+    #    location [0, 0]
+    #    size [300, 800]
+    #  end
+    #
+    #  stage "viewer" do
+    #    title "Limelight Composer Viewer"
+    #    location [350, 0]
+    #    size [800, 800]
+    #  end
+    #
+    # In this example above, two stages are created for the production.  One is named 'inspector' and the other is named
+    # 'viewer'.  'inspector' has a default scene that will be loaded on startup.  'viewer' will not contain any scene
+    # on startup.  Using the DSL, each stage can be configured to set the title, location, size, or any other attribute
+    # of a stage.
+    #
+    # See Limelight::Stage
+    #
+    class StagesBuilder
+
+      Limelight::Util.lobotomize(self)
+
+      attr_reader :__stages__
+
+      # Constructs a new StagesBuilder.  A Theater object is required as a parameter.  Each stages created will belong
+      # to the Theater passed in.
+      #
+      def initialize(theater)
+        @__theater__ = theater
+        @__stages__ = []
+      end
+
+      # Creates a new stage with the provided name.  The block will contain StageBuilder DSL to configure the stage.
+      #
+      def stage(name, &block)
+        stage_builder = StageBuilder.new(@__theater__, name)
+        stage_builder.instance_eval(&block) if block
+        @__stages__ << stage_builder.__stage__
+      end
+
+    end
+
+    # The basis of the DSL for configuring a Stage object.
+    #
+    class StageBuilder
+
+      Limelight::Util.lobotomize(self)
+
+      attr_reader :__stage__
+
+      def initialize(theater, name) #:nodoc:
+        if theater[name]
+          @__stage__ = theater[name]
+        else
+          @__stage__ = theater.add_stage(name)
+        end
+      end
+
+      # Specifies the scene that will be displayed on the stage upon opening of the production.
+      #
+      def default_scene(scene_name)
+        @__stage__.default_scene = scene_name
+      end
+
+      def method_missing(sym, value)  #:nodoc:
+        setter_sym = "#{sym}=".to_s
+        raise StageBuilderException.new(sym) if !@__stage__.respond_to?(setter_sym)
+        @__stage__.send(setter_sym, value)
+      end
+    end
+
+    # Exception thrown by StageBuilder in the event of an invalid configuration.
+    #
+    class StageBuilderException < LimelightException
+      def initialize(name)
+        super("'#{name}' is not a valid stage property")
+      end
+    end
+
+  end
+end

data/lib/limelight/dsl/styles_builder.rb

@@ -0,0 +1,134 @@
+#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+require 'limelight/util'
+
+module Limelight
+
+  # A trigger to define Style objects using the StyleBuilder DSL.
+  #
+  # See Limelight::Stylesbuilder, Limelight::Stylebuilder
+  #
+  def self.build_styles(style_hash = nil, &block)
+    builder = DSL::StylesBuilder.new(style_hash)
+    builder.instance_eval(&block) if block
+    return builder.__styles__
+  end
+
+  module DSL
+
+    # The basis of the DSL for building Style objects.
+    #
+    # Sample StyleBuilder DSL
+    #
+    #  sandbox {
+    #    width "100%"
+    #    height "100%"
+    #    vertical_alignment :top
+    #  }
+    #
+    #  sample {
+    #    width 320
+    #    height 320
+    #    gradient :on
+    #  }
+    #
+    #  spinner {
+    #    extends :sample
+    #    background_color :green
+    #    secondary_background_color :blue
+    #    gradient_angle 0
+    #    gradient_penetration 100
+    #  }
+    #
+    # This exmple builds three styles: sandbox, sample, spinner.  Within each style block, the individual attributes of
+    # the style may be set.
+    #
+    # See Limelight::Styles
+    #
+    class StylesBuilder
+
+      Limelight::Util.lobotomize(self)
+
+      attr_reader :__styles__
+
+      def initialize(style_hash = nil)
+        @__styles__ = style_hash || {}
+      end
+
+      def method_missing(sym, &block) #:nodoc:
+        __add_style__(sym.to_s, &block)
+      end
+
+      def __add_style__(name, &block) #:nodoc:
+        builder = StyleBuilder.new(name, self)
+        builder.instance_eval(&block) if block
+        @__styles__[name] = builder.__style__
+      end
+    end
+
+    # The basis of the DSL for defining a Style object.
+    #
+    class StyleBuilder
+
+      Limelight::Util.lobotomize(self)
+
+      attr_reader :__style__  #:nodoc:
+
+      def initialize(name, styles_builder, options = {})  #:nodoc:
+        @__name = name
+        @__styles_builder = styles_builder
+        @__style__ = @__styles_builder.__styles__[name] || Styles::RichStyle.new
+      end
+
+      # Used to define a hover style.  Hover styles are appiled when the mouse passed over a prop using the specified style.
+      #
+      #   spinner {
+      #     width 50
+      #     height 50
+      #     hover {
+      #       text_color :white
+      #     }
+      #   }
+      #
+      # The text color of props using the 'spinner' style will become white when the mouse hovers over them.
+      #
+      def hover(&block)
+        @__styles_builder.__add_style__("#{@__name}.hover", &block)
+      end
+
+      # Styles may extend other styles.
+      #
+      #    base {
+      #      background_color :red
+      #    }
+      #
+      #    cell {
+      #      extends :base
+      #      text_color :black
+      #    }
+      #
+      # The 'cell' style now has all attributes defined in 'base'.  Therefore any prop using the 'cell' style
+      # will have a red background.  Styles may override attributes aquired through extension.
+      #
+      def extends(*style_names)
+        style_names.each do |style_name|
+          extension = @__styles_builder.__styles__[style_name.to_s]
+          raise StyleBuilderException.new("Can't extend missing style: '#{style_name}'") if extension.nil?
+          @__style__.add_extension(extension)
+        end
+      end
+
+      def method_missing(sym, value) #:nodoc:
+        setter_sym = "#{sym}=".to_s
+        raise StyleBuilderException.new("'#{sym}' is not a valid style") if !@__style__.respond_to?(setter_sym)
+        @__style__.send(setter_sym, value.to_s)
+      end
+    end
+
+    # Exception thrown by StyleBuilder when an error is encountered.
+    #
+    class StyleBuilderException < Exception
+    end
+
+  end
+end

data/lib/limelight/file_loader.rb

@@ -0,0 +1,46 @@
+#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+module Limelight
+
+  class FileLoader #:nodoc:
+
+    include ResourceLoader
+
+    attr_reader :root
+
+    def self.for_root(root)
+      loader = new
+      loader.reset_on_root(root)
+      return loader
+    end
+
+    def reset_on_root(root)
+      @root = File.expand_path(root)
+    end
+
+    def path_to(path)
+      if (path == File.expand_path(path))
+        return path
+      else
+        return File.expand_path(File.join(@root, path))
+      end
+    end
+
+    def exists?(path)
+      return File.exists?(path_to(path))
+    end
+
+    alias :pathTo :path_to
+
+    def load(path)
+      file_to_load = path_to(path)
+      raise LimelightException.new("File not found: #{file_to_load}") if not File.exists?(file_to_load)
+      return IO.read(file_to_load)
+    end
+
+    alias :read :load
+
+  end
+
+end

data/lib/limelight/gems.rb

@@ -0,0 +1,45 @@
+module Limelight
+  module Gems
+
+    class << self
+
+      attr_accessor :current_production
+
+      def load_path
+        @load_path = $: if @load_path.nil?
+        return @load_path
+      end
+
+      def install(gem_name, paths)
+        stack = paths.dup
+        while !stack.empty?
+          load_path.unshift File.join(current_production.gems_directory, gem_name, stack.pop)
+        end
+      end
+
+      def install_gems_in_production(production)
+        self.current_production = production
+
+        gems_dir = current_production.gems_directory
+        if File.exists?(gems_dir) && File.directory?(gems_dir)
+          gems = Dir.entries(gems_dir).select { |dir| dir != "." && dir != ".." }
+          gems.sort!
+          gems.reverse!
+          gems.each do |gem_name|
+            init_file = File.join(gems_dir, gem_name, 'limelight_init.rb')
+            if File.exists?(init_file)
+              load init_file
+            else
+              puts "WARNING: Frozen gem (#{gem_name}) is missing limelight_init.rb file."
+            end
+          end
+        end
+
+        self.current_production = nil
+      end
+
+    end
+
+
+  end
+end

data/lib/limelight/java_couplings.rb

@@ -4,9 +4,12 @@
 module Limelight #:nodoc:
 
   Main = Java::limelight.Main
-  SceneLoader = Java::limelight.SceneLoader
+  ResourceLoader = Java::limelight.ResourceLoader
   Context = Java::limelight.Context
-  AnimationTask = Java::limelight.AnimationTask
+
+  module Background
+    Animation = Java::limelight.background.Animation
+  end
 
   module Styles #:nodoc:
     Style = Java::limelight.styles.Style
@@ -26,6 +29,7 @@ module Limelight #:nodoc:
     module Model #:nodoc:
       Frame = Java::limelight.ui.model.Frame
       Panel = Java::limelight.ui.model.PropPanel
+      ImagePanel = Java::limelight.ui.model.ImagePanel
 
       module Inputs #:nodoc:
        ButtonPanel = Java::limelight.ui.model.inputs.ButtonPanel
@@ -42,6 +46,7 @@ module Limelight #:nodoc:
       Prop = Java::limelight.ui.api.Prop
       Stage = Java::limelight.ui.api.Stage
       Theater = Java::limelight.ui.api.Theater
+      Studio = Java::limelight.ui.api.Studio
     end
 
     module Painting #:nodoc:

data/lib/limelight/java_util.rb

@@ -1,6 +1,8 @@
 #- Copyright 2008 8th Light, Inc. All Rights Reserved.
 #- Limelight and all included source files are distributed under terms of the GNU LGPL.
 
+require 'limelight/string'
+
 class Class
 
   # Class level method to creates Java style getters.
@@ -44,19 +46,4 @@ class Class
   end
   
 end
-
-class String
-
-  # Converts Ruby style names to Java style camal case.
-  #
-  #   "four_score".camalized # => "FourScore"
-  #   "and_seven_years".camalized(:lower) # => "andSevenYears"
-  #
-  def camalized(starting_case = :upper)
-    value = self.downcase.gsub(/[_| ]([a-z])/) { |match| match[-1..-1].upcase } 
-    value = value[0..0].upcase + value[1..-1] if starting_case == :upper
-    return value
-  end
-  
-end
   

data/lib/limelight/main.rb

@@ -1,7 +1,7 @@
 #- Copyright 2008 8th Light, Inc. All Rights Reserved.
 #- Limelight and all included source files are distributed under terms of the GNU LGPL.
 
-require 'limelight/commands'
+require 'limelight/commands/command'
 
 module Limelight
 
@@ -81,7 +81,7 @@ module Limelight
       #
       def run(args)
         command_name = args.shift
-        command = Commands::COMMANDS[command_name]
+        command = Commands[command_name]
         if command
           command.new.run(args)
         else
@@ -92,12 +92,14 @@ module Limelight
       # Prints the usage of the limelight command.
       #
       def usage
+        puts ""
         puts "Usage: limelight <command> [options] [params]"
-        puts "commands:"
-        Commands::COMMANDS.keys.sort.each do |key|
-          command = Commands::COMMANDS[key]
+        puts "  commands:"
+        Commands::LISTING.keys.sort.each do |key|
+          command = Commands[key]
           puts "\t#{key}\t\t#{command.description}"
         end
+        exit -1
       end
     end
 

data/lib/limelight/producer.rb

@@ -1,16 +1,17 @@
 #- Copyright 2008 8th Light, Inc. All Rights Reserved.
 #- Limelight and all included source files are distributed under terms of the GNU LGPL.
 
-require 'limelight/loaders/file_scene_loader'
-require 'limelight/prop_builder'
-require 'limelight/styles_builder'
-require 'limelight/stage_builder'
-require 'limelight/production_builder'
+require 'limelight/file_loader'
+require 'limelight/dsl/prop_builder'
+require 'limelight/dsl/styles_builder'
+require 'limelight/dsl/stage_builder'
+require 'limelight/dsl/production_builder'
 require 'limelight/casting_director'
 require 'limelight/stage'
-require 'limelight/build_exception'
+require 'limelight/dsl/build_exception'
 require 'limelight/theater'
 require 'limelight/production'
+require 'limelight/gems'
 
 module Limelight
 
@@ -27,7 +28,7 @@ module Limelight
       producer = new(production_name)
       producer.open
     end
-    
+
     attr_reader :loader, :theater, :production
     attr_writer :builtin_styles
 
@@ -35,12 +36,16 @@ module Limelight
     # 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] == ".llp")
+      if (root_path[-4..-1] == ".lll")
+        url = IO.read(root_path).strip
+        root_path = Limelight::Context.instance.downloader.download(url).absolute_path
+      end
+      if (root_path[-4..-1] == ".llp")
         root_path = unpack_production(root_path)
       end
-      @loader = Loaders::FileSceneLoader.for_root(root_path)
+      @production = production || Production.new(root_path)
+      @loader = @production.root
       @theater = theater.nil? ? Theater.new : theater
-      @production = production
     end
 
     # Returns the CastingDirector for this Production.
@@ -50,40 +55,52 @@ module Limelight
       return @casting_director
     end
 
-    # Opens the Production specified during construction. If the file 'init.rb' exists in the root directory of the
-    # Production, it will be loaded before anything else.
+    # Loads the Production without opening it.  The Production will be created into memory with all it's stages
     #
-    def open()
+    def load(options = {})
       establish_production
-      Kernel.load(@loader.path_to("init.rb")) if @loader.exists?("init.rb")
-      if @loader.exists?("stages.rb")
-        load_stages.each { |stage| open_scene(stage.default_scene, stage) }
+      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()
+      load
+      if @theater.has_stages?
+        @theater.stages.each { |stage| open_scene(stage.default_scene, stage) if stage.default_scene }
       else
-        open_scene('.', @theater.default_stage)
+        open_scene(:root, @theater.default_stage)
       end
       @casting_director = nil
     end
 
     # Opens the specified Scene onto the Spcified Stage.
     #
-    def open_scene(path, stage)
-      styles = load_styles(path)
-      merge_with_root_styles(styles)
+    def open_scene(name, stage)
+      path = @production.scene_directory(name)
+      scene_name = File.basename(path)
+      scene = load_props(:production => @production, :casting_director => casting_director, :path => path, :name => scene_name)
 
-      scene = load_props(path, :styles => styles, :production => @production, :casting_director => casting_director, :loader => @loader, :path => path)
+      styles = load_styles(scene)
+      merge_with_root_styles(styles)
+      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
-      content = @loader.load("stages.rb")
+      stages_file = @production.stages_file
+      content = IO.read(stages_file)
       stages = Limelight.build_stages(@theater) do
         begin
           eval content
         rescue Exception => e
-          raise BuildException.new("stages.rb", content, e)
+          raise DSL::BuildException.new(stages_file, content, e)
         end
       end
       return stages
@@ -91,33 +108,34 @@ module Limelight
 
     # Loads of the 'props.rb' file for a particular Scene and creates all the Prop objects and Scene.
     #
-    def load_props(path, options = {})
-      return Scene.new(options) if path.nil?
-      filename = File.join(path, "props.rb")
-      content = @loader.exists?(filename) ? @loader.load(filename) : ""
-      options[:build_loader] = @loader
-      return Limelight.build_scene(options) do
-        begin
-          eval content
-        rescue Exception => e
-          raise BuildException.new(filename, content, e)
+    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_scene(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(path)
+    def load_styles(context)
       styles = builtin_styles
-      return styles if path.nil?
-      filename = File.join(path, "styles.rb")
-      return styles if not @loader.exists?(filename)
-      content = @loader.load(filename)
+      return styles if not File.exists?(context.styles_file)
+      content = IO.read(context.styles_file)
       return Limelight.build_styles(styles) do
         begin
           eval content
         rescue Exception => e
-          raise BuildException.new(filename, content, e)
+          raise DSL::BuildException.new(context.styles_file, content, e)
         end
       end
     end
@@ -125,49 +143,39 @@ module Limelight
     # Loads the 'production.rb' file if it exists and configures the Production.
     #
     def establish_production
-      return if @production
-      if @loader.exists?("production.rb")
-        content = @loader.load("production.rb")
-        @production = Limelight.build_production(self, @theater) do
+      @production.producer = self
+      @production.theater = @theater
+
+      if @production.root.exists?("production.rb")
+        content = @production.root.load("production.rb")
+        @production = Limelight.build_production(@production) do
           begin
             eval content
           rescue Exception => e
-            raise BuildException.new("production.rb", content, e)
+            raise DSL::BuildException.new("production.rb", content, e)
           end
         end
-      else
-        @production = Production.new(self, @theater)
-      end      
+      end
+
     end
 
     # A production with multiple Scenes may have a 'styles.rb' file in the root directory.  This is called the
     # root_style.  This method loads the root_styles, if they haven't already been loaded, and returns them.
     #
     def root_styles
-      return @root_syles if @root_syles
-      if @loader.exists?('styles.rb')
-        @root_styles = load_styles('.')
+      return @root_syles if @root_syles   
+      if File.exists?(@production.styles_file)
+        @root_styles = load_styles(@production)
       else
         @root_styles = {}
       end
       return @root_styles
     end
-    
-    private ###############################################
-    
-    def merge_with_root_styles(styles)
-      root_styles.each_pair do |key, value|
-        styles[key] = value if !styles.has_key?(key)
-      end
-    end
-
-    def unpack_production(production_name)
-      packer = Limelight::Util::Packer.new()
-      return packer.unpack(production_name)
-    end
 
+    # Returns a hash of all the built-in Limglight Styles
+    #
     def builtin_styles
-      return @builtin_styles if @builtin_styles 
+      return @builtin_styles.dup if @builtin_styles
       builtin_styles_file = File.join($LIMELIGHT_LIB, "limelight", "builtin", "styles.rb")
       content = IO.read(builtin_styles_file)
       @builtin_styles = Limelight.build_styles do
@@ -177,9 +185,22 @@ module Limelight
           raise BuildException.new(filename, content, e)
         end
       end
-      return @builtin_styles
+      return @builtin_styles.dup
+    end
+
+    private ###############################################
+
+    def merge_with_root_styles(styles)
+      root_styles.each_pair do |key, value|
+        styles[key] = value if !styles.has_key?(key)
+      end
+    end
+
+    def unpack_production(production_name)
+      packer = Limelight::Util::Packer.new()
+      return packer.unpack(production_name)
     end
 
   end
-  
+
 end