limelight 0.3.1-java → 0.4.0-java

data/lib/limelight/specs/spec_helper.rb

@@ -1,58 +1,85 @@
+#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
 require 'spec'
 require File.expand_path(File.dirname(__FILE__) + "/../../init")
 require 'limelight/scene'
 require 'limelight/producer'
 
-$producer = nil
-$with_ui = true
+module Limelight
+  module Specs
+
+    class << self
+      attr_accessor :producer
+    end
+
+    module SpecHelper
+
+      def open_scene
+        if @ll_spec_options[:stage]
+          stage = producer.theater[@ll_spec_options[:stage]]
+          raise "No such stage: '#{@ll_spec_options[:stage]}'" unless stage
+        else
+          stage = producer.theater.default_stage
+        end
+
+        stage.should_remain_hidden = @ll_spec_options[:hidden]
+
+        @scene = producer.open_scene(@scene_name.to_s, stage)
+      end
+
+      def scene
+        open_scene unless @scene
+        return @scene
+      end
+
+    end
+  end
+end
 
 module Spec
   module Example
     class ExampleGroup
 
-      def self.uses_scene(scene_name)
+      def self.uses_scene(scene_name, options = {})
+        include Limelight::Specs::SpecHelper
+
         before(:each) do
-          @scene = producer.open_scene(scene_name.to_s, producer.theater["default"])
+          @scene_name = scene_name
+          @ll_spec_options = options
+          @scene = nil
         end
-
-        attr_reader :scene
       end
 
       after(:suite) do
-        $producer.theater.stages.each { |stage| stage.close } unless $producer.nil?
+        unless Limelight::Specs.producer.nil?
+          Limelight::Specs.producer.theater.stages.each do |stage|
+            # MDM - We do this in a round-about way to reduce the chance of using stubbed or mocked methods.
+            frame = stage.instance_variable_get("@frame")
+            frame.close if frame
+          end
+        end
       end
 
       def producer
-        if $producer.nil?
+        if Limelight::Specs.producer.nil?
           if $with_ui
             Limelight::Main.initializeContext
           else
             Limelight::Main.initializeTestContext
           end
-          $producer = Limelight::Producer.new($PRODUCTION_PATH)
-          $producer.load
+          raise "$PRODUCTION_PATH undefined.  Make sure you specify the location of the production in $PRODUCTION_PATH." unless defined?($PRODUCTION_PATH)
+          raise "Could not find production: '#{$PRODUCTION_PATH}'. Check $PRODUCTION_PATH." unless File.exists?($PRODUCTION_PATH)
+          Limelight::Specs.producer = Limelight::Producer.new($PRODUCTION_PATH)
+          Limelight::Specs.producer.load
         end
-        return $producer
+        return Limelight::Specs.producer
       end
 
-    end
-  end
-end
-
-if !$with_ui
-  module Limelight
-    module UI
-      module Model
-
-        class Frame
-
-          def open
-
-          end
-
-        end
-
+      def production
+        return producer.production
       end
+
     end
   end
 end

data/lib/limelight/stage.rb

@@ -1,7 +1,7 @@
-#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- 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/dsl/menu_bar'
+#require 'limelight/dsl/menu_bar'
 require 'limelight/file_chooser'
 require 'limelight/util'
 
@@ -15,17 +15,20 @@ module Limelight
   class Stage
     attr_accessor :default_scene
     attr_reader :frame, :current_scene, :name, :theater
-    
+
+    attr_accessor :should_remain_hidden #:nodoc:
+
     include UI::Api::Stage
 
     # To create a new Stage, it be given a Theater to which it belongs, and the name is optional.  If no name is provided
     # it will default to 'default'.  A stage name must be unique, so it is recommended you provide a name.
     #
-    def initialize(theater, name="default")
+    def initialize(theater, name, options = {})
       @theater = theater
       @name = name
       build_frame
       self.title = @name
+      apply_options(options)
     end
 
     # Returns the title that is displayed at the top of the window that this stage represents.
