sproutcore 1.6.0.1-java → 1.7.1.beta-java

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

@@ -23,11 +23,6 @@ module Chance
             output += "\n-webkit-background-size: #{width}px #{height}px;"
           end
 
-
-          # FOR IE < 8:
-          output += '*background-image: url("mhtml:chance-mhtml.txt!' + slice[:css_name] + '")'
-          output += "\n"
-
           output
         }
 
@@ -57,29 +52,5 @@ module Chance
       end
     end
 
-    def mhtml(opts)
-      # If there are no slices, ensure that we return an empty file.
-      return "" if @slices.length == 0
-
-      output = "Content-Type: multipart/related; boundary=\"CHANCE__\"\r\n"
-
-      @slices.each {|name, slice|
-        output += "\r\n--CHANCE__\r\n"
-        output += "Content-Location:" + slice[:css_name] + "\r\n"
-        output += "Content-Type:image/png\r\n"
-        output += "Content-Transfer-Encoding:base64\r\n\r\n"
-
-        base64Image = base64_for(slice)
-        output += base64Image.gsub("[^\r]\n", "\r\n")
-
-        output
-      }
-
-       output += "\r\n--CHANCE__--"
-
-      output
-    end
-
-
   end
 end

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

@@ -2,17 +2,57 @@ 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
+      class << self
+        def add_canvas_to_cache(canvas, file, rect)
+          if @canvas_cache.nil?
+            @canvas_cache = {}
+          end
+          
+          left = rect[:left]
+          top = rect[:top]
+          width = rect[:width]
+          height = rect[:height]
+          
+          key = "#{file[:path]}:#{left},#{top},#{width},#{height}"
+          @canvas_cache[key] = {
+            mtime: file[:mtime],
+            canvas: canvas
+          }
+        end
+        
+        def get_canvas_from_cache(file, rect)
+          if @canvas_cache.nil?
+            @canvas_cache = {}
+          end
+          
+          left = rect[:left]
+          top = rect[:top]
+          width = rect[:width]
+          height = rect[:height]
+          
+          key = "#{file[:path]}:#{left},#{top},#{width},#{height}"
+          hash = @canvas_cache[key]
+          
+          # Check to see if it is new enough
+          if not hash.nil? and hash[:mtime] == file[:mtime]
+            return hash[:canvas]
+          end
+          
+          @canvas_cache[key] = nil
+          nil
+        end
+      end
+      
       # 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)
+      def slice_images(opts)        
         slices = @slices
         output = ""
 
@@ -21,7 +61,7 @@ module Chance
           # 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
@@ -53,7 +93,17 @@ module Chance
               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)
+                
+                ## CHECK CACHE ##
+                file = file_for(slice, opts)
+                cached_canvas = Chance::Instance::Slicing.get_canvas_from_cache(file, rect)
+                if cached_canvas
+                  slice[:canvas] = cached_canvas
+                else
+                  slice[:canvas] = canvas.crop(rect[:left] * f, rect[:top] * f, rect[:width] * f, rect[:height] * f)
+                  Chance::Instance::Slicing.add_canvas_to_cache(slice[:canvas], file, rect)
+                end
+                
                 canvas_width = rect[:height] * f
                 canvas_height = rect[:width] * f
               end
@@ -62,8 +112,11 @@ module Chance
             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.

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

@@ -18,12 +18,12 @@ module Chance
       # 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)
+      def generate_sprite_definitions(opts)        
         @sprites = {}
 
         group_slices_into_sprites(opts)
         @sprites.each do |key, sprite|
-          layout_slices_in_sprite sprite
+          layout_slices_in_sprite sprite, opts
         end
       end
 
@@ -70,7 +70,7 @@ module Chance
       # 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"
+        if slice[:repeat] == "repeat"
           return slice[:path] + (opts[:x2] ? "@2x" : "")
         end
 
@@ -79,10 +79,23 @@ module Chance
 
       # Performs the layout operation, laying either up-to-down, or "
       # (for repeat-y slices) left-to-right.
