pdf-labels 1.0.0

data/vendor/pdf/grid.rb

@@ -0,0 +1,135 @@
+#! /usr/bin/env ruby
+#--
+# PDF::Writer for Ruby.
+#   http://rubyforge.org/projects/ruby-pdf/
+#   Copyright 2003 - 2005 Austin Ziegler.
+#
+#   Licensed under a MIT-style licence. See LICENCE in the main distribution
+#   for full licensing information.
+#
+# $Id: grid.rb,v 1.2 2005/08/12 03:19:44 austin Exp $
+#++
+require 'pdf/writer'
+
+class PDF::Grid
+    # The scale of the grid lines in one direction. The scale always starts
+    # from the top or left of the page, depending on whether this is the X
+    # axis or Y axis. Minor lines are drawn before major lines.
+  class Scale
+    def initialize
+      @initial_gap  = 0
+
+      yield self if block_given?
+    end
+
+      # The initial gap between the top or left of the page and the first
+      # grid line.
+    attr_accessor :initial_gap
+      # Major grid line style. The default is unset, which uses the current
+      # line style.
+    attr_accessor :major_style
+      # Major grid line colour. The default is unset, which uses the current
+      # line colour.
+    attr_accessor :major_color
+      # The number of units between each major line.
+    attr_accessor :major_step
+      # Minor grid line style. The default is unset, which uses the current
+      # line style.
+    attr_accessor :minor_style
+      # Minor grid line colour. The default is unset, which uses the current
+      # line colour.
+    attr_accessor :minor_color
+      # The number of units between each minor line.
+    attr_accessor :minor_step
+  end
+
+  def initialize
+    yield self if block_given?
+  end
+
+    # The X axis scale of the grid. X axis lines are drawn first.
+  attr_accessor :x_scale
+    # The Y axis scale of the grid. X axis lines are drawn first.
+  attr_accessor :y_scale
+
+    # Renders the grid on the document.
+  def render_on(pdf)
+    pdf.save_state
+
+    if @x_scale.minor_step and @x_scale.minor_step > 0
+      pdf.stroke_color! @x_scale.minor_color if @x_scale.minor_color
+      pdf.stroke_style! @x_scale.minor_style if @x_scale.minor_style
+
+      start = @x_scale.initial_gap
+      step  = @x_scale.minor_step
+
+      start.step(pdf.page_width, step) do |x|
+        line(x, 0, x, pdf.page_height).stroke
+      end
+    end
+
+    if @y_scale.minor_step and @y_scale.minor_step > 0
+      pdf.stroke_color! @y_scale.minor_color if @y_scale.minor_color
+      pdf.stroke_style! @y_scale.minor_style if @y_scale.minor_style
+
+      start = pdf.page_height - @y_scale.initial_gap
+      step  = -@y_scale.minor_step
+
+      start.step(0, step) do |y|
+        line(0, y, pdf.page_width, y).stroke
+      end
+    end
+
+    if @x_scale.major_step and @x_scale.major_step > 0
+      pdf.stroke_color! @x_scale.major_color if @x_scale.major_color
+      pdf.stroke_style! @x_scale.major_style if @x_scale.major_style
+
+      start = @x_scale.initial_gap
+      step  = @x_scale.major_step
+
+      start.step(pdf.page_width, step) do |x|
+        line(x, 0, x, pdf.page_height).stroke
+      end
+    end
+
+    if @y_scale.major_step and @y_scale.major_step > 0
+      pdf.stroke_color! @y_scale.major_color if @y_scale.major_color
+      pdf.stroke_style! @y_scale.major_style if @y_scale.major_style
+
+      start = pdf.page_height - @y_scale.initial_gap
+      step  = -@y_scale.major_step
+
+      start.step(0, step) do |y|
+        line(0, y, pdf.page_width, y).stroke
+      end
+    end
+
+#   stroke_color(Color::::RGB::Grey60)
+#   y = absolute_top_margin
+#   line(0, y, @page_width, y).stroke
+#   line(0, @bottom_margin, @page_width, @bottom_margin).stroke
+#   line(@left_margin, 0, @left_margin, @page_height).stroke
+#   x = absolute_right_margin
+#   line(x, 0, x, @page_height).stroke
+#   y = @page_height / 2.0
+#   line(0, y, @left_margin, y).stroke
+#   x = absolute_right_margin
+#   line(x, y, @page_width, y).stroke
+#   x = @page_width / 2.0
+#   line(x, 0, x, @bottom_margin).stroke
+#   y = absolute_top_margin
+#   line(x, y, x, @page_height).stroke
+
+#   0.step(@page_width, 10) do |x|
+#     add_text(x, 0, 3, x.to_s)
+#     add_text(x, @page_height - 3, 3, x.to_s)
+#   end
+
+#   0.step(@page_height, 10) do |y|
+#     add_text(0, y, 3, y.to_s)
+#     add_text(@page_width - 5, y, 3, y.to_s)
+#   end
+
+    restore_state
+  end
+end