@@ -40,36 +43,142 @@ module Limelight
       @frame.title = value
     end
 
-    # Returns the width and height of the Stage.
+    # Returns the width and height styles of the Stage.
     #
     #   width, height = stage.size
     #
     def size
-      return @frame.width, @frame.height
+      return @frame.width_style.to_s, @frame.height_style.to_s
     end
 
-    # Sets the width and height of the Stage. The dimensions are passed in as an array.
+    # Sets the width and height styles of the Stage.
     #
     #   state.size = [100, 200]
+    #   state.size = ["50%", "100%"] # consuming 50% of the width and 100% of the height of the screen
     #
-    def size=(values)
-      @frame.set_size(values[0], values[1])
+    def size=(*values)
+      values = values[0] if values.size == 1 && values[0].is_a?(Array)
+      @frame.set_size_styles(values[0], values[1])
     end
 
-    # The location of the Stage on the screen.
+    # The location styles of the Stage.
     #
     #   x, y = stage.location
     #
     def location
-      return @frame.location.x, @frame.location.y
+      return @frame.getXLocationStyle.to_s, @frame.getYLocationStyle.to_s
     end
 
-    # Sets the location of the Stage on the screen.
+    # Sets the location styles of the Stage.
     #
     #   stage.location = [500, 200]
     #
-    def location= values
-      @frame.set_location(values[0], values[1])
+    def location=(*values)
+      values = values[0] if values.size == 1 && values[0].is_a?(Array)
+      @frame.set_location_styles(values[0], values[1])
+    end
+
+    # Turns fullscreen mode on and off.  In fullscreen mode, the stage will fill the entire screen and appear on top
+    # of all other windows.
+    #
+    #   stage.fullscreen = true
+    #
+
+    def fullscreen=(on)
+      @frame.setFullScreen(on)
+    end
+
+    # Returns true if the stage is in fullscreen mode.
+    #
+    def fullscreen?
+      return @frame.isFullScreen()
+    end
+
+    # Turns kiosk mode for this stage on and off.  When on, the stage will:
+    #   * be fullscreen
+    #   * not be frames
+    #   * disable OS key commands
+    #     * OS X: Cmd-Tab, Cmd-Alt-Esc, etc...
+    #     * Windows: Alt-Tab, Ctrl-Esc, etc... (Ctrl-Alt-Del must be disabled through a registry entry)
+    #
+    #   stage.kiosk = true
+    #
+    def kiosk=(on)
+      @frame.setKiosk(on)
+    end
+
+    # Return true if the stage is in kiosk mode.
+    #
+    def kiosk?
+      return @frame.isKiosk()
+    end
+
+
+    # Hides the stage so that it is not visible on the screen without destroying it.
+    #
+    def hide
+      @frame.visible = false
+    end
+
+    # Shows the stage after having hiding it.
+    #
+    def show
+      @frame.visible = true unless @should_remain_hidden
+    end
+
+    # Returns true if the stage is visible on the screen.
+    #
+    def visible?
+      return @frame.visible
+    end
+
+    # Sets the background color of the stage
+    #
+    def background_color=(value)
+      @frame.background_color = value.to_s
+    end
+
+    # Returns the background color of the stage in the format #RRGGBB(AA)
+    #
+    def background_color
+      return @frame.background_color
+    end
+
+    # When true, the stage will be frame with the operating system's standard window frame including close, minimize,
+    # and maximize buttons
+    #
+    def framed=(value)
+      @frame.setUndecorated(!value)
+    end
+
+    # Return true if the stage is framed.
+    #
+    def framed?
+      return !@frame.isUndecorated()
+    end
+
+    # When true, the stage will remain on top of all other windows.
+    #
+    def always_on_top=(value)
+      @frame.always_on_top = value
+    end
+
+    # Return true if the stage has been set to always be on top.
+    #
+    def always_on_top?
+      return @frame.always_on_top
+    end
+
+    # Sets the vitality of the stage.  Limelight will not exit while vital frames remain visible.
+    #
+    def vital=(value)
+      @frame.vital = value
+    end
+
+    # Returns true if this is a vital stage.  Limelight will not exit while vital frames remain visible.
+    #
+    def vital?
+      return @frame.vital?
     end
 
     # Opens the Stage and loads the provided Scene.
