limelight 0.5.5-java → 0.6.14-java

data/ruby/lib/limelight/specs/spec_helper.rb

@@ -0,0 +1,191 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+require 'rspec'
+require File.expand_path(File.dirname(__FILE__) + "/../limelight_init")
+require 'limelight/production'
+require 'limelight/scene'
+require 'limelight/string'
+require 'limelight/mouse'
+
+module Limelight
+
+  # Limelight comes with builtin assistance for testing your productions with rspec.
+  # See Limelight::Specs::SpecHelper
+  #
+  module Specs
+
+    class << self
+      attr_accessor :production
+    end
+
+    # Limelight comes with builtin assistance for testing your productions using RSpec. To get started, add the following
+    # to your describe block...
+    #
+    #   uses_limelight :scene => "my_scene"
+    #
+    # This will add before(:each) blocks that will setup your production and load your scene before each test.
+    # It also provides some accessors to common objects like the scene and production.  Afterwards, you can
+    # write tests that look like this.
+    #
+    #   it "does something with the scene" do
+    #     scene.name.should == "my_scene"
+    #     scene.find("title").text.should == "This is the Title"
+    #     production.theater["default_stage"].current_scene.should be(scene)
+    #   end
+    #
+    # There are several other options you can supply with 'uses_limelight':
+    #
+    # :hidden - (true or false) Defaults to true, but if you turn it off, the scene will pop open on your screen. This
+    # can be really nifty at times and really annoying at other time.
+    #
+    # :stage - The name of the stage you want the scene to be loaded on. The theater's default stage will be used by
+    # default.
+    #
+    # :scene_name - To be used instead of the :scene option.  This will create an empty scene in your production with
+    # the specified name.
+    #
+    # :scene_path - To be used in conjunction with :scene_name.  This will cause the empty scene to be loaded with
+    # the specified path.  Styles and Players associated with the path will be applied to the created scene.
+    #
+    # The 'uses_limelight' methods also accepts block using the Limelight::DSL::PropBuilder DSL.  This is convenient for building a
+    # simple prop structure sufficient to test the desired behavior.  Here's an example:
+    #
+    #   describe "my scene" do
+    #     uses_limelight :scene_name => "some_name", :scene_path => "my_scene_path" do
+    #       clicky :id => "clicky", :text => "click me", :on_mouse_clicked => "self.text = 'Hey! You clicked me!'"
+    #     end
+    #
+    #     it "should change text on clicky when clicked" do
+    #       scene.find("clicky").mouse_clicked(nil)
+    #       clicky.text.should == "Hey!  You clicked me!"
+    #     end
+    #   end
+    #
+    module SpecHelper
+
+      def production
+        if Limelight::Specs.production.nil?
+#          if $with_ui
+          Java::limelight.Boot.boot
+#          else
+#            Limelight::Main.initializeTestContext
+#          end
+          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.production = Limelight::Production.new(Java::limelight.ruby.RubyProduction.new($PRODUCTION_PATH))
+          Limelight::Specs.production.peer.illuminateProduction
+          Limelight::Specs.production.peer.loadProduction
+        end
+        Limelight::Specs.production
+      end
+
+      def mouse
+        @mouse ||= Limelight::Mouse.new
+        @mouse
+      end
+
+      def scene
+        if @scene.nil?
+          _setup_stage
+          if @ll_scene_id
+            @scene = production.open_scene(@ll_scene_id.to_s, :stage => @stage.name)
+          elsif @ll_scene_path
+            _setup_scene
+          end
+        end
+        @scene
+      end
+
+      private #############################################
+
+      def _init_ll_options(options)
+        @ll_scene_id = options[:scene]
+        @ll_scene_name = options[:scene_name]
+        @ll_scene_path = options[:scene_path]
+        @ll_stage_id = options[:stage]
+        @ll_hidden = options[:hidden]
+        @ll_player_names = options[:with_players]
+        _configure_player_helpers()
+      end
+
+      def _configure_player_helpers
+        if @ll_player_names
+          @ll_player_names = @ll_player_names.is_a?(Array) ? @ll_player_names : [@ll_player_names]
+          @ll_player_names = @ll_player_names.map { |n| n.to_s }
+          @ll_player_names.each do |player_name|
+            eval "def #{player_name}; scene.find('#{player_name}'); end;"
+          end
+        end
+      end
+
+      def _create_player_helpers
+        player_names = @ll_player_names
+        Limelight.build_props(@scene, :build_loader => production.root) do
+          player_names.each do |player_name|
+            __test_prop :name =>player_name, :players => "#{player_name}", :id => "#{player_name}"
+          end
+        end
+      end
+
+      def _setup_scene
+        path = production.scene_directory(@ll_scene_path)
+        @scene = Scene.new(:production => production, :path => path, :name => @ll_scene_name)
+        _create_player_helpers
+        Limelight.build_props(@scene, :build_loader => production.root, &@prop_block) if @prop_block
+
+        production.load_styles(@scene, @production.styles)
+        @stage.scene = @scene
+        @stage.open
+      end
+
+      def _setup_stage
+        if @ll_stage_id
+          @stage = production.theater[@ll_stage_id]
+          raise "No such stage: '#{@ll_stage_id}'" unless @stage
+        else
+          @stage = production.theater.default_stage
+        end
+
+        Java::limelight.ui.model.StageFrame.hiddenMode = @ll_hidden || true
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.after(:suite) do
+    Java::limelight.Context.instance.killThreads
+    #if Limelight::Specs.production
+    #  Limelight::Specs.production.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
+    Java::java.awt.Window.getWindows.each do |window|
+      window.dispose
+    end
+  end
+end
+
+module RSpec
+  module Core
+    class ExampleGroup
+
+      def self.uses_limelight(options = {}, &prop_block)
+        include Limelight::Specs::SpecHelper
+
+        before(:all) do
+          _init_ll_options(options)
+          @prop_block = prop_block
+        end
+
+        before(:each) do
+          @player = @scene = nil
+        end
+      end
+
+    end
+  end
+end