data/vendor/pdf/math.rb

@@ -0,0 +1,108 @@
+#--
+# PDF::Writer for Ruby.
+#   http://rubyforge.org/projects/ruby-pdf/
+#   Copyright 2003 - 2005 Austin Ziegler.
+#
+#   Licensed under a MIT-style licence. See LICENCE in the main distribution
+#   for full licensing information.
+#
+# $Id: math.rb,v 1.3 2005/05/16 20:44:34 austin Exp $
+#++
+  # Encapsulate some of the mathematical calculations that need to be
+  # performed when working with PDF documents. All angles in PDF::Writer are
+  # measured in degrees, but all angles in PDF documents are in radians. The
+  # standard conversions between radians, degrees, and gradians are
+  # provided.
+  #
+  # As with the Perl implementations of these conversions, they will be
+  # wrapped in the range of the target measurement (0..PI2 for radians,
+  # 0..360 for degrees, and 0..400 for gradians). To prevent this wrapping,
+  # provide a false value for the +wrap+ parameter.
+  #
+  # To wrap these values manually, use #rad2rad, #deg2deg, or #grad2grad.
+module PDF::Math
+  class << self
+    PI2   = ::Math::PI * 2.0
+
+      # One degree of arc measured in terms of radians.
+    DR  = PI2 / 360.0
+      # One radian of arc, measured in terms of degrees.
+    RD  = 360 / PI2
+      # One degree of arc, measured in terms of gradians.
+    DG  = 400 / 360.0
+      # One gradian of arc, measured in terms of degrees.
+    GD  = 360 / 400.0
+      # One radian of arc, measured in terms of gradians.
+    RG  = 400 / PI2
+      # One gradian of arc, measured in terms of radians.
+    GR  = PI2 / 400.0
+
+      # Truncate the remainder.
+    def remt(num, den)
+      num - den * (num / den.to_f).to_i
+    end
+
+      # Wrap radian values within the range of radians (0..PI2).
+    def rad2rad(rad)
+      remt(rad, PI2)
+    end
+
+      # Wrap degree values within the range of degrees (0..360).
+    def deg2deg(deg)
+      remt(deg, 360)
+    end
+
+      # Wrap gradian values within the range of gradians (0..400).
+    def grad2grad(grad)
+      remt(grad, 400)
+    end
+
+      # Convert degrees to radians. The value will be constrained to the
+      # range of radians (0..PI2) unless +wrap+ is false.
+    def deg2rad(deg, wrap = true)
+      rad = DR * deg
+      rad = rad2rad(rad) if wrap
+      rad
+    end
+
+      # Convert degrees to gradians. The value will be constrained to the
+      # range of gradians (0..400) unless +wrap+ is false.
+    def deg2grad(deg, wrap = true)
+      grad = DG * deg
+      grad = grad2grad(grad) if wrap
+      grad
+    end
+
+      # Convert radians to degrees. The value will be constrained to the
+      # range of degrees (0..360) unless +wrap+ is false.
+    def rad2deg(rad, wrap = true)
+      deg = RD * rad
+      deg = deg2deg(deg) if wrap
+      deg
+    end
+
+      # Convert radians to gradians. The value will be constrained to the
+      # range of gradians (0..400) unless +wrap+ is false.
+    def rad2grad(rad, wrap = true)
+      grad = RG * rad
+      grad = grad2grad(grad) if wrap
+      grad
+    end
+
+      # Convert gradians to degrees. The value will be constrained to the
+      # range of degrees (0..360) unless +wrap+ is false.
+    def grad2deg(grad, wrap = true)
+      deg = GD * grad
+      deg = deg2deg(deg) if wrap
+      deg
+    end
+
+      # Convert gradians to radians. The value will be constrained to the
+      # range of radians (0..PI2) unless +wrap+ is false.
+    def grad2rad(grad, wrap = true)
+      rad = GR * grad
+      rad = rad2rad(rad) if wrap
+      rad
+    end
+  end
+end

data/vendor/pdf/pagenumbers.rb