-      def layout_slices_in_sprite(sprite)
+      def layout_slices_in_sprite(sprite, opts)
         # The position is the position in the layout direction. In vertical mode
         # (the usual) it is the Y position.
         pos = 0
+        
+        # Adds some padding that will be painted with a pattern so that it is apparent that
+        # CSS is wrong.
+        # NOTE: though this is only in debug mode, we DO need to make sure it is on a 2px boundary.
+        # This makes sure 2x works properly.
+        padding = @options[:pad_sprites_for_debugging] ? 2 : 0
+        
+        # The position within a row. It starts at 0 even if we have padding,
+        # because we always just add padding when we set the individual x/y pos.
+        inset = 0
+        
+        # The length of the row. Length, when layout out vertically (the usual), is the height
+        row_length = 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.
@@ -94,17 +107,19 @@ module Chance
         smallest_size = nil
 
         is_horizontal = sprite[:use_horizontal_layout]
-
-        sprite[:slices].each do |slice|
+        
+        # Figure out slice width/heights. We cannot rely on slicing to do this for us
+        # because some images may be being passed through as-is.
+        sprite[:slices].each {|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"
+            throw "Could not sprite image " + slice[:path] + "; if it is not a PNG, make sure you have rmagick installed"
           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')
@@ -114,10 +129,10 @@ module Chance
             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
@@ -128,8 +143,41 @@ module Chance
 
             size = size.lcm slice_size
           else
-            size = [size, slice_size].max
+            size = [size, slice_size + padding * 2].max
+          end
+          
+          slice[:slice_width] = slice_width.to_i
+          slice[:slice_height] = slice_height.to_i
+        }
+        
+        # Sort slices from widest/tallest (dependent on is_horizontal) or is_vertical
+        # NOTE: This means we are technically sorting reversed
+        sprite[:slices].sort! {|a, b|
+          # WHY <=> NO WORK?
+          if is_horizontal
+            b[:slice_height] <=> a[:slice_height]
+          else
+            b[:slice_width] <=> a[:slice_width]
+          end
+        }
+
+        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]
+          
+          slice_width = slice[:slice_width]
+          slice_height = slice[:slice_height]
+          
+          slice_length = is_horizontal ? slice_width : slice_height
+          slice_size = is_horizontal ? slice_height : slice_width
+          
+          if slice[:repeat] != "no-repeat" or inset + slice_size + padding * 2 > size or not @options[:optimize_sprites]
+            pos += row_length
+            inset = 0
+            row_length = 0
           end
+            
 
           # We have extras for manual tweaking of offsetx/y. We have to make sure there
           # is padding for this (on either side)
@@ -149,20 +197,44 @@ module Chance
           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_x] = (is_horizontal ? pos : inset)
+          slice[:sprite_slice_y] = (is_horizontal ? inset : pos)
+          
+          # add padding for x, only if it a) doesn't repeat or b) repeats vertically because it has horizontal layout
+          if slice[:repeat] == "no-repeat" or slice[:repeat] == "repeat-y"
+            slice[:sprite_slice_x] += padding
+          end
+          
+          if slice[:repeat] == "no-repeat" or slice[:repeat] == "repeat-x"
+            slice[:sprite_slice_y] += padding
+          end
+          
           slice[:sprite_slice_width] = slice_width
           slice[:sprite_slice_height] = slice_height
 
-          pos += slice_length
+          inset += slice_size + padding * 2
+          
+          # We pad the row length ONLY if it is a repeat-x, repeat-y, or no-repeat image.
+          # If it is 'repeat', we do not pad it, because it should be processed raw.
+          row_length = [slice_length + (slice[:repeat] != "repeat" ? padding * 2 : 0), row_length].max
+          
+          # In 2X, make sure we are aligned on a 2px grid.
+          # We correct this AFTER positioning because we always position on an even grid anyway;
+          # we just may leave that even grid if we have an odd-sized image. We do this after positioning
+          # so that the next loop knows if there is space.
+          if opts[:x2]
+            row_length = (row_length.to_f / 2).ceil * 2
+            inset = (inset.to_f / 2).ceil * 2
+          end
+          
         end