data/ruby/lib/limelight/stage.rb

@@ -0,0 +1,268 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+#require 'limelight/dsl/menu_bar'
+require 'limelight/optionable'
+require 'limelight/file_chooser'
+require 'limelight/util'
+require 'limelight/util/hashes'
+
+module Limelight
+
+  # In the metephorical sense, a Stage is a platform which may hold a scene.  In a more, to-the-point sence, a Stage
+  # represents a window on the computer screen.  The Stage objects within a Production are configured by the StagesBuilder.
+  # By default a Production will have one Stage.  A Stage may open any number of Scenes but it may only have one current
+  # scene loaded at a time.
+  #
+  class Stage
+
+    include Java::limelight.model.api.StageProxy
+    include Optionable
+
+    attr_reader :peer
+
+    # 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, options = {})
+      @theater = theater
+      @peer = Java::limelight.ui.model.FramedStage.new(name, self)
+      @peer.apply_options(Util::Hashes.for_java(options))
+    end
+
+    # Returns the name of the scene that will be loaded on this stage by default
+    #
+    def default_scene_name
+      return @peer.default_scene_name
+    end
+
+    # Specifies the name of the scene that will be loaded on this stage by default
+    #
+    def default_scene_name=(value)
+      @peer.default_scene_name = value
+    end
+
+    # Returns the name of the stage
+    #
+    def name
+      return @peer.name
+    end
+
+    # Returns the title that is displayed at the top of the window that this stage represents.
+    #
+    def title
+      return @peer.title
+    end
+
+    # Sets the title that is displayed at the top of the window that this stage represents.
+    #
+    def title=(value)
+      @peer.title = value
+    end
+
+    # Returns the width and height styles of the Stage.
+    #
+    #   width, height = stage.size
+    #
+    def size
+      return @peer.width_style.to_s, @peer.height_style.to_s
+    end
+
+    # 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)
+      values = values[0] if values.size == 1 && values[0].is_a?(Array)
+      @peer.set_size_styles(values[0], values[1])
+    end
+
+    # The location styles of the Stage.
+    #
+    #   x, y = stage.location
+    #
+    def location
+      return @peer.getXLocationStyle.to_s, @peer.getYLocationStyle.to_s
+    end
+
+    # Sets the location styles of the Stage.
+    #
+    #   stage.location = [500, 200]
+    #
+    def location=(*values)
+      values = values[0] if values.size == 1 && values[0].is_a?(Array)
+      @peer.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)
+      @peer.setFullScreen(on)
+    end
+
+    # Returns true if the stage is in fullscreen mode.
+    #
+    def fullscreen?
+      return @peer.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)
+      @peer.setKiosk(on)
+    end
+
+    # Return true if the stage is in kiosk mode.
+    #
+    def kiosk?
+      return @peer.isKiosk()
+    end
+
+
+    # Hides the stage so that it is not visible on the screen without destroying it.
+    #
+    def hide
+      @peer.hide
+    end
+
+    # Shows the stage after having hiding it.
+    #
+    def show
+      @peer.show
+    end
+
+    # Returns true if the stage is visible on the screen.
+    #
+    def visible?
+      return @peer.visible
+    end
+
+    # Sets the background color of the stage
+    #
+    def background_color=(value)
+      @peer.background_color = value.to_s
+    end
+
+    # Returns the background color of the stage in the format #RRGGBB(AA)
+    #
+    def background_color
+      return @peer.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)
+      @peer.framed = value
+    end
+
+    # Return true if the stage is framed.
+    #
+    def framed?
+      return @peer.framed?
+    end
+
+    # When true, the stage will remain on top of all other windows.
+    #
+    def always_on_top=(value)
+      @peer.always_on_top = value
+    end
+
+    # Return true if the stage has been set to always be on top.
+    #
+    def always_on_top?
+      return @peer.always_on_top
+    end
+
+    # Sets the vitality of the stage.  Limelight will not exit while vital frames remain visible.
+    #
+    def vital=(value)
+      @peer.vital = value
+    end
+
+    # Returns true if this is a vital stage.  Limelight will not exit while vital frames remain visible.
+    #
+    def vital?
+      return @peer.vital?
+    end
+
+    # Loads the provided Scene.
+    #
+    # See load_scene
+    #
+    def scene=(scene)
+      @peer.scene = scene.peer
+    end
+
+    # Returns the scene currently open on the stage
+    #
+    def scene
+      return @peer.scene.proxy if @peer.scene
+    end
+
+    # Returns the theater that the stage belongs to.
+    #
+    def theater
+      return @peer.theater.proxy
+    end
+
+    # Opens the stage. Opened stages are visible on the screen.
+    #
+    def open
+      @peer.open
+    end
+
+    # Closes the Stage. It's window will no longer be displayed on the screen.
+    #
+    def close
+      @peer.close
+    end
+
+    # Pops up a simple modal dialog with the provided message.
+    #
+    def alert(message)
+      Thread.new do
+        begin
+          Context.instance.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 @peer.should_all_close
+    end
+
+    # returns true if the stage has been closed.  Closed stages may not be reopened.
+    #
+    def closed?
+      return @peer.closed?
+    end
+
+    def should_remain_hidden #:nodoc:
+      return @peer.should_remain_hidden
+    end
+
+    def should_remain_hidden=(value) #:nodoc:
+      @peer.should_remain_hidden = value
+    end
+  end
+
+end
+