@@ -0,0 +1,288 @@
+#--
+# PDF::Writer for Ruby.
+#   http://rubyforge.org/projects/ruby-pdf/
+#   Copyright 2003 - 2005 Austin Ziegler.
+#
+#   Licensed under a MIT-style licence. See LICENCE in the main distribution
+#   for full licensing information.
+#
+# $Id: pagenumbers.rb,v 1.3 2005/10/12 14:41:40 austin Exp $
+#++
+require 'pdf/writer'
+
+  # This class will create tables with a relatively simple API and internal
+  # implementation.
+class PDF::PageNumbers
+  VERSION = '1.1.4'
+
+    # Creates a page numbering object. The 
+  def initialize(x, y, options = {})
+    @x  = x
+    @y  = y
+
+    @font               = options[:font]
+    @font_encoding      = options[:font_encoding]
+    @font_size          = options[:font_size]
+    @alignment          = options[:alignment] || :left
+    @pattern            = options[:pattern] || "<PAGE> of <TOTAL>"
+    @first_page_number  = options[:first_page_number] || 1
+
+    @start_pages        = []
+    @stop_pages         = []
+
+    yield self if block_given?
+  end
+
+    # The +x+ position for the page numbering. This will be used as a
+    # relative position based on <tt>#alignment</tt>.
+  attr_accessor :x
+    # The +y+ position for the page numbering.
+  attr_accessor :y
+    # The font that will be used for rendering the page numbers. If not
+    # specified, the font currently active at the time of page rendering
+    # will be used.
+  attr_accessor :font
+    # The font encoding for rendering page numbers. If not specified, the
+    # default font encoding will be used.
+  attr_accessor :font_encoding
+    # The size of the font for rendering page numbers. If not specified, the
+    # current font size at the time of page rendering will be used.
+  attr_accessor :font_size
+    # The alignment of the page numbers relative to <tt>#x</tt>. The options
+    # are <tt>:left</tt> (the text *begins* at <tt>#x</tt>),
+    # <tt>:right</tt> (the text *ends* at <tt>#x</tt>), and <tt>:center</tt>
+    # (the text *surrounds* <tt>#x</tt>). The default alignment is
+    # <tt>:left</tt>.
+  attr_accessor :alignment
+    # The page numbering pattern object. This object must either be a String
+    # or an object that responds to #apply(page, total). String patterns
+    # will be searched for <PAGE> and <TOTAL> and these strings will be
+    # replaced with the current page number and the total page number values
+    # in Arabic (1, 2, 3, 4, ...) numeral values.
+    #
+    # Pattern objects will have their #apply method called with the current
+    # page number and the total page number values. They will be expected to
+    # return a String for writing on the page.
+    #
+    # The default pattern is "<PAGE> of <TOTAL>".
+  attr_accessor :pattern
+    # The page numbering style. This is a number "generator" object that
+    # responds to #[] and returns a string representing that number.
+    # Symbolic values <tt>:default</tt>
+    # 
+    # The
+    # values <tt>:arabic</tt> and <tt>:roman</tt>
+  attr_accessor :numbering_style
+    # The first page number is the value that will be used as the 
+    # generic page number reported by the PDF document during rendering.
+    # This allows physical page 10 to be presented as page 1.
+  attr_accessor :first_page_number
+
+    # Starts page numbering with this page numbering object. The page
+    # numbering will begin on +first_page+, which will be either
+    # <tt>:this_page</tt> or <tt>:next_page</tt>.
+  def start(pdf, first_page = :this_page)
+  end
+
+.blist {{{
+<b>:this_page</b> will add the object just to the current page.
+<b>:all_pages</b> will add the object to the current and all following pages.
+<b>:even_pages</b> will add the object to following even pages, including the current page if it is an even page.
+<b>:odd_pages</b> will add the object to following odd pages, including the current page if it is an odd page.
+<b>:all_following_pages</b> will add the object to the next page created and all following pages.
+<b>:following_even_pages</b> will add to the next even page created and all following even pages.
+<b>:following_odd_pages</b> will add to the next odd page created and all following odd pages.
+.endblist }}}
+
+  def restart_numbering(pdf, page = :this_page)
+  end
+
+  def stop_on_current_page(pdf)
+  end
+
+  def stop_on_next_page(pdf)
+  end
+
+    # 
+  def start(pdf, on_page = :current)
+  end
+  
+  def stop(pdf, on_page = :next)
+  end
+
+  def render(pdf, debug = false)
+  end
+
+    # Put page numbers on the pages from the current page. Place them
+    # relative to the coordinates <tt>(x, y)</tt> with the text horizontally
+    # relative according to +pos+, which may be <tt>:left</tt>,
+    # <tt>:right</tt>, or <tt>:center</tt>. The page numbers will be written
+    # on each page using +pattern+.
+    #
+    # When +pattern+ is rendered, <PAGENUM> will be replaced with the
+    # current page number; <TOTALPAGENUM> will be replaced with the total
+    # number of pages in the page numbering scheme. The default +pattern+ is
+    # "<PAGENUM> of <TOTALPAGENUM>".
+    #
+    # If +starting+ is non-nil, this is the first page number. The number of
+    # total pages will be adjusted to account for this.
+    #
+    # Each time page numbers are started, a new page number scheme will be
+    # started. The scheme number will be returned.
+  def start_page_numbering(x, y, size, pos = nil, pattern = nil, starting = nil)
+    pos     ||= :left
+    pattern ||= "<PAGENUM> of <TOTALPAGENUM>"
+
+    @page_numbering ||= []
+    @page_numbering << (o = {})
+
+    page    = @pageset.size
+    o[page] = {
+      :x        => x,
+      :y        => y,
+      :pos      => pos,
+      :pattern  => pattern,
+      :starting => starting,
+      :size     => size
+    }
+    @page_numbering.index(o)
+  end
+
+    # Given a particular generic page number +page_num+ (numbered
+    # sequentially from the beginning of the page set), return the page
+    # number under a particular page numbering +scheme+. Returns +nil+ if
+    # page numbering is not turned on.
+  def which_page_number(page_num, scheme = 0)
+    return nil unless @page_numbering
+
+    num = 0
+    start = start_num = 1
+
+    @page_numbering[scheme].each do |kk, vv|
+      if kk <= page_num
+        if vv.kind_of?(Hash)
+          unless vv[:starting].nil?
+            start = vv[:starting]
+            start_num = kk
+            num = page_num - start_num + start
+          end
+        else
+          num = 0
+        end
+      end
+    end
+    num
+  end
+
+    # Stop page numbering. Returns +false+ if page numbering is off.
+    #
+    # If +stop_total+ is true, then then the totaling of pages for this page
+    # numbering +scheme+ will be stopped as well. If +stop_at+ is
+    # <tt>:current</tt>, then the page numbering will stop at this page;
+    # otherwise, it will stop at the next page.
+  def stop_page_numbering(stop_total = false, stop_at = :current, scheme = 0)
+    return false unless @page_numbering
+
+    page = @pageset.size
+
+    if stop_at != :current and @page_numbering[scheme][page].kind_of?(Hash)
+      if stop_total
+        @page_numbering[scheme][page]["stoptn"] = true
+      else
+        @page_numbering[scheme][page]["stopn"] = true
+      end
+    else
+      if stop_total
+        @page_numbering[scheme][page] = "stopt"
+      else
+        @page_numbering[scheme][page] = "stop"
+      end
+
+      @page_numbering[scheme][page] << "n" unless stop_at == :current
+    end
+  end
+
+  def page_number_search(label, tmp)
+    tmp.each do |scheme, v|
+      if v.kind_of?(Hash)
+        return scheme unless v[label].nil?
+      else
+        return scheme if v == label
+      end
+    end
+    0
+  end
+  private :page_number_search
+
+  def add_page_numbers
+      # This will go through the @page_numbering array and add the page
+      # numbers are required.
+    unless @page_numbering.nil?
+      total_pages1 = @pageset.size
+      tmp1 = @page_numbering
+      status = 0
+      info = {}
+      tmp1.each do |tmp|
+          # Do each of the page numbering systems. First, find the total
+          # pages for this one.
+        k = page_number_search("stopt", tmp)
+        if k and k > 0
+          total_pages = k - 1
+        else
+          l = page_number_search("stoptn", tmp)
+          if l and l > 0
+            total_pages = l
+          else
+            total_pages = total_pages1
+          end
+        end
+        @pageset.each_with_index do |id, page_num|
+          next if page_num == 0
+          if tmp[page_num].kind_of?(Hash) # This must be the starting page #s
+            status = 1
+            info = tmp[page_num]
+            if info[:starting]
+              info[:delta] = info[:starting] - page_num
+            else
+              info[:delta] = page_num
+            end
+              # Also check for the special case of the numbering stopping
+              # and starting on the same page.
+            status = 2 if info["stopn"] or info["stoptn"]
+          elsif tmp[page_num] == "stop" or tmp[page_num] == "stopt"
+            status = 0 # we are stopping page numbers
+          elsif status == 1 and (tmp[page_num] == "stoptn" or tmp[page_num] == "stopn")
+            status = 2
+          end
+
+          if status != 0
+              # Add the page numbering to this page
+            unless info[:delta]
+              num = page_num
+            else
+              num = page_num + info[:delta]
+            end
+
+            total = total_pages + num - page_num
+            pat = info[:pattern].gsub(/<PAGENUM>/, num.to_s).gsub(/<TOTALPAGENUM>/, total.to_s)
+            reopen_object(id.contents.first)
+
+            case info[:pos]
+            when :left    # Write the page number from x.
+              w = 0
+            when :right   # Write the page number to x.
+              w = text_width(pat, info[:size])
+            when :center  # Write the page number around x.
+              w = text_width(pat, info[:size]) / 2.0
+            end
+            add_text(info[:x] - w, info[:y], pat, info[:size])
+            close_object
+            status = 0 if status == 2
+          end
+        end
+      end
+    end
+  end
+  private :add_page_numbers
+
+end