+        pos += row_length
 
         # 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 "WARNING: Used more than 10 extra rows or columns to accommodate repeating slices."
           puts "Wasted up to " + (pos * size-smallest_size).to_s + " pixels"
         end
 
@@ -177,6 +249,14 @@ module Chance
       def generate_sprite(sprite)
         canvas = canvas_for_sprite(sprite)
         sprite[:canvas] = canvas
+        
+        # If we are padding sprites, we should paint the background something really
+        # obvious & obnoxious. Say, magenta. That's obnoxious. A nice light purple wouldn't
+        # be bad, but magenta... that will stick out like a sore thumb (I hope)
+        if @options[:pad_sprites_for_debugging]
+          magenta = ChunkyPNG::Color.rgb(255, 0, 255)
+          canvas.rect(0, 0, sprite[:width], sprite[:height], magenta, magenta)
+        end
 
         sprite[:slices].each do |slice|
           x = slice[:sprite_slice_x]
@@ -221,14 +301,18 @@ module Chance
 
         # Repeat the pattern to fill the width/height.
         while top < height do
+          left = 0
+
           while left < width do
-            if target.respond_to?(:compose)
-              target.compose!(source_canvas, left + x, top + y)
+            if target.respond_to?(:replace!)
+              target.replace!(source_canvas, left + x, top + y)
             else
               target.composite!(source_canvas, left + x, top + y)
             end
+
             left += source_width
           end
+
           top += source_height
         end
 
@@ -295,7 +379,14 @@ module Chance
 
         generate_sprite(sprite) if not sprite[:has_generated]
 
-        sprite[:canvas].to_blob
+        ret = sprite[:canvas].to_blob
+        
+        if Chance.clear_files_immediately
+          sprite[:canvas] = nil
+          sprite[:has_generated] = false
+        end
+        
+        ret
       end
 
       def sprite_names(opts={})

data/vendor/chance/lib/chance/parser.rb

@@ -23,15 +23,6 @@
 # - :theme: a selector that will make up the initial value of the $theme
 #   variable. For example: :theme => "ace.test-controls"
 #
-# - :compress: if true, the slice names in the CSS will be shortened.
-#   This has two drawbacks: 1) the slice names will not be helpful for
-#   debugging, and 2) if using Chance in a standalone way and committing
-#   the output to a source control system, the output can change dramatically
-#   between runs, even if the input CSS is unchanged.
-#
-#   As the most common use of Chance is as part of the SC build tools,
-#   and this debugging support is usually only required to debug Chance
-#   itself, :compress defaults to true
 #
 # How Slice & Slices work
 # -------------------------------
@@ -56,16 +47,15 @@ module Chance
     BEGIN_SCOPE = /\{/
     END_SCOPE = /\}/
     THEME_DIRECTIVE = /@theme\s*/
-    SELECTOR_THEME_VARIABLE = /\$theme\./
+    SELECTOR_THEME_VARIABLE = /\$theme(?=[^\w:-])/
     INCLUDE_SLICES_DIRECTIVE = /@include\s+slices\s*/
     INCLUDE_SLICE_DIRECTIVE = /@include\s+slice\s*/
     CHANCE_FILE_DIRECTIVE = /@_chance_file /
     NORMAL_SCAN_UNTIL = /[^{}@$]+/
 
-    @@uid = 0
 
     def initialize(string, opts = {})
-      @opts = { :theme => "", :compress => true }
+      @opts = { :theme => "" }
       @opts.merge!(opts)
       @path = ""
 
@@ -77,9 +67,6 @@ module Chance
 
       @theme = @opts[:theme]
 
-      @@uid += 1
-      @uid = @@uid
-
     end
 
     # SLICE MANAGEMENT
