sproutcore 1.5.0.pre.5 → 1.5.0.rc.1

data/vendor/chance/lib/chance/instance/javascript.rb

@@ -0,0 +1,19 @@
+module Chance
+  class Instance
+    module JavaScript
+      def javascript(opts)
+        # Currently, we only include the preload JavaScript
+        preload_javascript(opts)
+      end
+
+      # Generates the preload JavaScript
+      def preload_javascript(opts)
+        output = "if (typeof CHANCE_SLICES === 'undefined') var CHANCE_SLICES = [];"
+        output += "CHANCE_SLICES = CHANCE_SLICES.concat(["
+        output += @slices.map {|name, slice| "'" + slice[:css_name] + "'" }.join(",\n")
+        output += "]);"
+      end
+
+    end
+  end
+end

data/vendor/chance/lib/chance/instance/slicing.rb

@@ -0,0 +1,181 @@
+require "chance/perf"
+
+module Chance
+  class Instance
+    
+    # The Slicing module handles taking a collection of slice definitions to
+    # produce sliced images. It uses ChunkyPNG to perform the slicing, and
+    # stores the sliced image in the slice definition.
+    module Slicing
+      # performs the slicing indicated by each slice definition, and puts the resulting
+      # image in the slice definition's :image property.
+      #
+      # if x2 is supplied, this will assume it is a second pass to locate any @2x images
+      # and use them to replace the originals.
+      def slice_images(opts)
+        slices = @slices
+        output = ""
+
+        slices.each do |name, slice|
+          # If we modify the canvas, we'll place the modified canvas here.
+          # Otherwise, consumers will use slice[:file] [:canvas] or [:contents]
+          # to get the original data as needed.
+          slice[:canvas] = nil
+
+          # In any case, if there is one, we need to get the original file and canvas;
+          # this process also tells us if the slice is 2x, etc.
+          canvas = canvas_for slice, opts
+
+          # Check if a canvas is required
+          must_slice = (slice[:left] != 0 or slice[:right] != 0 or slice[:top] != 0 or slice[:bottom] != 0)
+          if must_slice or slice[:x2]
+            if canvas.nil?
+              throw "Chance could not load file '#{slice[:path]}'." +
+                    "If it is not a PNG, RMagick is required to slice or use @2x mode."
+            end
+
+            f = slice[:proportion]
+
+            # RMagick or ChunkyPNG? 'columns' is RMagick
+            if canvas.respond_to?('columns')
+              canvas_width = canvas.columns
+              canvas_height = canvas.rows
+            else
+              canvas_width = canvas.width
+              canvas_height = canvas.height
+            end
+
+            if must_slice
+              rect = nil
+
+              # The math that uses canvas_width and canvas_height needs to return numbers that,
+              # when multiplied by f, are valid. So, divide by f first.
+              rect = slice_rect(slice, canvas_width / f, canvas_height / f)
+
+              if not rect.nil?
+                slice[:canvas] = canvas.crop(rect[:left] * f, rect[:top] * f, rect[:width] * f, rect[:height] * f)
+                canvas_width = rect[:height] * f
+                canvas_height = rect[:width] * f
+              end
+            end
+
+            slice[:target_width] = canvas_width / f
+            slice[:target_height] = canvas_height / f
+          end
+
+        end
+      end
+
+      # Returns either a RMagick image or a ChunkyPNG canvas for a slice, as applicable.
+      # If not applicable, the :raw property on the passed slice will be set.
+      #
+      # Opts specify if x2, etc. is allowed.
+      def canvas_for(slice, opts)
+        file = file_for(slice, opts)
+        file[:canvas]
+      end
+
+      # Returns the file to use for the specified slice (might be either the
+      # normal one, or a @2x one)
+      #
+      # The slice's :file property will be set to the Chance file.
+      # If @2x, the :x2 flag on the slice is set to true.
+      # opts specify if x2, etc. is allowed.
+      def file_for(slice, opts)
+        path = slice[:path]
+
+        file = get_file(path)
+        slice[:x2] = false
+        slice[:proportion] = 1
+
+        # Check for x2 version if we are in x2 mode
+        if opts[:x2]
+          begin
+            path_2x = path[0..(-1 - File.extname(path).length)] + "@2x.png"
+
+            file = get_file(path_2x)
+            slice[:x2] = true
+            slice[:proportion] = 2
+          rescue
+          end
+        end
+
+        raise "File does not exist: " + slice[:path] unless file
+
+        slice[:file] = file
+        file
+      end
+
+      # Creates the final slice rectangle from the image width and height
+      # returns nil if no rectangle or if the slice is the full image
+      def slice_rect(slice, image_width, image_height)
+        left = slice[:left]
+        top = slice[:top]
+        bottom = slice[:bottom]
+        right = slice[:right]
+        width = slice[:width]
+        height = slice[:height]
+
+        rect = {}
+
+        if not left.nil?
+          rect[:left] = left
+
+          # in this case, it must be left+width or left+right, or left-to-end
+          if not right.nil?
+            rect[:width] = image_width - right - left
+          elsif not width.nil?
+            rect[:width] = width
+          else
+            # then this is left-to-end
+            rect[:width] = image_width - left
+          end
+        elsif not right.nil?
+          # in this case it must be right+width or right-to-end
+          if not width.nil?
+            rect[:left] = image_width - width - right
+            rect[:width] = width
+          else
+            rect[:left] = image_width - right
+            rect[:width] = right
+          end
+        else
+          rect[:left] = 0
+          rect[:width] = image_width
+        end
+
+        if not top.nil?
+          rect[:top] = top
+
+          # in this case, it must be top+height or top+bottom or top-to-bottom
+          if not bottom.nil?
+            rect[:height] = image_height - bottom - top
+          elsif not height.nil?
+            rect[:height] = height
+          else
+            rect[:height] = image_height - top
+          end
+        elsif not bottom.nil?
+          # in this case it must be bottom+height
+          if not height.nil?
+            rect[:top] = image_height - height - bottom
+            rect[:height] = height
+          else
+            rect[:top] = image_height - bottom
+            rect[:height] = bottom
+          end
+        else
+          rect[:top] = 0
+          rect[:height] = image_height
+        end
+
+        if rect[:left] == 0 and rect[:top] == 0 and rect[:width] == image_width and rect[:height] == image_height
+          return nil
+        end
+
+        return rect
+      end
+
+    end
+  end
+end

