epall-limelight 0.5.0-java

data/lib/limelight/dsl/menu_bar.rb

@@ -0,0 +1,71 @@
+#- 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
+
+  module DSL
+
+    class AnonymousActionListener #:nodoc:
+      include java.awt.event.ActionListener
+
+      def initialize(context, symbol)
+        @context = context
+        @symbol = symbol
+      end
+
+      def actionPerformed(e)
+        method = @context.method(@symbol)
+        method.call
+      end
+    end
+
+    # A class used to build menu bars using a DSL.
+    #
+    #  MenuBar.build(self) do
+    #    menu("File") do
+    #      item("Open", :open_chosen_scene)
+    #      item("Refresh", :reload)
+    #    end
+    #  end
+    #
+    # This example created one menu named 'File' with two menu items: 'Open' and 'Refresh'. The seconds parameter of the
+    # menu items is the symbol of a method on the context that will be invoked when the menu item is selected.
+    #
+    class MenuBar
+
+      def self.build(context, &prop)
+        builder = self.new(context)
+        builder.instance_eval(&prop)
+        return builder.menu_bar
+      end
+
+      attr_reader :menu_bar
+
+      # This builder must be provided with a context.  All menu item actions will be invoked on the context.
+      #
+      def initialize(context)
+        @context = context
+        @menu_bar = javax.swing.JMenuBar.new
+      end
+
+      # Creates a new menu with the provided name
+      #
+      def menu(name)
+        @menu = javax.swing.JMenu.new(name)
+        @menu_bar.add(@menu)
+        yield
+      end
+
+      # Created a new menu item with the provided name.  The symbols paramter is the name of a method on the context
+      # that will be invoked when the item is selected.
+      #
+      def item(name, symbol)
+        menu_item = javax.swing.JMenuItem.new(name)
+        @menu.add(menu_item)
+        menu_item.addActionListener(AnonymousActionListener.new(@context, symbol))
+      end
+
+    end
+    
+  end
+end

data/lib/limelight/dsl/prop_builder.rb

@@ -0,0 +1,155 @@
+#- 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/prop'
+require 'limelight/scene'
+require 'limelight/dsl/build_exception'
+require 'limelight/util'
+
+module Limelight
+
+  # A trigger to build a Limelight::Scene using the PropBuilder DSL.
+  #
+  # See Limelight::PropBuilder
+  #
+  def self.build_props(root, options={}, &block)
+    loader = options.delete(:build_loader)
+    instance_variables = options.delete(:instance_variables)
+    root.add_options(options)
+    builder = DSL::PropBuilder.new(root)
+    builder.__install_instance_variables(instance_variables)
+    builder.__loader__ = loader
+    builder.instance_eval(&block) if block
+    return root
+  end
+
+  module DSL
+
+    # The basis of the DSL for building Limelight::Prop objects.
+    #
+    # Sample usage:
+    #
+    #   builder = Limelight::PropBuilder.new(a_prop)
+    #   builder.instance_eval(&block)
+    #
+    # The prop passed into the constructor will be the root of the contructed Prop tree.
+    # The block passed into instance_eval contains the DSL for building props.
+    #
+    # Example block/DSL:
+    #
+    #   parent :id => "the_parent" do
+    #     child_one do
+    #       grand_child_one :id => "gc_1", :styles => "grand_child"
+    #       grand_child_two :id => "gc_2", :styles => "grand_child"
+    #     end
+    #     child_two
+    #   end
+    #
+    # The above example will create a Limelight::Prop named 'parent' and add it to the root prop passed into the builder.
+    # The 'parent' prop will contain two props named 'child_one' and 'child_two'.  'child_one' will contain two props named
+    # 'grand_child_one' and 'grand_child_two'.  'child_two' has no child props nor do 'grand_child_one' or 'grand_child_two'.
+    #
+    # An options Hash may be passed into each prop.  The key, value pairs in the hash will be used to set properties on the prop
+    # when it is added to a Limelight::Scene.
+    #
+    # See Limelight::Prop
+    #
+    class PropBuilder
+
+      alias :__instance_variables :instance_variables
+      alias :__instance_variable_get :instance_variable_get
+      alias :__instance_variable_set :instance_variable_set
+
+      Limelight::Util.lobotomize(self)
+
+      # Returns the root prop either passed in or created by this builder.
+      #
+      attr_reader :__prop__
+      attr_accessor :__loader__
+
+      # Creates a new builder.  If a prop is passed it, it will be the root on which props are created.
+      # If the paramter is a Hash, the Hash will be used to construct a prop that will be used as the root.
+      #
+      def initialize(options)
+        if options.is_a?(Prop)
+          @__prop__ = options
+        else
+          @__prop__ = Prop.new(options)
+        end
+      end
+
+      # Add extra initialization options to the prop currently under construction.
+      #
+      #   tree :id => "stump" do
+      #     __ :height => "100%", :width => "30", :background_color => :brown
+      #     branch :height => "100", :width => "20"
+      #     branch do
+      #       __ :height => "100", :width => "20"
+      #     end
+      #   end
+      #
+      # In the above example, the 'tree' prop has the following initialization options: id, height, width, background_color.
+      # The two 'branch' child props are identical.
+      #
+      def __(options)
+        @__prop__.add_options(options)
+      end
+
+      # Installs props from another file using the prop DSL.  The path will be relative to the
+      # root directory of the current production.
+      #
+      def __install(file, instance_variables = {})
+        raise "Cannot install external props because no loader was provided" if @__loader__.nil?
+        raise "External prop file: '#{file}' doesn't exist" if !@__loader__.exists?(file)
+        content = @__loader__.load(file)
+        begin
+          self.__install_instance_variables(instance_variables)
+          self.instance_eval(content)
+        rescue Exception => e
+          raise BuildException.new(file, content, e)
+        end
+      end
+
+      # Installs instance variables, specified by the passed hash, into the PropBuilder instance.
+      # The following call...
+      #
+      #   __install_instance_variables :one => "1", "two" => "two", :three => 3
+      #
+      # ...will result in the following instance variables.
+      #
+      #   @one   = "1"
+      #   @two   = "2"
+      #   @three = 3
+      #
+      # Instance variables are propogated to nested builders so that they need only be defined
+      # on the top level builder and all children will have access to them.
+      #
+      def __install_instance_variables(instance_variables)
+        return if instance_variables.nil?
+        instance_variables.each_pair do |key, value|
+          name = "@#{key}"
+          __instance_variable_set(name, value)
+        end
+      end
+
+      def __install_instance_variables_from_builder(source) #:nodoc:
+        source.__instance_variables.each do |name|
+          if !__instance_variable_get(name)
+            value = source.__instance_variable_get(name)
+            __instance_variable_set(name, value)
+          end
+        end
+      end
+
+      def method_missing(sym, options={}, &prop) # :nodoc:
+        options[:name] ||= sym.to_s
+        builder = PropBuilder.new(options)
+        builder.__install_instance_variables_from_builder(self)
+        builder.__loader__ = @__loader__
+        builder.instance_eval(&prop) if prop
+        @__prop__.add(builder.__prop__)
+      end
+    end
+
+  end
+end

