limelight 0.2.1-java → 0.3.0-java

data/bin/ll.bat

@@ -1,4 +1,4 @@
-set LIMELIGHT_HOME=Y:\Projects\limelight
+set LIMELIGHT_HOME=Z:\Projects\limelight
 
 java -cp lib\limelight.jar;jruby\lib\jruby.jar %JAVA_OPTS% -Dlimelight.home=%LIMELIGHT_HOME% limelight.Main %1 %2 %3 %4 %5
 

data/lib/limelight/animation.rb

@@ -9,7 +9,7 @@ module Limelight
   # Although, this object does not update the screen, it provides a means to perform sequential updates in evenly
   # spaced time frames.
   #
-  class Animation < Limelight::AnimationTask
+  class Animation < Limelight::Background::Animation
 
     # A Prop and block are required to construct an Animation.  Options may include :name (string), :updates_per_second
     # (int defaults to 60)
@@ -23,10 +23,10 @@ module Limelight
       @block = block
       name = options[:name] || "#{prop.to_s} animation"
       updates_per_second = options[:updates_per_second] || 60
-      super(name, updates_per_second, prop.panel)
+      super(updates_per_second)
     end
 
-    def doPerform #:nodoc:
+    def doUpdate #:nodoc:
       @block.call
     end
 

data/lib/limelight/builtin/players.rb

@@ -9,4 +9,5 @@ require 'limelight/builtin/players/text_area'
 require 'limelight/builtin/players/text_box'
 require 'limelight/builtin/players/combo_box_popup_list_item'
 require 'limelight/builtin/players/combo_box_popup_list'
-require 'limelight/builtin/players/curtains'
+require 'limelight/builtin/players/curtains'
+require 'limelight/builtin/players/image'

data/lib/limelight/builtin/players/combo_box.rb

@@ -29,10 +29,16 @@ module Limelight
             combo_box = Limelight::UI::Model::Inputs::ComboBoxPanel.new
             prop.panel.add(combo_box)
             prop.combo_box = combo_box.combo_box
+            prop.clear
           end
         end
 
         attr_accessor :combo_box #:nodoc:
+        attr_reader :choices
+
+        def clear #:nodoc:
+          @choices = []
+        end
 
         # Sets the choices listed in the combo_box.  The value parameter should an Array or a String that
         # can be evalulated into an Array.  All choices in a combo_box are strings.
@@ -43,7 +49,7 @@ module Limelight
         def choices=(value)
           value = eval(value) if value.is_a? String
           raise "Invalid choices type: #{value.class}.  Choices have to be an array." if !value.is_a?(Array)
-          @values = value
+          @choices = value
           combo_box.remove_all_items
           value.each { |choice| combo_box.add_item(choice) }
         end
@@ -69,7 +75,7 @@ module Limelight
           popup_style.y = panel.absolute_location.y.to_s
           popup_style.width = panel.width.to_s
 
-          @values.each do |value|
+          @choices.each do |value|
             popup_list.add(Limelight::Prop.new(:name => "limelight_builtin_players_combo_box_popup_list_item", :text => value, :players => "combo_box_popup_list_item", :combo_box => self))
           end
 

data/lib/limelight/builtin/players/image.rb

@@ -0,0 +1,47 @@
+module Limelight
+  module Builtin
+    module Players
+
+      module Image
+
+        class << self
+
+          def extended(prop) #:nodoc:
+            image_panel = Limelight::UI::Model::ImagePanel.new
+            prop.panel.add(image_panel)
+            prop.image_panel = image_panel
+          end
+          
+        end
+
+        attr_accessor :image_panel #:nodoc:
+        
+        def image=(path)
+          image_panel.image_file = path
+        end
+
+        def image
+          return image_panel.image_file
+        end
+
+        def rotation=(value)
+          image_panel.rotation = value.to_f
+        end
+
+        def rotation
+          return image_panel.rotation
+        end
+
+        def scaled=(value)
+          image_panel.scaled = value
+        end
+
+        def scaled?
+          return image_panel.scaled
+        end
+
+      end
+
+    end
+  end
+end

data/lib/limelight/builtin/styles.rb

@@ -16,7 +16,7 @@ limelight_builtin_players_combo_box_popup_list {
   rounded_corner_radius 5
   border_width 1
   border_color "#dcdcdc"
-  vertical_scroll_bar :on
+  vertical_scrollbar :on
   min_height 50
   max_height 200
 }

data/lib/limelight/casting_director.rb

@@ -11,70 +11,101 @@ module Limelight
   # Users of Limelight need not be concerned with this class.
   #
   class CastingDirector
-    
+
     def initialize(loader)
       @loader = loader
       @known_players = {}
     end
-    
+
     def fill_cast(prop)
+      raise LimelightException.new("Cannot cast a Prop without a Scene.") if prop.scene.nil?
       cast_default_player(prop)
       cast_additional_players(prop)
     end
-    
+
     private ###############################################
-    
+
     def cast_default_player(prop)
       return if prop.name.nil? || prop.name.empty?