@@ -135,12 +122,8 @@ module Chance
         slice[:max_offset_x] = [slice[:max_offset_x], opts[:offset_x]].max
         slice[:max_offset_y] = [slice[:max_offset_y], opts[:offset_y]].max
       else
-        parts = slice_path.split("/")
-        css_name = "__slice_" + parts.join("_")
-
-        if @opts[:compress]
-          css_name = "__s" + @uid.to_s + "_" + @slices.length.to_s
-        end
+        modified_path = @opts[:instance_id].to_s.gsub(/[^a-zA-Z0-9]/, '_') + "_" + slice_path.gsub(/[^a-zA-Z0-9]/, '_')
+        css_name = "__chance_slice_#{modified_path}"
 
         slice = opts.merge({ 
           :name => slice_path, 
@@ -151,12 +134,16 @@ module Chance
           :max_offset_x => opts[:offset_x],
           :max_offset_y => opts[:offset_y],
           :imaged_offset_x => 0, # the imaging process will re-define these.
-          :imaged_offset_y => 0
+          :imaged_offset_y => 0,
+
+          :used_by => []
         })
 
         @slices[slice_path] = slice
       end
 
+      slice[:used_by] << { :path => @path }
+
       return slice
     end
 
@@ -358,7 +345,7 @@ module Chance
       scanner = @scanner
       scanner.scan SELECTOR_THEME_VARIABLE
 
-      output = "\#{$theme}."
+      output = "\#{$theme}"
 
       return output
     end
@@ -486,7 +473,7 @@ module Chance
 
       # We prefix with -chance; this should let everything be passed through more
       # or less as-is. Postprocessing will turn it into -background-position.
-      output += "-chance-offset: \"#{slice[:name]}\" #{slice[:offset_x]} #{slice[:offset_y]};"
+      output += "-chance-offset: \"#{slice[:name]}\" #{offset[0]} #{offset[1]};"
       output += "background-repeat: " + slice[:repeat]
       return output
     end
@@ -564,17 +551,25 @@ module Chance
       fill_width = Integer(fill[0])
       fill_height = Integer(fill[1])
 
-      skip_top_left = values.include? 'skip-top-left'
-      skip_top = values.include? 'skip-top'
-      skip_top_right = values.include? 'skip-top-right'
+      # skip control
+      skip = arguments[:skip]
+      if skip.nil?
+        skip = []
+      else
+        skip = skip.split /\s+/
+      end
+
+      skip_top_left = skip.include? 'top-left'
+      skip_top = skip.include? 'top'
+      skip_top_right = skip.include? 'skip-top-right'
 
-      skip_left = values.include? 'skip-left'
-      skip_middle = values.include? 'skip-middle'
-      skip_right = values.include? 'skip-right'
+      skip_left = skip.include? 'left'
+      skip_middle = skip.include? 'middle'
+      skip_right = skip.include? 'right'
 
-      skip_bottom_left = values.include? 'skip-bottom-left'
-      skip_bottom = values.include? 'skip-bottom'
-      skip_bottom_right = values.include? 'skip-bottom-right'
+      skip_bottom_left = skip.include? 'bottom-left'
+      skip_bottom = skip.include? 'bottom'
+      skip_bottom_right = skip.include? 'bottom-right'
 
       filename = parse_string(arguments[0])
 
@@ -645,7 +640,7 @@ module Chance
         :sprite_padding => arguments[:"middle-padding"],
         :offset => arguments[:"middle-offset"],
         :filename => filename,
-        :repeat => fill_height != 0 ? (fill_width != 0 ? "repeat-both" : "repeat-y") : (fill_width != 0 ? "repeat-x" : nil)
+        :repeat => fill_height != 0 ? (fill_width != 0 ? "repeat" : "repeat-y") : (fill_width != 0 ? "repeat-x" : nil)
 
 
         # fill in width, height or right, bottom depending on fill settings
@@ -734,9 +729,18 @@ module Chance
       output = ""
 
       # LEFT
-      if should_include_slice?(top_left_slice) and not skip_top_left
+      # NOTE: we write it even if we are supposed to skip; we only wrap the slice include portion in 
+      if should_include_slice?(top_left_slice)
         output += "& > .top-left {\n"
