limelight 0.5.0-java → 0.5.1-java

data/lib/init.rb

@@ -1,16 +1,12 @@
 #- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
 #- Limelight and all included source files are distributed under terms of the GNU LGPL.
 
-$LIMELIGHT_LIB = File.expand_path(File.dirname(__FILE__))
-$: << $LIMELIGHT_LIB unless $:.include?($LIMELIGHT_LIB)
-$LIMELIGHT_HOME = File.expand_path(File.join($LIMELIGHT_LIB, ".."))
+
 
 require 'java'
 if File.exists?(File.dirname(__FILE__) + "/limelight.jar")
   require File.expand_path(File.dirname(__FILE__) + "/limelight.jar")
 end
 
+require File.expand_path(File.dirname(__FILE__) + "/limelight/limelight_init")
 
-# ENV["GEM_HOME"] = ENV["GEM_PATH"] = File.expand_path(File.dirname(__FILE__) + "/../../jruby/lib/ruby/gems/1.8")
-require 'rubygems'
-require 'limelight/java_couplings'

data/lib/limelight/builtin/utilities_production/production.rb

@@ -10,6 +10,10 @@ module Production
     @alert_monitor = @monitor.new_cond
   end
 
+  def allow_close?
+    return false
+  end
+
   def default_scene
     nil
   end

data/lib/limelight/commands/create_command.rb

@@ -53,7 +53,7 @@ module Limelight
         raise "Missing template type" if @template_type.nil?
         raise "Unknown template type: #{@template_type}" if !["production", "scene"].include?(@template_type)
         self.send "parse_#{@template_type}".to_sym, args
-        @spec_path = File.join(@production_path, "spec") unless @spec_path
+        @spec_path = "spec" unless @spec_path
       end
 
       def do_requires #:nodoc:

data/lib/limelight/commands/open_command.rb

@@ -18,7 +18,7 @@ module Limelight
 
       install_as "open"
 
-      DEFAULT_PRODUCTION = File.expand_path($LIMELIGHT_HOME + "/productions/startup")
+      DEFAULT_PRODUCTION = File.expand_path($LIMELIGHT_HOME + "/productions/playbills.lll")
 
       attr_reader :drb_port
 
@@ -36,7 +36,7 @@ module Limelight
         return "<production_path>"
       end
 
-      def do_requires
+      def do_requires       
         Main.initialize_context
         require 'limelight/producer'
       end
@@ -50,8 +50,8 @@ module Limelight
       end
 
       def process
-        Studio.publish_on_drb(@drb_port.to_i) if @drb_port
-        Studio.open(@production_path)
+        Context.instance.studio.publish_on_drb(@drb_port.to_i) if @drb_port
+        Context.instance.studio.open(@production_path)
       end
 
     end

data/lib/limelight/java_couplings.rb

@@ -6,6 +6,7 @@ module Limelight #:nodoc:
   Main = Java::limelight.Main
   ResourceLoader = Java::limelight.ResourceLoader
   Context = Java::limelight.Context
+  Studio = Java::limelight.ui.api.Studio
 
   module Background
     Animation = Java::limelight.background.Animation
@@ -49,7 +50,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
+      Production = Java::limelight.ui.api.Production
     end
 
     module Painting #:nodoc:

data/lib/limelight/limelight_init.rb

@@ -0,0 +1,12 @@
+#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+$LIMELIGHT_LIB = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$: << $LIMELIGHT_LIB unless $:.include?($LIMELIGHT_LIB)
+$LIMELIGHT_HOME = File.expand_path(File.join($LIMELIGHT_LIB, ".."))
+
+if Java::java.lang.System.getProperty("limelight.home").nil?
+  Java::java.lang.System.setProperty("limelight.home", $LIMELIGHT_HOME)
+end
+
+require 'limelight/java_couplings'

data/lib/limelight/producer.rb

@@ -23,15 +23,27 @@ module Limelight
   #
   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
+    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
 
@@ -50,7 +62,7 @@ module Limelight
         root_path = unpack_production(root_path)
       end
       @production = production || Production.new(root_path)
