prawn-git 2.0.1

data/lib/prawn/graphics/cap_style.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+# cap_style.rb : Implements stroke cap styling
+#
+# Contributed by Daniel Nelson. October, 2009
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Graphics
+    module CapStyle
+      # @group Stable API
+
+      CAP_STYLES = { :butt => 0, :round => 1, :projecting_square => 2 }
+
+      # Sets the cap style for stroked lines and curves
+      #
+      # style is one of :butt, :round, or :projecting_square
+      #
+      # NOTE: If this method is never called, :butt will be used by default.
+      #
+      def cap_style(style=nil)
+        return current_cap_style || :butt if style.nil?
+
+        self.current_cap_style = style
+
+        write_stroke_cap_style
+      end
+
+      alias_method :cap_style=, :cap_style
+
+      private
+
+      def current_cap_style
+        graphic_state.cap_style
+      end
+
+      def current_cap_style=(style)
+        graphic_state.cap_style = style
+      end
+
+      def write_stroke_cap_style
+        renderer.add_content "#{CAP_STYLES[current_cap_style]} J"
+      end
+    end
+  end
+end

data/lib/prawn/graphics/color.rb

@@ -0,0 +1,232 @@
+# encoding: utf-8
+
+# color.rb : Implements color handling
+#
+# Copyright June 2008, Gregory Brown.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  module Graphics
+    module Color
+      # @group Stable API
+
+      # Sets or returns the fill color.
+      #
+      # When called with no argument, it returns the current fill color.
+      #
+      # If a single argument is provided, it should be a 6 digit HTML color
+      # code.
+      #
+      #   pdf.fill_color "f0ffc1"
+      #
+      # If 4 arguments are provided, the color is assumed to be a CMYK value
+      # Values range from 0 - 100.
+      #
+      #   pdf.fill_color 0, 99, 95, 0
+      #
+      def fill_color(*color)
+        return current_fill_color if color.empty?
+        self.current_fill_color = process_color(*color)
+        set_fill_color
+      end
+
+      alias_method :fill_color=, :fill_color
+
+      # Sets or returns the line stroking color.
+      #
+      # When called with no argument, it returns the current stroking color.
+      #
+      # If a single argument is provided, it should be a 6 digit HTML color
+      # code.
+      #
+      #   pdf.stroke_color "f0ffc1"
+      #
+      # If 4 arguments are provided, the color is assumed to be a CMYK value
+      # Values range from 0 - 100.
+      #
+      #   pdf.stroke_color 0, 99, 95, 0
+      #
+      def stroke_color(*color)
+        return current_stroke_color if color.empty?
+        color = process_color(*color)
+        self.current_stroke_color = color
+        set_stroke_color(color)
+      end
+
+      alias_method :stroke_color=, :stroke_color
+
+      module_function
+
+      # Converts RGB value array to hex string suitable for use with fill_color
+      # and stroke_color
+      #
+      #   >> Prawn::Graphics::Color.rgb2hex([255,120,8])
+      #   => "ff7808"
+      #
+      def rgb2hex(rgb)
+        rgb.map { |e| "%02x" % e }.join
+      end
+
+      # Converts hex string into RGB value array:
+      #
+      #  >> Prawn::Graphics::Color.hex2rgb("ff7808")
+      #  => [255, 120, 8]
+      #
+      def hex2rgb(hex)
+        r,g,b = hex[0..1], hex[2..3], hex[4..5]
+        [r,g,b].map { |e| e.to_i(16) }
+      end
+
+      private
+
+      def process_color(*color)
+        case(color.size)
+        when 1
+          color[0]
+        when 4
+          color
+        else
+          raise ArgumentError, 'wrong number of arguments supplied'
+        end
+      end
+
+      def color_type(color)
+        case color
+        when String
+          :RGB
+        when Array
+          case color.length
+          when 3
+            :RGB
+          when 4
+            :CMYK
+          else
+            raise ArgumentError, "Unknown type of color: #{color.inspect}"
+          end
+        end
+      end
+
+      def normalize_color(color)
+        case color_type(color)
+        when :RGB
+          r,g,b = hex2rgb(color)
+          [r / 255.0, g / 255.0, b / 255.0]
+        when :CMYK
+          c,m,y,k = *color
+          [c / 100.0, m / 100.0, y / 100.0, k / 100.0]
+        end
+      end
+
+      def color_to_s(color)
+        normalize_color(color).map { |c| '%.3f' % c }.join(' ')
+      end
+
+      def color_space(color)
+        case color_type(color)
+        when :RGB
+          :DeviceRGB
+        when :CMYK
+          :DeviceCMYK
+        end
+      end
+
+      COLOR_SPACES = [:DeviceRGB, :DeviceCMYK, :Pattern]
+
+      def set_color_space(type, color_space)
+        # don't set the same color space again
+        return if current_color_space(type) == color_space && !state.page.in_stamp_stream?
+        set_current_color_space(color_space, type)
+
+        unless COLOR_SPACES.include?(color_space)
+          raise ArgumentError, "unknown color space: '#{color_space}'"
+        end
+
+        operator = case type
+        when :fill
+          'cs'
+        when :stroke
+          'CS'
+        else
+          raise ArgumentError, "unknown type '#{type}'"
+        end
+
+        renderer.add_content "/#{color_space} #{operator}"
+      end
+
+      def set_color(type, color, options = {})
+        operator = case type
+        when :fill
+          'scn'
+        when :stroke
+          'SCN'
+        else
+          raise ArgumentError, "unknown type '#{type}'"
+        end
+
+        if options[:pattern]
+          set_color_space type, :Pattern
+          renderer.add_content "/#{color} #{operator}"
+        else
+          set_color_space type, color_space(color)
+          color = color_to_s(color)
+          write_color(color, operator)
+        end
+      end
+
+      def set_fill_color(color = nil)
+        set_color :fill, color || current_fill_color
+      end
+
+      def set_stroke_color(color = nil)
+        set_color :stroke, color || current_stroke_color
+      end
+
+      def update_colors
+        set_fill_color
+        set_stroke_color
+      end
+
+      private
+
+      def current_color_space(type)
+        graphic_state.color_space[type]
+      end
+
+      def set_current_color_space(color_space, type)
+        save_graphics_state if graphic_state.nil?
+        graphic_state.color_space[type] = color_space
+      end
+
+      def current_fill_color
+        graphic_state.fill_color
+      end
+
+      def current_fill_color=(color)
+        graphic_state.fill_color = color
+      end
+
+      def current_stroke_color
+        graphic_state.stroke_color
+      end
+
+      def current_stroke_color=(color)
+        graphic_state.stroke_color = color
+      end
+
+      def write_fill_color
+        write_color(current_fill_color, 'scn')
+      end
+
+      def write_stroke_color
+        write_color(current_fill_color, 'SCN')
+      end
+
+      def write_color(color, operator)
+        renderer.add_content "#{color} #{operator}"
+      end
+
+    end
+  end
+end
+