@@ -77,9 +186,10 @@ module Limelight
     # See load_scene
     #
     def open(scene)
+      scene.stage = self
       scene.illuminate
       load_scene(scene)
-      @frame.open
+      @frame.open unless @should_remain_hidden
       scene.visible = true
       scene.scene_opened(self)
     end
@@ -87,18 +197,19 @@ module Limelight
     # Closes the Stage. It's window will no longer be displayed on the screen.
     #
     def close
+      @theater.stage_closed(self)
       @frame.close
+      @current_scene.visible = false if @current_scene
+      @current_scene = nil
     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)
-      @frame.setJMenuBar(scene.menu_bar)
+      #      @frame.setJMenuBar(scene.menu_bar)
       @frame.load(scene.panel)
-      scene.stage = self
-#      scene.panel.snap_to_size  # What's this for?
-      if(has_static_size?(scene.style))
+      if (has_static_size?(scene.style))
         @frame.set_size(scene.style.compiled_width.value + @frame.getHorizontalInsetWidth, scene.style.compiled_height.value + @frame.getVerticalInsetWidth)
       end
       @current_scene = scene
@@ -120,7 +231,27 @@ module Limelight
     # Pops up a simple modal dialog with the provided message.
     #
     def alert(message)
-      frame.alert(message)
+      Thread.new do
+        begin
+          Studio.utilities_production.alert(message)
+        rescue StandardError => e
+          puts "Error on alert: #{e}"
+        end
+      end
+    end
+
+    # Called when the user or system would like to close the stage.  The stage will return true, allowing it to be
+    # closed, unless the current_scene defines the allow_close? method in which case the decision it left up to the
+    # current_scene.  
+    #
+    def should_allow_close
+      return true if @current_scene.nil?
+      return true if !@current_scene.respond_to?(:allow_close?)
+      return @current_scene.allow_close?
+    end
+
+    def stub_current_scene(scene) #:nodoc:
+      @current_scene = scene
     end
 
     protected #############################################
@@ -130,7 +261,7 @@ module Limelight
     end
 
     private ###############################################
-    
+
     def build_frame
       @frame = new_frame
       @frame.set_size(800, 800)
@@ -145,8 +276,17 @@ module Limelight
     def is_static?(value)
       return !(value.to_s.include?("%")) && !(value.to_s == "auto")
     end
-    
+
+    def apply_options(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)    
+        end
+      end
+    end
+
   end
-    
+
 end
 

data/lib/limelight/string.rb

@@ -1,3 +1,6 @@
+#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
 class String
 
   # Converts Ruby style names to Java style camal case.

data/lib/limelight/studio.rb

@@ -1,29 +1,166 @@
+#- 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/producer'
 
 module Limelight
 
+  # A Studio creates Productions.  There is only one instance of Studio per Limelight runtime.  All open productions
+  # are opened by the studio.
+  #
   class Studio
 
     include Limelight::UI::Api::Studio
 
     class << self
 
-      def install
-        Context.instance.studio = instance  
+      def install #:nodoc:
+        Context.instance.studio = instance
       end
 
-      def instance
+      def instance #:nodoc:
         @studio = self.new if @studio.nil?
         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
+
+      # 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 Exception => e
+          # TODO MDM - open the error in a window
+          puts e
+          puts e.backtrace
+        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
+
+      # 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 }
+        @utilities_production.close if @utilities_production
+        @is_shutdown = true
+        Thread.new { Context.instance().shutdown }
+      end
+
+      # Called when a production is closed to notify the studio of the event.
+      #
+      def production_closed(production)
+        @index.delete(production)
+        shutdown if(@index.empty?)
+      end
+
+      # Returns an array of all the productions
+      #
+      def productions
+        return @index.nil? ? [] : @index.dup
+      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
+
+      # 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
+
+      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
+
+      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
+
+    end
+
+    # Same as the class level method.
+    #
+    def open(production_path)
+      self.class.open(production_path)
     end
 