-      @theater = theater.nil? ? Theater.new : theater
+      @theater = theater.nil? ? Theater.new(@production) : theater
       establish_production
     end
 
@@ -77,15 +89,23 @@ module Limelight
       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 = {})
-      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|          
+        @theater.stages.each do |stage|
           open_scene(stage.default_scene.to_s, stage) if stage.default_scene
         end
       elsif @production.default_scene
@@ -144,7 +164,7 @@ module Limelight
     # 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)
+      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)

data/lib/limelight/production.rb

@@ -3,7 +3,6 @@
 
 require 'limelight/limelight_exception'
 require 'limelight/file_loader'
-require 'limelight/studio'
 require 'drb'
 
 module Limelight
@@ -15,6 +14,8 @@ module Limelight
   #
   class Production
 
+    include UI::Api::Production
+
     class << self
 
       def [](name) #:nodoc:
@@ -26,6 +27,7 @@ module Limelight
     attr_reader :name, :root
     attr_accessor :producer, :theater
 
+
     # Users typically need not create Production objects.
     #
     def initialize(path)
@@ -36,7 +38,7 @@ module Limelight
     # 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)
+      Context.instance.studio.error_if_duplicate_name(value)
       @name = value
     end
 
@@ -138,9 +140,19 @@ module Limelight
     # Closes the production. If there are no more productions open, the Limelight runtime will shutdown.
     #
     def close
+      return if @closed
       self.production_closing
-      Studio.production_closed(self)
+      @theater.close
+      @closed = true
       self.production_closed
+      Context.instance.studio.production_closed(self)
+    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?
     end
 
     # Returned the name of the default scene.  This is only used when there are not stages defined in the production.
@@ -164,6 +176,14 @@ module Limelight
       return @root_styles
     end
 
+    alias :getName :name #:nodoc:
+    alias :setName :name= #:nodoc:
+    alias :allowClose :allow_close? #:nodoc: 
+
+    def callMethod(name, args) #:nodoc:   
+      send(name.to_sym, *args)
+    end
+
   end
 
 end

data/lib/limelight/scene.rb

@@ -88,7 +88,7 @@ module Limelight
     # Creates a new Producer to open the specified Production.
     #
     def open_production(production_path)
-      Thread.new { Studio.open(production_path) }
+      Thread.new { Context.instance.studio.open(production_path) }
     end
 
     # Opens the specified Scene on the Stage currently occupied by this Scene.

data/lib/limelight/specs/spec_helper.rb

@@ -34,7 +34,7 @@ module Spec
         uses_limelight({:scene => scene_name}.merge(options))
       end
       
-      def self.uses_limelight(options, &prop_block)
+      def self.uses_limelight(options = {}, &prop_block)
         include Limelight::Specs::SpecHelper
         
         before(:each) do

data/lib/limelight/stage.rb

@@ -186,6 +186,7 @@ module Limelight
     # See load_scene
     #
     def open(scene)
+      @current_scene.visible = false if @current_scene
       scene.stage = self
       scene.illuminate
       load_scene(scene)
@@ -197,16 +198,22 @@ module Limelight
     # Closes the Stage. It's window will no longer be displayed on the screen.
     #
     def close
-      @theater.stage_closed(self)
       @frame.close
+      closed
+    end
+
+    # Invoked when the stage has been closed.  Users need not call it. 
+    #
+    def closed
       @current_scene.visible = false if @current_scene
       @current_scene = nil
+      @theater.stage_closed(self)
     end
 
     # Loads a scene on the Stage.  If the Stage is currently hosting a Scene, the original Scene will be removed and
     # the new Scene will replace it.
     #
-    def load_scene(scene)
+    def load_scene(scene)      
       #      @frame.setJMenuBar(scene.menu_bar)
       @frame.load(scene.panel)
       if (has_static_size?(scene.style))
@@ -233,7 +240,7 @@ module Limelight
     def alert(message)
       Thread.new do
         begin
-          Studio.utilities_production.alert(message)
+          Context.instance.studio.utilities_production.alert(message)
         rescue StandardError => e
           puts "Error on alert: #{e}"
         end

data/lib/limelight/studio.rb