-      prop.include_player(@known_players[prop.name]) if player_exists?(prop, prop.name)
+      cast_player(prop, prop.name)
     end
-    
+
     def cast_additional_players(prop)
       return if prop.players.nil? || prop.players.empty?
       player_names = prop.players.split(/[ ,]/)
       player_names.each do |player_name|
-        apply_player(prop, player_name)
+        cast_player(prop, player_name)
       end
     end
-    
-    def apply_player(prop, player_name)
-      prop.include_player(@known_players[player_name]) if player_exists?(prop, player_name)
+
+    def cast_player(prop, player_name)
+      recruiter = Recruiter.new(prop, player_name, @loader)
+      prop.include_player(recruiter.player) if recruiter.player_exists?
+    end
+  end
+
+  class Recruiter
+
+    def initialize(prop, player_name, loader)
+      @prop = prop
+      @cast = prop.scene.cast
+      @player_name = player_name
+      @module_name = player_name.camalized
+      @loader = loader
+    end
+
+    def player
+      return @cast.const_get(@module_name)
+    end
+
+    def player_already_exists?
+      return @cast.const_defined?(@module_name)
     end
-    
-    def player_exists?(prop, player_name)
-      load_player_by_name(prop, player_name) if !@known_players.has_key?(player_name)
-      return @known_players[player_name] != :does_not_exist
+
+    def player_exists?
+      recruit_player if !player_already_exists?
+      return @cast.const_get(@module_name) != :does_not_exist
     end
-    
-    def load_player_by_name(prop, player_name)
-      load_custom_player(prop, player_name)
-      load_builtin_player(player_name) if !@known_players.has_key?(player_name)
-      @known_players[player_name] = :does_not_exist if !@known_players.has_key?(player_name)
+
+    def recruit_player
+      recruit_custom_player
+      recruit_builtin_player if !player_already_exists?
+      @cast.const_set(@module_name, :does_not_exist) if !player_already_exists?
     end
-    
-    def load_custom_player(prop, player_name)
-      player_filename = File.join([prop.scene.path.to_s, "players", "#{player_name}.rb"])
-      return if !@loader.exists?(player_filename)
-      
-      Kernel.load @loader.path_to(player_filename)
-      
-      module_name = player_name.camalized
-      return if !Object.const_defined?(module_name)
-      
-      mod = Object.const_get(module_name)
-      @known_players[player_name] = mod
+
+    def recruit_custom_player
+      player_filename = locate_player
+      load_player(player_filename) if player_filename
     end
-    
-    def load_builtin_player(player_name)
+
+    def recruit_builtin_player
       begin
-        module_name = player_name.camalized
-        return if !Limelight::Builtin::Players.const_defined?(module_name)
-        mod = Limelight::Builtin::Players.const_get(module_name)
-        @known_players[player_name] = mod
+        return if !Limelight::Builtin::Players.const_defined?(@module_name)
+        @cast.const_set(@module_name, Limelight::Builtin::Players.const_get(@module_name))
       rescue NameError
       end
     end
-    
+
+    private ###############################################
+
+    def locate_player
+      player_filename = File.join(@prop.scene.path.to_s, "players", "#{@player_name}.rb")  
+      if !@loader.exists?(player_filename)
+        if @prop.scene.production && @prop.scene.path != @prop.scene.production.path
+          player_filename = File.join(@prop.scene.production.path.to_s, "players", "#{@player_name}.rb")
+          return nil if !@loader.exists?(player_filename)
+        else
+          return nil
+        end
+      end
+      return player_filename
+    end
+
+    def load_player(player_filename)
+      src = IO.read(@loader.path_to(player_filename))
+      @cast.module_eval(src, player_filename)
+    end
+
   end
-  
+
 end

data/lib/limelight/commands/command.rb