-    def open(production)
-      producer = Producer.new(production)
-      producer.open
+    # Same as the class level method.
+    #
+    def should_allow_shutdown
+      return self.class.should_allow_shutdown
     end
 
+    # Same as the class level method.
+    #
+    def shutdown
+      self.class.shutdown()
+    end
   end
 
 end

data/lib/limelight/styles.rb

@@ -1,4 +1,4 @@
-#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- 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
@@ -329,6 +329,19 @@ module Limelight
     #   style.y = <value>
     #
     Y  = Limelight::Styles::Style::STYLE_LIST.get(53)
+
+    # Specifies the starting X coordinate of background images.
+    #
+    #   style.background_image_x = <value>
+    #
+    BackgroundImageX  = Limelight::Styles::Style::STYLE_LIST.get(54)
+
+    # Specifies the Y of a prop.
+    #
+    #   style.background_images_y = <value>
+    #
+    BackgroundImageY  = Limelight::Styles::Style::STYLE_LIST.get(55)
+    
   end
 
 end

data/lib/limelight/templates/production_templater.rb

@@ -1,5 +1,9 @@
+#- 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/templates/templater'
 require 'limelight/string'
+require 'limelight/version'
 
 module Limelight
   module Templates
@@ -9,7 +13,6 @@ module Limelight
     #
     #    creating directory:  ./love_story
     #    creating file:       ./love_story/production.rb
-    #    creating file:       ./love_story/init.rb
     #    creating file:       ./love_story/stages.rb
     #    creating file:       ./love_story/styles.rb
     #
@@ -25,15 +28,16 @@ module Limelight
         @tokens = {}
         @tokens[:DEFAULT_SCENE_NAME] = default_scene_name
         @tokens[:PRODUCTION_NAME] = File.basename(production_path).titleized
+        @tokens[:CURRENT_VERSION] = Limelight::VERSION::STRING
       end
 
       # Generates the files
       #
       def generate
         file(File.join(@production_path, "production.rb"), "production/production.rb.template", @tokens)
-        file(File.join(@production_path, "init.rb"), "production/init.rb.template", @tokens)
         file(File.join(@production_path, "stages.rb"), "production/stages.rb.template", @tokens)
         file(File.join(@production_path, "styles.rb"), "production/styles.rb.template", @tokens)
+        file(File.join(@production_path, "spec", "spec_helper.rb"), "production/spec/spec_helper.rb.template", @tokens)
       end
 
     end

data/lib/limelight/templates/scene_templater.rb

@@ -1,3 +1,6 @@
+#- 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/templates/templater'
 require 'limelight/string'
 
@@ -18,21 +21,23 @@ module Limelight
 
       # The scene_path should be path to a desired scene inside a production directory.
       #
-      def initialize(scene_path)
-        super(File.dirname(scene_path), Templater.source_dir)
-        @scene_path = File.basename(scene_path)
-        scene_name = File.basename(scene_path)
+      def initialize(production_path, scene_path)
+        super(production_path, Templater.source_dir)
+        @production_path = production_path
+        @scene_path = scene_path
+        @scene_name = File.basename(scene_path)
         @tokens = {}
-        @tokens[:SCENE_NAME] = scene_name
-        @tokens[:SCENE_TITLE] = scene_name.titleized
+        @tokens[:SCENE_NAME] = @scene_name
+        @tokens[:SCENE_TITLE] = @scene_name.titleized
       end
 
-      # Generated the files
+      # Generates the files
       #
       def generate
         file(File.join(@scene_path, "props.rb"), "scene/props.rb.template", @tokens)
         file(File.join(@scene_path, "styles.rb"), "scene/styles.rb.template", @tokens)
         directory(File.join(@scene_path, "players"))
+        file(File.join("spec", @scene_path, "#{@scene_name}_spec.rb"), "scene_spec/scene_spec.rb.template", @tokens)
       end
 
     end