@@ -10,12 +10,11 @@ module Limelight
   #
   class Studio
 
-    include Limelight::UI::Api::Studio
-
     class << self
 
       def install #:nodoc:
         Context.instance.studio = instance
+        return instance
       end
 
       def instance #:nodoc:
@@ -23,163 +22,164 @@ module Limelight
         return @studio
       end
 
-      def index(production) #:nodoc:
-        @index = [] if @index.nil?
-        if name_taken?(production.name)
-          assign_unique_name(production)
-        elsif production.name.nil?
-          assign_name_to(production)
-        else
-          error_if_duplicate_name(production.name)
-        end
-        @index << production
-      end
-
-      # Returns the production with the specified name that was previously opened but the Studio.
-      #
-      def [](name)
-        return nil if @index.nil?
-        return @index.find { |production| production.name == name }
-      end
-
-      def name_taken?(name) #:nodoc:
-        return self[name] != nil
-      end
-
       def reset #:nodoc:
-        @index = []
-        @is_shutdown = false
-        @is_shutting_down = false
         @studio = nil
       end
 
-      def error_if_duplicate_name(name) #:nodoc:
-        raise Limelight::LimelightException.new("Production name '#{name}' is already taken") if name_taken?(name)
-      end
+    end
 
-      # Opens the production at the specified path.
-      #
-      def open(production_path)        
-        begin
-          producer = Producer.new(production_path)
-          production = producer.production
-          index(production)
-          producer.open
-          return production
-        rescue StandardError => e
-          alert_and_shutdown(e)
-        end
+    def index(production) #:nodoc:
+      @index = [] if @index.nil?
+      if name_taken?(production.name)
+        assign_unique_name(production)
+      elsif production.name.nil?
+        assign_name_to(production)
+      else
+        error_if_duplicate_name(production.name)
       end
+      @index << production
+    end
 
-      # Returns true if all of the open productions allow closing.
-      #
-      def should_allow_shutdown
-        return true if @index.nil?
-        return @index.all? { |production| production.allow_close? }
-      end
+    # Returns the production with the specified name that was previously opened but the Studio.
+    #
+    def [](name)
+      return nil if @index.nil?
+      return @index.find { |production| production.name == name }
+    end
 
-      # If allowed (should_allow_shutdown), this will close all open productions and shutdown the limelight runtime.
-      #
-      def shutdown
-        return if @is_shutdown || @is_shutting_down
-        return unless should_allow_shutdown
-        @is_shutting_down = true
-        @index.each { |production| production.close } if @index
-        @utilities_production.close if @utilities_production
-        @is_shutdown = true
-        Thread.new { Context.instance().shutdown }
-      end
+    def name_taken?(name) #:nodoc:
+      return self[name] != nil
+    end
 
-      # Called when a production is closed to notify the studio of the event.
-      #
-      def production_closed(production)
-        @index.delete(production) if @index
-        shutdown if @index && @index.empty?
-      end
+    def error_if_duplicate_name(name) #:nodoc:
+      raise Limelight::LimelightException.new("Production name '#{name}' is already taken") if name_taken?(name)
+    end
 
-      # Returns an array of all the productions
-      #
-      def productions
-        return @index.nil? ? [] : @index.dup
+    # Opens the production at the specified path.
+    #
+    def open(production_path)
+      begin
+        src = <<END
+#begin
+  puts "$:: \#{$:.join(", ")}"
+  puts "__FILE__: \#{__FILE__}"
+  require 'limelight/limelight_init'
+  require 'limelight/producer'
+  producer = Limelight::Producer.new("#{production_path}")
+  production = producer.production
+  Java::java.lang.Thread.currentThread.handle = production
+  producer.open
+#rescue Exception => e
+#  raise e
+#end
+END
+        production = Context.instance().runtimeFactory.spawn(src)
+        index(production)
+        return production
+      rescue StandardError => e
+        alert_and_shutdown(e)
       end
+    end
 