@@ -0,0 +1,150 @@
+require 'optparse'
+
+module Limelight
+  module Commands
+
+    LISTING = {}
+
+    class << self
+
+      def [](name)
+        load_listing if !@listing_loaded
+        return LISTING[name]
+      end
+
+      def load_listing
+        Dir.entries(File.dirname(__FILE__)).each do |file|
+          if file != "." && file != ".."
+            require "limelight/commands/#{file.gsub('.rb', '')}"
+          end
+        end
+        @listing_loaded = true
+      end
+
+    end
+
+    # The base class for all limelight commands.  The following is a list of them all.
+    #
+    #  Usage: limelight <command> [options] [params]
+    #    commands:
+    #    create		Creates the directories and files for a production and/or scene.
+    #    freeze		freeze a gem into a production.
+    #    open		Open a limelight production.
+    #    pack		Pack a limelight production into a .llp file.
+    #
+    class Command
+
+      class << self
+
+        attr_accessor :alias
+
+        # Sets the alias for the derivative command and installs it in the command listing.  All derivative much
+        # call this method exactly once.
+        #
+        def install_as(name)
+          raise "Command already installed: #{name}." if LISTING[name]
+          self.alias = name
+          LISTING[name] = self
+        end
+
+        # Abstract class level methof that returns a string description of the command.  Derivatives should
+        # override this class level method.
+        #
+        def description
+          return "Default Command description"
+        end
+
+      end
+
+      # Flag.  The backtrace on parse errors will be printed if true.
+      #
+      attr_accessor :print_backtrace
+
+      # Runs the command.  This is TemplateMethod.  It will first parse the arguments, then require files, and finally
+      # process the command.  Derivative should not override this method.
+      #
+      def run(args)
+        parse(args)
+        do_requires
+        begin
+          process if !@has_parse_error
+        rescue SystemExit
+          #okay
+        end
+      end
+
+      # Parse the arguments.  All options will be parsed first, then parse_remainder will be called on
+      # remaining args.  Derivative should not override this method.
+      #
+      def parse(args)         
+        begin
+          remainder = options_spec.parse(args)
+          parse_remainder(remainder)
+        rescue SystemExit => e
+          raise e
+        rescue Exception => e
+          @has_parse_error = true
+          parse_error e
+        end
+      end
+
+      protected ###########################################
+
+      # Prints an exception that occurs while parsing the arguments.  The usages summary will follow.
+      #
+      def parse_error(exception = nil)
+        if exception
+          puts ""
+          puts "!!! #{exception}"
+          puts exception.backtrace if @print_backtrace
+        end
+        usage
+        exit -1
+      end
+
+      # Prints the usage summary for a command.
+      #
+      def usage
+        puts ""
+        puts "Usage: limelight #{self.class.alias} #{parameter_description}"
+        puts "    #{self.class.description}"
+        puts "    options:"
+        puts options_spec.summarize
+      end
+
+      # Retreives the OptionParser instance for this command.  It will create it if it doesn't exist.
+      #
+      def options_spec
+        if @options_spec.nil?
+          @options_spec = OptionParser.new
+          @options_spec.on("-h", "--help", "Prints this usage summary.") { usage; exit 0 }
+          build_options(@options_spec)
+        end
+        return @options_spec
+      end
+
+      # Abstract method to require any files needed for processing the command.  Derivative should override this
+      # method if they need to require any files.
+      #
+      def do_requires
+        #override me
+      end
+
+      # Abstract method to define the command line options in the OptionParser.  Derivative should override
+      # this method if they offer command line options 
+      #
+      def build_options(spec)
+        #override me
+      end
+
+      # Abstract method to parse command line paramters.  Parameter are those command line arguments listed after
+      # the options.  Derivatives should override this method they take command line paramters.
+      #
+      def parse_remainder(args)
+        #override me
+      end
+
+    end
+
+  end
+end

data/lib/limelight/commands/create_command.rb

@@ -0,0 +1,79 @@
+require 'limelight/commands/command'
+
+module Limelight
+  module Commands
+
+    # See the following usages summary
+    #
+    #     Usage: limelight create [options] <production|scene> <path>
+    #        Creates the directories and files for a production and/or scene.
+    #        options:
+    #        -h, --help                       Prints this usage summary.
+    #        -s, --scene=<name>               Name of scene when creating a production.  Defaults to 'default_scene'.
+    #
+    # Assume you wanted to create a new production named "love_story" containing two scenes, "midnight_romance" and
+    # "happily_ever_after".  The following commands would created all the needed files.
+    #
+    #   $ jruby -S limelight create -s midnight_romance production love_story
+    #   $ jruby -S limelight create scene love_story/happily_ever_after
+    #
+    class CreateCommand < Command
+
+      install_as "create"
+
+      def self.description #:nodoc:
+        return "Creates the directories and files for a production and/or scene."
+      end
+
+      protected ###########################################
+
+      attr_reader :template_type, :path, :default_scene_name  #:nodoc:
+
+      def initialize #:nodoc:
+        @default_scene_name = "default_scene"
+        @actions = {}
+        @actions["production"] = :create_production
+        @actions["scene"] = :create_scene
+      end
+
+      def process #:nodoc:
+        action = @actions[@template_type]
+        self.send action
+      end
+
+      def parameter_description #:nodoc:
+        return "[options] <production|scene> <path>"
+      end
+
+      def parse_remainder(args) #:nodoc:
+        @template_type = args.shift
+        raise "Missing template type" if @template_type.nil?
+        raise "Unknown template type: #{@template_type}" if @actions[@template_type].nil?
+        @path = args.shift
+        raise "Missing path parameter" if @path.nil?
+      end
+
+      def do_requires #:nodoc:
+        require 'limelight/templates/production_templater'
+        require 'limelight/templates/scene_templater'
+      end
+
+      def build_options(spec) #:nodoc:
+        spec.on("-s <name>", "--scene=<name>", "Name of scene when creating a production.  Defaults to 'default_scene'.") { |value| @default_scene_name = value}
+      end
+
+      private #############################################
+
+      def create_production
+        Templates::ProductionTemplater.new(@path, @default_scene_name).generate
+        Templates::SceneTemplater.new("#{@path}/#{@default_scene_name}").generate
+      end
+
+      def create_scene
+        Templates::SceneTemplater.new(@path).generate
+      end
+
+    end
+
+  end
+end