data/lib/prawn/graphics/dash.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+
+# dash.rb : Implements stroke dashing
+#
+# Contributed by Daniel Nelson. October, 2009
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Graphics
+    module Dash
+      # @group Stable API
+
+      # Sets the dash pattern for stroked lines and curves or return the
+      # current dash pattern setting if +length+ is nil.
+      #
+      # There are two ways to set the dash pattern:
+      #
+      # * If the parameter +length+ is an Integer/Float, it specifies
+      #   the length of the dash and of the gap. The length of the gap
+      #   can be customized by setting the :space option.
+      #
+      #   Examples:
+      #
+      #     length = 3
+      #       3 on, 3 off, 3 on, 3 off, ...
+      #     length = 3, :space =2
+      #       3 on, 2 off, 3 on, 2 off, ...
+      #
+      # * If the parameter +length+ is an array, it specifies the
+      #   lengths of alternating dashes and gaps. The :space option is
+      #   ignored in this case.
+      #
+      #   Examples:
+      #
+      #     length = [2, 1]
+      #       2 on, 1 off, 2 on, 1 off, ...
+      #     length = [3, 1, 2, 3]
+      #       3 on, 1 off, 2 on, 3 off, 3 on, 1 off, ...
+      #
+      # Options may contain the keys :space and :phase
+      #
+      # :space:: The space between the dashes (only used when +length+
+      #          is not an array)
+      #
+      # :phase:: The distance into the dash pattern at which to start
+      #          the dash. For example, a phase of 0 starts at the
+      #          beginning of the dash; whereas, if the phase is equal
+      #          to the length of the dash, then stroking will begin at
+      #          the beginning of the space. Default is 0.
+      #
+      # Integers or Floats may be used for length and the option values.
+      # Dash units are in PDF points (1/72 inch).
+      #
+      def dash(length=nil, options={})
+        return current_dash_state if length.nil?
+
+        if length == 0 || length.kind_of?(Array) && length.any? { |e| e == 0 }
+          raise ArgumentError,
+            "Zero length dashes are invalid. Call #undash to disable dashes."
+        end
+
+        self.current_dash_state = { :dash  => length,
+                  :space => length.kind_of?(Array) ? nil : options[:space] || length,
+                  :phase => options[:phase] || 0 }
+
+        write_stroke_dash
+      end
+
+      alias_method :dash=, :dash
+
+      # Stops dashing, restoring solid stroked lines and curves
+      #
+      def undash
+        self.current_dash_state = undashed_setting
+        write_stroke_dash
+      end
+
+      # Returns when stroke is dashed, false otherwise
+      #
+      def dashed?
+        current_dash_state != undashed_setting
+      end
+
+      private
+
+      def write_stroke_dash
+        renderer.add_content dash_setting
+      end
+
+      def undashed_setting
+        { :dash => nil, :space => nil, :phase => 0 }
+      end
+
+      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/join_style.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+# join_style.rb : Implements stroke join styling
+#
+# Contributed by Daniel Nelson. October, 2009
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Graphics
+    module JoinStyle
+      JOIN_STYLES = { :miter => 0, :round => 1, :bevel => 2 }
+
+      # @group Stable API
+
+      # Sets the join style for stroked lines and curves
+      #
+      # style is one of :miter, :round, or :bevel
+      #
+      # NOTE: if this method is never called, :miter will be used for join style
+      # throughout the document
+      #
+      def join_style(style=nil)
+        return current_join_style || :miter if style.nil?
+
+        self.current_join_style = style
+
+        write_stroke_join_style
+      end
+
+      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
+        renderer.add_content "#{JOIN_STYLES[current_join_style]} j"
+      end
+    end
+  end
+end