data/vendor/chance/lib/chance/instance/spriting.rb

@@ -0,0 +1,311 @@
+# Spriting support.
+#
+# The sprite method performs the spriting. It creates collections of
+# images to sprite and then calls layout_sprite and generate_sprite.
+#
+# The layout_sprite method arranges the slices, defining their positions
+# within the sprites.
+#
+# The generate_sprite method combines the slices into an image.
+module Chance
+
+  class Instance
+
+    # The Spriting module handles sorting slices into sprites, laying them
+    # out within the sprites, and generating the final sprite images.
+    module Spriting
+      # Performs the spriting process on all of the @slices, creating sprite
+      # images in the class's @sprites property and updating the individual slices 
+      # with a :sprite property containing the identifier of the sprite, and offset
+      # properties for the offsets within the image.
+      def generate_sprite_definitions(opts)
+        @sprites = {}
+
+        group_slices_into_sprites(opts)
+        @sprites.each do |key, sprite|
+          layout_slices_in_sprite sprite
+        end
+      end
+
+      # Determines the appropriate sprite for each slice, creating it if necessary,
+      # and puts the slice into that sprite. The appropriate sprite may differ based
+      # on the slice's repeat settings, for instance.
+      def group_slices_into_sprites(opts)
+        @slices.each do |key, slice|
+          sprite = sprite_for_slice(slice, opts)
+          sprite[:slices] << slice
+
+          @sprites[sprite[:name]] = sprite
+        end
+      end
+
+      # Returns the sprite to use for the given slice, creating the sprite if needed.
+      # The sprite could differ based on repeat settings or file type, for instance.
+      def sprite_for_slice(slice, opts)
+        sprite_name = sprite_name_for_slice(slice, opts)
+
+        get_sprite_named(sprite_name, opts.merge({
+          :horizontal_layout => slice[:repeat] == "repeat-y" ? true : false
+        }))
+
+        return @sprites[sprite_name]
+      end
+
+      # Creates a sprite definition with a given name and set of options
+      def get_sprite_named(sprite_name, opts)
+        if @sprites[sprite_name].nil?
+          @sprites[sprite_name] = {
+            :name => sprite_name,
+            :slices => [],
+            :has_generated => false,
+
+            # The sprite will use horizontal layout under repeat-y, where images
+            # must stretch all the way from the top to the bottom
+            :use_horizontal_layout => opts[:horizontal_layout]
+
+          }
+        end
+      end
+
+      # Determines the name of the sprite for the given slice. The sprite
+      # by this name may not exist yet.
+      def sprite_name_for_slice(slice, opts)
+        if slice[:repeat] == "repeat-both"
+          return slice[:path] + (opts[:x2] ? "@2x" : "")
+        end
+
+        return slice[:repeat] + (opts[:x2] ? "@2x" : "") + File.extname(slice[:path])
+      end
+
+      # Performs the layout operation, laying either up-to-down, or "
+      # (for repeat-y slices) left-to-right.
+      def layout_slices_in_sprite(sprite)
+        # The position is the position in the layout direction. In vertical mode
+        # (the usual) it is the Y position.
+        pos = 0
+
+        # The size is the current size of the sprite in the non-layout direction;
+        # for example, in the usual, vertical mode, the size is the width.
+        #
+        # Usually, this is computed as a simple max of itself and the width of any
+        # given slice. However, when repeating, the least common multiple is used,
+        # and the smallest item is stored as well.
+        size = 1
+        smallest_size = nil
+
+        is_horizontal = sprite[:use_horizontal_layout]
+
+        sprite[:slices].each do |slice|
+          # We must find a canvas either on the slice (if it was actually sliced),
+          # or on the slice's file. Otherwise, we're in big shit.
+          canvas = slice[:canvas] || slice[:file][:canvas]
+
+          # TODO: MAKE A BETTER ERROR.
+          unless canvas
+            throw "Could not sprite image " + slice[:path] + "; if it is not a PNG"
+          end
+
+          # RMagick has a different API than ChunkyPNG; we have to detect
+          # which one we are using, and use the correct API accordingly.
+          if canvas.respond_to?('columns')
+            slice_width = canvas.columns
+            slice_height = canvas.rows
+          else
+            slice_width = canvas.width
+            slice_height = canvas.height
+          end
+
+          slice_length = is_horizontal ? slice_width : slice_height
+          slice_size = is_horizontal ? slice_height : slice_width
+
+          # When repeating, we must use the least common multiple so that
+          # we can ensure the repeat pattern works even with multiple repeat
+          # sizes. However, we should take into account how much extra we are
+          # adding by tracking the smallest size item as well.
+          if slice[:repeat] != "no-repeat"
+            smallest_size = slice_size if smallest_size.nil?
+            smallest_size = [slice_size, smallest_size].min
+
+            size = size.lcm slice_size
+          else
+            size = [size, slice_size].max
+          end
+
+          # We have extras for manual tweaking of offsetx/y. We have to make sure there
+          # is padding for this (on either side)
+          #
+          # We have to add room for the minimum offset by adding to the end, and add
+          # room for the max by adding to the front. We only care about it in our
+          # layout direction. Otherwise, the slices are flush to the edge, so it won't
+          # matter.
+          if slice[:min_offset_x] < 0 and is_horizontal
+            slice_length -= slice[:min_offset_x]
+          elsif slice[:min_offset_y] < 0 and not is_horizontal
+            slice_length -= slice[:min_offset_y]
+          end
+
+          if slice[:max_offset_x] > 0 and is_horizontal
+            pos += slice[:max_offset_x]
+          elsif slice[:max_offset_y] > 0 and not is_horizontal
+            pos += slice[:max_offset_y]
+          end
+
+
+          slice[:sprite_slice_x] = is_horizontal ? pos : 0
+          slice[:sprite_slice_y] = is_horizontal ? 0 : pos
+          slice[:sprite_slice_width] = slice_width
+          slice[:sprite_slice_height] = slice_height
+
+          pos += slice_length
+        end
+
+        # TODO: USE A CONSTANT FOR THIS WARNING
+        smallest_size = size if smallest_size == nil
+        if size - smallest_size > 10
+          puts "WARNING: Used more than 10 extra rows or columns to accomdate repeating slices."
+          puts "Wasted up to " + (pos * size-smallest_size).to_s + " pixels"
+        end
+
+        sprite[:width] = is_horizontal ? pos : size
+        sprite[:height] = is_horizontal ? size : pos
+
+      end
+
+
+      # Generates the image for the specified sprite, putting it in the sprite's 
+      # :image property.
+      def generate_sprite(sprite)
+        canvas = canvas_for_sprite(sprite)
+        sprite[:canvas] = canvas
+
+        sprite[:slices].each do |slice|
+          x = slice[:sprite_slice_x]
+          y = slice[:sprite_slice_y]
+          width = slice[:sprite_slice_width]
+          height = slice[:sprite_slice_height]
+
+          # If it repeats, it needs to go edge-to-edge in one direction
+          if slice[:repeat] == 'repeat-y'
+            height = sprite[:height]
+          end
+
+          if slice[:repeat] == 'repeat-x'
+            width = sprite[:width]
+          end
+
+          compose_slice_on_canvas(canvas, slice, x, y, width, height)
+        end
+      end
+
+      def canvas_for_sprite(sprite)
+        width = sprite[:width]
+        height = sprite[:height]
+
+        # If we require RMagick, we should have already loaded it, so we don't
+        # need to worry over that at the moment.
+        if sprite[:name] =~ /\.(gif|jpg)/
+          return Magick::Image.new(width, height)
+        else
+          return ChunkyPNG::Image.new(width, height, ChunkyPNG::Color::TRANSPARENT)
+        end
+      end
+
+      # Writes a slice to the target canvas, repeating it as necessary to fill the width/height.
+      def compose_slice_on_canvas(target, slice, x, y, width, height)
+        source_canvas = slice[:canvas] || slice[:file][:canvas]
+        source_width = slice[:sprite_slice_width]
+        source_height = slice[:sprite_slice_height]
+
+        top = 0
+        left = 0
+
+        # Repeat the pattern to fill the width/height.
+        while top < height do
+          while left < width do
+            if target.respond_to?(:compose)
+              target.compose!(source_canvas, left + x, top + y)
+            else
+              target.composite!(source_canvas, left + x, top + y)
+            end
+            left += source_width
+          end
+          top += source_height
+        end
+
+      end
+
+      # Postprocesses the CSS, inserting sprites and defining offsets.
+      def postprocess_css_sprited(opts)
+        # The images should already be sliced appropriately, as we are
+        # called by the css method, which calls slice_images.
+
+        # We will need the position of all sprites, so generate the sprite
+        # definitions now:
+        generate_sprite_definitions(opts)
+
+        css = @css.gsub(/_sc_chance:\s*["'](.*?)["']/) {|match|
+          slice = @slices[$1]
+          sprite = sprite_for_slice(slice, opts)
+
+          output = "background-image: chance_file('#{sprite[:name]}')\n"
+
+          if slice[:x2]
+            width = sprite[:width] / slice[:proportion]
+            height = sprite[:height] / slice[:proportion]
+            output += ";  -webkit-background-size: #{width}px #{height}px"
+          end
+
+          output
+        }
+
+        css.gsub!(/-chance-offset:\s?"(.*?)" (-?[0-9]+) (-?[0-9]+)/) {|match|
+          slice = @slices[$1]
+
+          slice_x = $2.to_i - slice[:sprite_slice_x]
+          slice_y = $3.to_i - slice[:sprite_slice_y]
+
+          # If it is 2x, we are scaling the slice down by 2, making all of our
+          # positions need to be 1/2 of what they were.
+          if slice[:x2]
+            slice_x /= slice[:proportion]
+            slice_y /= slice[:proportion]
+          end
+
+          "background-position: #{slice_x}px #{slice_y}px"
+        }
+
+        css
+
+      end
+
+      def sprite_data(opts)
+        _render
+        slice_images(opts)
+        generate_sprite_definitions(opts)
+
+        sprite = @sprites[opts[:name]]
+
+        # When the sprite is nil, it simply means there weren't any images,
+        # so this sprite is not needed. But build systems may still
+        # expect this file to exist. We'll just make it empty.
+        if sprite.nil?
+          return ""
+        end
+
+
+        generate_sprite(sprite) if not sprite[:has_generated]
+
+        sprite[:canvas].to_blob
+      end
+
+      def sprite_names(opts={})
+        _render
+        slice_images(opts)
+        generate_sprite_definitions(opts)
+
+        @sprites.keys
+      end
+
+    end
+  end
+end