data/lib/limelight/dsl/stage_builder.rb

@@ -0,0 +1,105 @@
+#- 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/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, *values)  #:nodoc:     
+        setter_sym = "#{sym}=".to_s
+        raise StageBuilderException.new(sym) if !@__stage__.respond_to?(setter_sym)
+        @__stage__.send(setter_sym, *values)
+      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,157 @@
+#- 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/util'
+
+module Limelight
+
+  # A trigger to define Style objects using the StyleBuilder DSL.
+  #
+  # See Limelight::Stylesbuilder, Limelight::Stylebuilder
+  #
+  def self.build_styles(extendable_styles = nil, &block)
+    builder = DSL::StylesBuilder.new(extendable_styles)
+    builder.instance_eval(&block) if block
+    return builder.__styles
+  end
+
+  def self.build_styles_from_file(filename, extendable_styles = nil)
+    content = IO.read(filename)
+    styles = Limelight.build_styles(extendable_styles) do
+      begin
+        eval content
+      rescue Exception => e
+        raise Limelight::DSL::BuildException.new(filename, content, e)
+      end
+    end
+    return 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, :__extendable_styles
+
+      def initialize(extendable_styles = nil)
+        @__extendable_styles = extendable_styles || {}
+        @__styles = {}
+      end
+
+      def method_missing(sym, &block) #:nodoc:
+        __add_style(sym.to_s, &block)
+      end
+
+      def __add_style(name, &block) #:nodoc:
+        style = @__styles[name]
+        if style == nil
+          style = Styles::RichStyle.new
+          extension = @__extendable_styles[name]
+          style.add_extension(extension) if extension
+        end
+        builder = StyleBuilder.new(name, style, self)
+        builder.instance_eval(&block) if block
+        @__styles[name] = 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, style, styles_builder, options = {})  #:nodoc:
+        @__name = name
+        @__style = style
+        @__styles_builder = styles_builder
+      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] || @__styles_builder.__extendable_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
+      def initialize(message)
+        super(message)
+      end
+    end
+
+  end
+end