-        output += generate_slice_include(top_left_slice) + ";"
+
+        # IF we are skipping the top left slice, we don't want the actual slice include-- but the layout
+        # information we still want. So, only bracket the generate_slice_include.
+        #
+        # Potential issue: slice_layout doesn't handle repeat settings. In theory, this should rarely be
+        # an issue (because you aren't setting a background for the skipped slice.
+        if not skip_top_left
+          output += generate_slice_include(top_left_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(top_left_slice)
@@ -744,9 +748,12 @@ module Chance
         output += "}\n"
       end
 
-      if should_include_slice?(left_slice) and not skip_left
+      if should_include_slice?(left_slice)
         output += "& > .left {\n"
-        output += generate_slice_include(left_slice) + ";"
+
+        if not skip_left
+          output += generate_slice_include(left_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(left_slice.merge({ :bottom => bottom }))
@@ -754,9 +761,12 @@ module Chance
         output += "}\n"
       end
 
-      if should_include_slice?(bottom_left_slice) and not skip_bottom_left
+      if should_include_slice?(bottom_left_slice)
         output += "& > .bottom-left {\n"
-        output += generate_slice_include(bottom_left_slice) + ";"
+
+        if not skip_bottom_left
+          output += generate_slice_include(bottom_left_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(bottom_left_slice)
@@ -765,9 +775,12 @@ module Chance
       end
 
       # MIDDLE
-      if should_include_slice?(top_slice) and not skip_top
+      if should_include_slice?(top_slice)
         output += "& > .top {\n"
-        output += generate_slice_include(top_slice) + ";"
+
+        if not skip_top
+          output += generate_slice_include(top_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(top_slice.merge({ :right => right }))
@@ -775,9 +788,12 @@ module Chance
         output += "}\n"
       end
 
-      if should_include_slice?(middle_slice) and not skip_middle
+      if should_include_slice?(middle_slice)
         output += "& > .middle {\n"
-        output += generate_slice_include(middle_slice) + ";"
+
+        if not skip_middle
+          output += generate_slice_include(middle_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(middle_slice.merge({ :bottom => bottom, :right => right }))
@@ -786,9 +802,12 @@ module Chance
         output += "}\n"
       end
 
-      if should_include_slice?(bottom_slice) and not skip_bottom
+      if should_include_slice?(bottom_slice)
         output += "& > .bottom {\n"
-        output += generate_slice_include(bottom_slice) + ";"
+
+        if not skip_bottom
+          output += generate_slice_include(bottom_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(bottom_slice.merge({ :right => right }))
@@ -798,9 +817,12 @@ module Chance
       end
 
       # RIGHT
-      if should_include_slice?(top_right_slice) and not skip_top_right
+      if should_include_slice?(top_right_slice)
         output += "& > .top-right {\n"
-        output += generate_slice_include(top_right_slice) + ";"
+
+        if not skip_top_right
+          output += generate_slice_include(top_right_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(top_right_slice)
@@ -808,9 +830,12 @@ module Chance
         output += "}\n"
       end
 
-      if should_include_slice?(right_slice) and not skip_right
+      if should_include_slice?(right_slice)
         output += "& > .right {\n"
-        output += generate_slice_include(right_slice) + ";"
+
+        if not skip_right
+          output += generate_slice_include(right_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(right_slice.merge({ :bottom => bottom }))
@@ -818,9 +843,12 @@ module Chance
         output += "}\n"
       end
 
-      if should_include_slice?(bottom_right_slice) and not skip_bottom_right
+      if should_include_slice?(bottom_right_slice)
         output += "& > .bottom-right {\n"
-        output += generate_slice_include(bottom_right_slice) + ";"
+
+        if not skip_bottom_right
+          output += generate_slice_include(bottom_right_slice) + ";"
+        end
 
         output += "\nposition: absolute;\n"
         output += slice_layout(bottom_right_slice)