data/lib/prawn/graphics/patterns.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+# patterns.rb : Implements axial & radial gradients
+#
+# Originally implemented by Wojciech Piekutowski. November, 2009
+# Copyright September 2012, Alexander Mankuta. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Graphics
+    module Patterns
+      # @group Stable API
+
+      # Sets the fill gradient from color1 to color2.
+      # old arguments: point, width, height, color1, color2, options = {}
+      # new arguments: from, to, color1, color1
+      #            or  from, r1, to, r2, color1, color2
+      def fill_gradient(*args)
+        set_gradient(:fill, *args)
+      end
+
+      # Sets the stroke gradient from color1 to color2.
+      # old arguments: point, width, height, color1, color2, options = {}
+      # new arguments: from, to, color1, color2
+      #            or  from, r1, to, r2, color1, color2
+      def stroke_gradient(*args)
+        set_gradient(:stroke, *args)
+      end
+
+      private
+
+      def set_gradient(type, *grad)
+        patterns = page.resources[:Pattern] ||= {}
+
+        registry_key = gradient_registry_key grad
+
+        if patterns["SP#{registry_key}"]
+          shading = patterns["SP#{registry_key}"]
+        else
+          unless shading = gradient_registry[registry_key]
+            shading = gradient(*grad)
+            gradient_registry[registry_key] = shading
+          end
+
+          patterns["SP#{registry_key}"] = shading
+        end
+
+        operator = case type
+        when :fill
+          'scn'
+        when :stroke
+          'SCN'
+        else
+          raise ArgumentError, "unknown type '#{type}'"
+        end
+
+        set_color_space type, :Pattern
+        renderer.add_content "/SP#{registry_key} #{operator}"
+      end
+
+      def gradient_registry_key(gradient)
+        if gradient[1].is_a?(Array) # axial
+          [
+            map_to_absolute(gradient[0]),
+            map_to_absolute(gradient[1]),
+            gradient[2], gradient[3]
+          ]
+        else # radial
+          [
+            map_to_absolute(gradient[0]),
+            gradient[1],
+            map_to_absolute(gradient[2]),
+            gradient[3],
+            gradient[4], gradient[5]
+          ]
+        end.hash
+      end
+
+      def gradient_registry
+        @gradient_registry ||= {}
+      end
+
+      def gradient(*args)
+        if args.length != 4 && args.length != 6
+          raise ArgumentError, "Unknown type of gradient: #{args.inspect}"
+        end
+
+        color1 = normalize_color(args[-2]).dup.freeze
+        color2 = normalize_color(args[-1]).dup.freeze
+
+        if color_type(color1) != color_type(color2)
+          raise ArgumentError, "Both colors must be of the same color space: #{color1.inspect} and #{color2.inspect}"
+        end
+
+        process_color color1
+        process_color color2
+
+        shader = ref!({
+          :FunctionType => 2,
+          :Domain => [0.0, 1.0],
+          :C0 => color1,
+          :C1 => color2,
+          :N => 1.0,
+        })
+
+        shading = ref!({
+          :ShadingType => args.length == 4 ? 2 : 3, # axial : radial shading
+          :ColorSpace => color_space(color1),
+          :Coords => args.length == 4 ?
+                        [0, 0, args[1].first - args[0].first, args[1].last - args[0].last] :
+                        [0, 0, args[1], args[2].first - args[0].first, args[2].last - args[0].last, args[3]],
+          :Function => shader,
+          :Extend => [true, true],
+        })
+
+        ref!({
+          :PatternType => 2, # shading pattern
+          :Shading => shading,
+          :Matrix => [1, 0,
+                      0, 1] + map_to_absolute(args[0]),
+        })
+      end
+    end
+  end
+end