nurettin-prawn 1.0.0.rc1

data/lib/prawn/graphics/cap_style.rb

@@ -0,0 +1,46 @@
+# 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
+
+      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
+        add_content "#{CAP_STYLES[current_cap_style]} J"
+      end
+    end
+  end
+end

data/lib/prawn/graphics/color.rb

@@ -0,0 +1,231 @@
+# 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
+
+      # 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
+
+        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
+          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)
+        add_content "#{color} #{operator}"
+      end
+
+    end
+  end
+end
+

data/lib/prawn/graphics/dash.rb

@@ -0,0 +1,82 @@
+# 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
+
+      # Sets the dash pattern for stroked lines and curves
+      #
+      #   length is the length of the dash. If options is not present,
+      #   or options[:space] is nil, then length is also the length of
+      #   the space between dashes
+      #
+      #   options may contain :space and :phase
+      #      :space is the space between the dashes
+      #      :phase is where in the cycle to begin dashing. 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 options
+      #
+      #   dash units are in PDF points ( 1/72 in )
+      #   
+      def dash(length=nil, options={})        
+        return current_dash_state || undash_hash if length.nil?
+
+        self.current_dash_state = { :dash  => length, 
+                  :space => 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
+      
+      def write_stroke_dash
+        add_content dash_setting
+      end
+
+    private
+      
+      def undashed_setting
+        { :dash => nil, :space => nil, :phase => 0 }
+      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/join_style.rb

@@ -0,0 +1,47 @@
+# 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 }
+      
+      # 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
+        add_content "#{JOIN_STYLES[current_join_style]} j"
+      end
+    end
+  end
+end

data/lib/prawn/graphics/patterns.rb

@@ -0,0 +1,137 @@
+# 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
+
+      # 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)
+        if args[1].is_a?(Array) || args[2].is_a?(Array)
+          set_gradient(:fill, *args)
+        else
+          warn "[DEPRECATION] 'fill_gradient(point, width, height,...)' is deprecated in favor of 'fill_gradient(from, to,...)'. " +
+               "Old arguments will be removed in release 1.1"
+          set_gradient :fill, args[0], [args[0].first, args[0].last - args[2]], args[3], args[4]
+        end
+      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)
+        if args[1].is_a?(Array) || args[2].is_a?(Array)
+          set_gradient(:stroke, *args)
+        else
+          warn "[DEPRECATION] 'stroke_gradient(point, width, height,...)' is deprecated in favor of 'stroke_gradient(from, to,...)'. " +
+               "Old arguments will be removed in release 1.1"
+          set_gradient :stroke, args[0], [args[0].first, args[0].last - args[2]], args[3], args[4]
+        end
+      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
+        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],
+        })
+
+        shading_pattern = ref!({
+          :PatternType => 2, # shading pattern
+          :Shading => shading,
+          :Matrix => [1, 0,
+                      0, 1] + map_to_absolute(args[0]),
+        })
+      end
+    end
+  end
+end