-      # Publish the Studio, using DRb, on the specified port.
-      #
-      def publish_on_drb(port)
-        @drb_server = DRb.start_service("druby://0.0.0.0:#{port}", self)
-      end
+#      def open(production_path)
+#        begin
+#          producer = Producer.new(production_path)
+#          production = producer.production
+#          index(production)
+#          producer.open
+#          return production
+#        rescue StandardError => e
+#          alert_and_shutdown(e)
+#        end
+#      end
+
+    # Returns true if all of the open productions allow closing.
+    #
+    def should_allow_shutdown
+      return true if @index.nil?
+      return @index.all? { |production| production.allow_close? }
+    end
 
-      # Returns the utilities production; a production used by limelight.
-      #
-      def utilities_production
-        if @utilities_production == nil
-          producer = Producer.new(File.join($LIMELIGHT_LIB, "limelight", "builtin", "utilities_production"))
-          @utilities_production = producer.production
-          producer.open
-        end
-        return @utilities_production
-      end
+    # If allowed (should_allow_shutdown), this will close all open productions and shutdown the limelight runtime.
+    #
+    def shutdown
+      return if @is_shutdown || @is_shutting_down
+      return unless should_allow_shutdown
+      @is_shutting_down = true
+      @index.each { |production| production.close } if @index
+      @utilities_production.close if @utilities_production
+      @is_shutdown = true
+      Thread.new { Context.instance().shutdown }
+    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
+    # Called when a production is closed to notify the studio of the event.
+    #
+    def production_closed(production)
+      puts "Studio.production_closed @index: #{@index}"
+      if @index
+        @index.delete(production)
+        puts "closing production: #{production}"
+production.audit        
+        Context.instance().runtimeFactory.terminate(production)
+puts "index.inspect: #{@index.inspect}"        
+      end
+      shutdown if @index && @index.empty?
+    end
 
-      private #############################################
+    # Returns an array of all the productions
+    #
+    def productions
+      return @index.nil? ? [] : @index.dup
+    end
 
-      def assign_unique_name(production) #:nodoc:
-        count = 2
-        name = production.name
-        while name_taken?(name)
-          name = "#{production.name}_#{count}"
-          count += 1
-        end
-        production.name = name
-      end
+    # Publish the Studio, using DRb, on the specified port.
+    #
+    def publish_on_drb(port)
+      @drb_server = DRb.start_service("druby://0.0.0.0:#{port}", self)
+    end
 
-      def assign_name_to(production) #:nodoc:
-        count = @index.length + 1
-        while name_taken?(count.to_s)
-          count += 1
-        end
-        production.name = count.to_s
+    # Returns the utilities production; a production used by limelight.
+    #
+    def utilities_production
+      if @utilities_production == nil
+        producer = Producer.new(File.join($LIMELIGHT_LIB, "limelight", "builtin", "utilities_production"))
+        @utilities_production = producer.production
+        producer.open
       end
+      return @utilities_production
+    end
 
-      def alert_and_shutdown(e)
-        begin
-          message = "#{e}\n#{e.backtrace.join("\n")}"
-          utilities_production.alert(message)
-          shutdown if @index.nil? || @index.empty?
-        rescue Exception => e
-          puts e
-          puts e.backtrace
-        end
-      end
+    private #############################################
 
+    def assign_unique_name(production) #:nodoc:
+      count = 2
+      name = production.name
+      while name_taken?(name)
+        name = "#{production.name}_#{count}"
+        count += 1
+      end
+      production.name = name
     end
 
-    # Same as the class level method.
-    #
-    def open(production_path)
-      self.class.open(production_path)
+    def assign_name_to(production) #:nodoc:
+      count = @index.length + 1
+      while name_taken?(count.to_s)
+        count += 1
+      end
+      production.name = count.to_s
     end
 
-    # Same as the class level method.
-    #
-    def should_allow_shutdown
-      return self.class.should_allow_shutdown
+    def alert_and_shutdown(e)
+      begin
+        message = "#{e}\n#{e.backtrace.join("\n")}"
+        utilities_production.alert(message)
+        shutdown if @index.nil? || @index.empty?
+      rescue Exception => e
+        puts e
+        puts e.backtrace
+      end
     end
 
-    # Same as the class level method.
-    #
-    def shutdown
-      self.class.shutdown()
-    end
   end
 
 end