prawn 0.11.1.pre → 0.11.1

data/lib/prawn/graphics/dash.rb

@@ -28,10 +28,10 @@ module Prawn
       #
       #   dash units are in PDF points ( 1/72 in )
       #   
-      def dash(length=nil, options={})
-        return @dash || undash_hash if length.nil?
+      def dash(length=nil, options={})        
+        return current_dash_state || undash_hash if length.nil?
 
-        @dash = { :dash  => length, 
+        self.current_dash_state = { :dash  => length, 
                   :space => options[:space] || length, 
                   :phase => options[:phase] || 0 }
 
@@ -43,29 +43,40 @@ module Prawn
       # Stops dashing, restoring solid stroked lines and curves
       #
       def undash
-        @dash = undash_hash
+        self.current_dash_state = undashed_setting
         write_stroke_dash
       end
       
       # Returns when stroke is dashed, false otherwise
       #
       def dashed?
-        dash != undash_hash
+        current_dash_state != undashed_setting
+      end
+      
+      def write_stroke_dash
+        add_content dash_setting
       end
 
-      private
-
-      def undash_hash
+    private
+      
+      def undashed_setting
         { :dash => nil, :space => nil, :phase => 0 }
       end
-
-      def write_stroke_dash
-        if @dash[:dash].nil?
-          add_content "[] 0 d"
-          return
-        end
-        add_content "[#{@dash[:dash]} #{@dash[:space]}] #{@dash[:phase]} d"
-      end     
+      
+      private 
+        
+      def current_dash_state=(dash_options)  
+        graphic_state.dash = dash_options
+      end
+      
+      def current_dash_state
+        graphic_state.dash
+      end
+      
+      def dash_setting
+        graphic_state.dash_setting
+      end
+      
     end
   end
 end

data/lib/prawn/graphics/gradient.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+# gradient.rb : Implements axial gradient
+#
+# Contributed by Wojciech Piekutowski. November, 2009
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Graphics
+    module Gradient
+      # Sets the fill gradient from color1 to color2.
+      #
+      # It accepts CMYK and RGB colors, like #fill_color. Both colors must be
+      # of the same type.
+      #
+      # point, width and height define a bounding box in which the gradient
+      # will be rendered. For example, if you want to have page full of text
+      # with gradually changing color:
+      #
+      #   pdf.fill_gradient [0, pdf.bounds.height], pdf.bounds.width,
+      #     pdf.bounds.height, 'FF0000', '0000FF'
+      #   pdf.text 'lots of text'*1000
+      #
+      # <tt>:stroke_bounds</tt> - draw gradient bounds
+      def fill_gradient(point, width, height, color1, color2, options = {})
+        set_gradient(:fill, point, width, height, color1, color2, options)
+      end
+
+      # Sets the stroke gradient from color1 to color2.
+      #
+      # See #fill_gradient for details.
+      def stroke_gradient(point, width, height, color1, color2, options = {})
+        set_gradient(:stroke, point, width, height, color1, color2, options)
+      end
+
+      private
+
+      def set_gradient(type, point, width, height, color1, color2, options)
+        if options[:stroke_bounds]
+          stroke_color 0, 0, 0, 100
+          stroke_rectangle point, width, height
+        end
+
+        if color_type(color1) != color_type(color2)
+          raise ArgumentError, 'both colors must be of the same type: RGB or CMYK'
+        end
+
+        process_color color1
+        process_color color2
+
+        shader = ref!({
+          :FunctionType => 2,
+          :Domain => [0.0, 1.0],
+          :C0 => normalize_color(color1),
+          :C1 => normalize_color(color2),
+          :N => 1,
+        })
+
+        shading = ref!({
+          :ShadingType => 2, # axial shading
+          :ColorSpace => color_type(color1) == :RGB ? :DeviceRGB : :DeviceCMYK,
+          :Coords => [0.0, 0.0, 1.0, 0.0],
+          :Function => shader,
+          :Extend => [true, true],
+        })
+
+        x, y = *point
+        shading_pattern = ref!({
+          :PatternType => 2, # shading pattern
+          :Shading => shading,
+          :Matrix => [0,-height, -width, 0, x, y],
+        })
+
+        patterns = page.resources[:Pattern] ||= {}
+        id = patterns.empty? ? 'SP1' : patterns.keys.sort.last.succ
+        patterns[id] = shading_pattern
+
+        set_color type, id, :pattern => true
+      end
+    end
+  end
+end
+

data/lib/prawn/graphics/join_style.rb

@@ -19,9 +19,9 @@ module Prawn
       # throughout the document
       #
       def join_style(style=nil)
-        return @join_style || :miter if style.nil?
+        return current_join_style || :miter if style.nil?
 
-        @join_style = style
+        self.current_join_style = style
 
         write_stroke_join_style
       end
@@ -29,9 +29,18 @@ module Prawn
       alias_method :join_style=, :join_style
 
       private
+      
+      def current_join_style  
+        graphic_state.join_style
+      end
+
+      def current_join_style=(style)  
+        graphic_state.join_style = style
+      end
+      
 
       def write_stroke_join_style
-        add_content "#{JOIN_STYLES[@join_style]} j"
+        add_content "#{JOIN_STYLES[current_join_style]} j"
       end
     end
   end

data/lib/prawn/graphics/transparency.rb

@@ -18,14 +18,14 @@ module Prawn
     #   # both the fill and stroke will be at 50% opacity
     #   pdf.transparent(0.5) do
     #     pdf.text("hello world")
-    #     pdf.fill_and_stroke_circle_at([x, y], :radius => 25)
+    #     pdf.fill_and_stroke_circle([x, y], 25)
     #   end
     #
     #   # the fill will be at 50% opacity, but the stroke will
     #   # be at 75% opacity
     #   pdf.transparent(0.5, 0.75) do
     #     pdf.text("hello world")
-    #     pdf.fill_and_stroke_circle_at([x, y], :radius => 25)
+    #     pdf.fill_and_stroke_circle([x, y], 25)
     #   end
     #
     module Transparency
@@ -41,14 +41,14 @@ module Prawn
       #   # both the fill and stroke will be at 50% opacity
       #   pdf.transparent(0.5) do
       #     pdf.text("hello world")
-      #     pdf.fill_and_stroke_circle_at([x, y], :radius => 25)
+      #     pdf.fill_and_stroke_circle([x, y], 25)
       #   end
       #
       #   # the fill will be at 50% opacity, but the stroke will
       #   # be at 75% opacity
       #   pdf.transparent(0.5, 0.75) do
       #     pdf.text("hello world")
-      #     pdf.fill_and_stroke_circle_at([x, y], :radius => 25)
+      #     pdf.fill_and_stroke_circle([x, y], 25)
       #   end
       #
       def transparent(opacity, stroke_opacity=opacity, &block)

data/lib/prawn/images.rb

@@ -68,9 +68,9 @@ module Prawn
 
       if file.respond_to?(:read)
         image_content = file.read
-      else      
+      else
         raise ArgumentError, "#{file} not found" unless File.file?(file)  
-        image_content =  File.binread(file)
+        image_content = File.binread(file)
       end
       
       image_sha1 = Digest::SHA1.hexdigest(image_content)
@@ -80,21 +80,18 @@ module Prawn
         info = image_registry[image_sha1][:info]
         image_obj = image_registry[image_sha1][:obj]
       else
-        # build the image object and embed the raw data
-        image_obj = case detect_image_format(image_content)
-        when :jpg then
-          info = Prawn::Images::JPG.new(image_content)
-          build_jpg_object(image_content, info)
-        when :png then
-          info = Prawn::Images::PNG.new(image_content)
-
-          # 16-bit color only supported in 1.5+ (ISO 32000-1:2008 8.9.5.1)
-          if info.bits > 8
-            min_version 1.5
-          end
-
-          build_png_object(image_content, info)
-        end
+        # Build the image object
+        klass = case detect_image_format(image_content)
+                when :jpg then Prawn::Images::JPG
+                when :png then Prawn::Images::PNG
+                end
+        info = klass.new(image_content)
+
+        # Bump PDF version if the image requires it
+        min_version(info.min_pdf_version) if info.respond_to?(:min_pdf_version)
+
+        # Add the image to the PDF and register it in case we see it again.
+        image_obj = info.build_pdf_object(self)
         image_registry[image_sha1] = {:obj => image_obj, :info => info}
       end
 
@@ -164,147 +161,6 @@ module Prawn
       (self.y - h) < bounds.absolute_bottom 
     end
 
-    def build_jpg_object(data, jpg) 
-      color_space = case jpg.channels
-      when 1
-        :DeviceGray
-      when 3
-        :DeviceRGB
-      when 4
-        :DeviceCMYK
-      else
-        raise ArgumentError, 'JPG uses an unsupported number of channels'
-      end
-      obj = ref!(:Type       => :XObject,
-          :Subtype          => :Image,
-          :Filter           => :DCTDecode,
-          :ColorSpace       => color_space,
-          :BitsPerComponent => jpg.bits,
-          :Width            => jpg.width,
-          :Height           => jpg.height,
-          :Length           => data.size ) 
-
-      # add extra decode params for CMYK images. By swapping the
-      # min and max values from the default, we invert the colours. See
-      # section 4.8.4 of the spec.
-      if color_space == :DeviceCMYK
-        obj.data[:Decode] = [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ]
-      end
-
-      obj << data
-      return obj
-    end
-
-    def build_png_object(data, png)
-
-      if png.compression_method != 0
-        raise Errors::UnsupportedImageType, 'PNG uses an unsupported compression method'
-      end
-
-      if png.filter_method != 0
-        raise Errors::UnsupportedImageType, 'PNG uses an unsupported filter method'
-      end
-
-      if png.interlace_method != 0
-        raise Errors::UnsupportedImageType, 'PNG uses unsupported interlace method'
-      end
-
-      # some PNG types store the colour and alpha channel data together,
-      # which the PDF spec doesn't like, so split it out.
-      png.split_alpha_channel!
-
-      case png.colors
-      when 1
-        color = :DeviceGray
-      when 3
-        color = :DeviceRGB
-      else
-        raise Errors::UnsupportedImageType, "PNG uses an unsupported number of colors (#{png.colors})"
-      end
-
-      # build the image dict
-      obj = ref!(:Type             => :XObject,
-                :Subtype          => :Image,
-                :Height           => png.height,
-                :Width            => png.width,
-                :BitsPerComponent => png.bits,
-                :Length           => png.img_data.size,
-                :Filter           => :FlateDecode
-               )
-
-      unless png.alpha_channel
-        obj.data[:DecodeParms] = {:Predictor => 15,
-                                  :Colors    => png.colors,
-                                  :BitsPerComponent => png.bits,
-                                  :Columns   => png.width}
-      end
-
-      # append the actual image data to the object as a stream
-      obj << png.img_data
-      
-      # sort out the colours of the image
-      if png.palette.empty?
-        obj.data[:ColorSpace] = color
-      else
-        # embed the colour palette in the PDF as a object stream
-        palette_obj = ref!(:Length => png.palette.size)
-        palette_obj << png.palette
-
-        # build the color space array for the image
-        obj.data[:ColorSpace] = [:Indexed, 
-                                 :DeviceRGB,
-                                 (png.palette.size / 3) -1,
-                                 palette_obj]
-      end
-
-      # *************************************
-      # add transparency data if necessary
-      # *************************************
-
-      # For PNG color types 0, 2 and 3, the transparency data is stored in
-      # a dedicated PNG chunk, and is exposed via the transparency attribute
-      # of the PNG class.
-      if png.transparency[:grayscale]
-        # Use Color Key Masking (spec section 4.8.5)
-        # - An array with N elements, where N is two times the number of color
-        #   components.
-        val = png.transparency[:grayscale]
-        obj.data[:Mask] = [val, val]
-      elsif png.transparency[:rgb]
-        # Use Color Key Masking (spec section 4.8.5)
-        # - An array with N elements, where N is two times the number of color
-        #   components.
-        rgb = png.transparency[:rgb]
-        obj.data[:Mask] = rgb.collect { |x| [x,x] }.flatten
-      elsif png.transparency[:indexed]
-        # TODO: broken. I was attempting to us Color Key Masking, but I think
-        #       we need to construct an SMask i think. Maybe do it inside
-        #       the PNG class, and store it in alpha_channel
-        #obj.data[:Mask] = png.transparency[:indexed]
-      end
-
-      # For PNG color types 4 and 6, the transparency data is stored as a alpha
-      # channel mixed in with the main image data. The PNG class seperates
-      # it out for us and makes it available via the alpha_channel attribute
-      if png.alpha_channel
-        min_version 1.4
-        smask_obj = ref!(:Type             => :XObject,
-                        :Subtype          => :Image,
-                        :Height           => png.height,
-                        :Width            => png.width,
-                        :BitsPerComponent => png.alpha_channel_bits,
-                        :Length           => png.alpha_channel.size,
-                        :Filter           => :FlateDecode,
-                        :ColorSpace       => :DeviceGray,
-                        :Decode           => [0, 1]
-                       )
-        smask_obj << png.alpha_channel
-        obj.data[:SMask] = smask_obj
-      end
-
-      return obj
-    end
-
     def calc_image_dimensions(info, options)
       w = options[:width] || info.width
       h = options[:height] || info.height
@@ -340,9 +196,11 @@ module Prawn
     def detect_image_format(content)
       top = content[0,128]                       
 
-      if top[0, 3] == "\xff\xd8\xff"
+      # Unpack before comparing for JPG header, so as to avoid having to worry
+      # about the source string encoding. We just want a byte-by-byte compare.
+      if top[0, 3].unpack("C*") == [255, 216, 255]
         return :jpg
-      elsif top[0, 8]  == "\x89PNG\x0d\x0a\x1a\x0a"
+      elsif top[0, 8].unpack("C*") == [137, 80, 78, 71, 13, 10, 26, 10]
         return :png
       else
         raise Errors::UnsupportedImageType, "image file is an unrecognised format"

data/lib/prawn/images/jpg.rb

@@ -25,6 +25,7 @@ module Prawn
       # <tt>:data</tt>:: A binary string of JPEG data
       #
       def initialize(data)
+        @data = data
         data = StringIO.new(data.dup)
 
         c_marker = "\xff" # Section marker.
@@ -41,6 +42,44 @@ module Prawn
           buffer = data.read(length - 2)
         end
       end
+
+      # Build a PDF object representing this image in +document+, and return
+      # a Reference to it.
+      #
+      def build_pdf_object(document)
+        color_space = case channels
+        when 1
+          :DeviceGray
+        when 3
+          :DeviceRGB
+        when 4
+          :DeviceCMYK
+        else
+          raise ArgumentError, 'JPG uses an unsupported number of channels'
+        end
+
+        obj = document.ref!(
+          :Type             => :XObject,
+          :Subtype          => :Image,
+          :Filter           => :DCTDecode,
+          :ColorSpace       => color_space,
+          :BitsPerComponent => bits,
+          :Width            => width,
+          :Height           => height,
+          :Length           => @data.size
+        ) 
+
+        # add extra decode params for CMYK images. By swapping the
+        # min and max values from the default, we invert the colours. See
+        # section 4.8.4 of the spec.
+        if color_space == :DeviceCMYK
+          obj.data[:Decode] = [ 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0 ]
+        end
+
+        obj << @data
+        obj
+      end
+
     end
   end
 end