eideticpdf 0.9.9

data/lib/epdfpw.rb

@@ -0,0 +1,1749 @@
+#!/usr/bin/env ruby
+# encoding: ASCII-8BIT
+#
+#  Created by Brent Rowland on 2007-07-13.
+#  Copyright (c) 2007, Eidetic Software. All rights reserved.
+
+require 'epdfo'
+require 'epdfsw'
+require 'epdfk'
+require 'epdft'
+require 'epdfafm'
+require 'epdftt'
+require 'epdfs'
+
+module EideticPDF
+  Font = Struct.new(:name, :size, :style, :color, :encoding, :sub_type, :widths, :ascent, :descent, :height,
+    :underline_position, :underline_thickness)
+  Location = Struct.new(:x, :y)
+  Signs = Struct.new(:x, :y)
+  Bullet = Struct.new(:name, :width, :proc)
+
+  SIGNS = [ Signs.new(1, -1), Signs.new(-1, -1), Signs.new(-1, 1), Signs.new(1, 1) ]
+  UNIT_CONVERSION = { :pt => 1, :in => 72, :cm => 28.35 }
+  LINE_PATTERNS = { :solid => [], :dotted => [1, 2], :dashed => [4, 2] }
+  LINE_CAP_STYLES = [:butt_cap, :round_cap, :projecting_square_cap].freeze
+  IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0].freeze
+
+  class PageStyle # :nodoc:
+    attr_reader :page_size, :crop_size, :orientation, :landscape, :rotate
+
+    PORTRAIT = 0
+    LANDSCAPE = 270
+
+    def initialize(options={})
+      page_size = options[:page_size] || :letter
+      crop_size = options[:crop_size] || page_size
+      @orientation = options[:orientation] || :portrait
+      @page_size = make_size_rectangle(page_size, @orientation)
+      @crop_size = make_size_rectangle(crop_size, @orientation)
+      @landscape = (@orientation == :landscape)
+      @rotate = ROTATIONS[options[:rotate] || :portrait]
+    end
+
+    SIZES = {
+      :letter => [612, 792].freeze,
+      :legal => [612, 1008].freeze,
+      :A4 => [595, 842].freeze,
+      :B5 => [499, 708].freeze,
+      :C5 => [459, 649].freeze
+    }
+    ROTATIONS = { :portrait => PORTRAIT, :landscape => LANDSCAPE }.freeze
+
+  protected
+    def make_size_rectangle(size, orientation)
+      w, h = SIZES[size]
+      w, h = h, w if orientation == :landscape
+      PdfObjects::Rectangle.new(0, 0, w, h)
+    end
+  end
+
+  class PageWriter # :nodoc:
+    include JpegInfo
+
+  private
+    def iconv_encoding(encoding)
+      case encoding
+      when 'WinAnsiEncoding' then 'CP1252'
+      else encoding
+      end
+    end
+
+    def pdf_encoding(encoding, font_name)
+      return 'StandardEncoding' if ['Symbol','ZapfDingbats'].include?(font_name)
+      case encoding.upcase
+      when 'CP1252' then 'WinAnsiEncoding'
+      else encoding
+      end
+    end
+
+    def to_points(units, measurement)
+      UNIT_CONVERSION[units] * measurement
+    end
+
+    def from_points(units, measurement)
+      measurement.quo(UNIT_CONVERSION[units])
+    end
+
+    def make_loc(x, y)
+      Location.new(x, y)
+    end
+
+    def translate(x, y)
+      Location.new(x, page_height - y)
+    end
+
+    def translate_p(p)
+      Location.new(p.x, page_height - p.y)
+    end
+
+    def convert_units(loc, from_units, to_units)
+      Location.new(
+        loc.x * UNIT_CONVERSION[from_units].quo(UNIT_CONVERSION[to_units]),
+        loc.y * UNIT_CONVERSION[from_units].quo(UNIT_CONVERSION[to_units]))
+    end
+
+    def get_quadrant_bezier_points(quadrant, x, y, rx, ry=nil)
+      ry = rx if ry.nil?
+      a = 4.0 / 3.0 * (Math.sqrt(2) - 1.0)
+      bp = []
+      if quadrant.odd? # quadrant is odd
+        # (1,0)
+        bp << make_loc(x + (rx * SIGNS[quadrant - 1].x), y)
+        # (1,a)
+        bp << make_loc(bp[0].x, y + (a * ry * SIGNS[quadrant - 1].y))
+        # (a,1)
+        bp << make_loc(x + (a * rx * SIGNS[quadrant - 1].x), y + (ry * SIGNS[quadrant - 1].y))
+        # (0,1)
+        bp << make_loc(x, bp[2].y)
+      else # quadrant is even
+        # (0,1)
+        bp << make_loc(x, y + (ry * SIGNS[quadrant - 1].y))
+        # (a,1)
+        bp << make_loc(x + (a * rx * SIGNS[quadrant - 1].x), bp[0].y)
+        # (1,a)
+        bp << make_loc(x + (rx * SIGNS[quadrant - 1].x), y + (a * ry * SIGNS[quadrant - 1].y))
+        # (1,0)
+        bp << make_loc(bp[2].x, y)
+      end
+      bp
+    end
+
+    def rotate_xy_coordinate(x, y, angle)
+      theta = angle.degrees
+      r_cos = Math::cos(theta)
+      r_sin = Math::sin(theta)
+      x_rot = (r_cos * x) - (r_sin * y)
+      y_rot = (r_sin * x) + (r_cos * y)
+      [x_rot, y_rot]
+    end
+
+  	def rotate_point(loc, angle)
+  		x, y = rotate_xy_coordinate(loc.x, loc.y, angle)
+  		make_loc(x, y)
+  	end
+
+    def add_vector(point, angle, distance)
+      theta = angle.degrees
+      Location.new(point.x + Math::cos(theta) * distance, point.y + Math::sin(theta) * distance)
+    end
+
+  	def rotate_points(mid, points, angle)
+      theta = angle.degrees
+      r_cos = Math::cos(theta)
+      r_sin = Math::sin(theta)
+  	  points.map do |p|
+  	    x, y = p.x - mid.x, p.y - mid.y
+        x_rot = (r_cos * x) - (r_sin * y)
+        y_rot = (r_sin * x) + (r_cos * y)
+  	    make_loc(x_rot + mid.x, y_rot + mid.y)
+      end
+    end
+
+    def calc_arc_small(r, mid_theta, half_angle, ccwcw)
+      half_theta = half_angle.abs.degrees
+      v_cos = Math::cos(half_theta)
+      v_sin = Math::sin(half_theta)
+
+      x0 = r * v_cos
+      y0 = -ccwcw * r * v_sin
+      x1 = r * (4.0 - v_cos) / 3.0
+      x2 = x1
+      y1 = r * ccwcw * (1.0 - v_cos) * (v_cos - 3.0) / (3.0 * v_sin)
+      y2 = -y1
+      x3 = r * v_cos
+      y3 = ccwcw * r * v_sin
+
+      x0, y0 = rotate_xy_coordinate(x0, y0, mid_theta)
+      x1, y1 = rotate_xy_coordinate(x1, y1, mid_theta)
+      x2, y2 = rotate_xy_coordinate(x2, y2, mid_theta)
+      x3, y3 = rotate_xy_coordinate(x3, y3, mid_theta)
+
+      [x0, y0, x1, y1, x2, y2, x3, y3]
+    end
+
+    def points_for_arc_small(x, y, r, mid_theta, half_angle, ccwcw)
+      x0, y0, x1, y1, x2, y2, x3, y3 = calc_arc_small(r, mid_theta, half_angle, ccwcw)
+      [make_loc(x+x0, y-y0), make_loc(x+x1, y-y1), make_loc(x+x2, y-y2), make_loc(x+x3, y-y3)]
+    end
+
+    def arc_small(x, y, r, mid_theta, half_angle, ccwcw, move_to0)
+      x0, y0, x1, y1, x2, y2, x3, y3 = calc_arc_small(r, mid_theta, half_angle, ccwcw)
+      line_to(x+x0, y-y0) unless move_to0
+      curve(x+x0, y-y0, x+x1, y-y1, x+x2, y-y2, x+x3, y-y3)
+    end
+
+    def set_text_angle(angle, x, y)
+      theta = angle.degrees
+      v_cos = Math::cos(theta)
+      v_sin = Math::sin(theta)
+      @tw.set_matrix(v_cos, v_sin, -v_sin, v_cos, to_points(@units, x), to_points(@units, y))
+      @text_angle = angle
+    end
+
+    def rgb_from_color(color)
+      color = named_colors[color] || 0 if color.respond_to? :to_str
+      color ||= 0
+      b = color & 0xFF
+      g = (color >> 8) & 0xFF
+      r = (color >> 16) & 0xFF
+      [r, g, b]
+    end
+
+    def color_from_rgb(r, g, b)
+      (r << 16) | (g << 8) | b
+    end
+  protected
+    def start_text
+      raise Exception.new("Already in text.") if @in_text
+      raise Exception.new("Not in page.") unless @doc.in_page
+      end_graph if @in_graph
+      @last_loc = Location.new(0, 0)
+      @in_text = true
+      @tw = TextWriter.new(@stream)
+      @tw.open
+      @tw
+    end
+
+    def end_text
+      raise Exception.new("Not in text.") unless @in_text
+      @tw.close
+      @in_text = false
+    end
+
+    def start_graph
+      raise Exception.new("Already in graph") if @in_graph
+      end_text if @in_text
+      @last_loc = Location.new(0, 0)
+      @in_graph = true
+      @gw = GraphWriter.new(@stream)
+    end
+
+    def end_path
+      gw.stroke if @auto_path
+      @in_path = false
+    end
+
+    def end_graph
+      raise Exception.new("Not in graph") unless @in_graph
+      end_path if @in_path
+      @gw = nil
+      @in_graph = false
+    end
+
+    def start_misc
+      raise Exception.new("Already in misc") if @in_misc
+      @in_misc = true
+      @mw = MiscWriter.new(@stream)
+    end
+
+    def end_misc
+      raise Exception.new("Not in misc") unless @in_misc
+      @mw = nil
+      @in_misc = false
+    end
+
+    def tw
+      @tw ||= start_text
+    end
+
+    def gw
+      @gw ||= start_graph
+    end
+
+    def mw
+      @mw ||= start_misc
+    end
+
+    def end_margins
+      end_path if @in_path
+      gw.restore_graphics_state
+    end
+
+    def end_sub_page
+      end_path if @in_path
+      gw.restore_graphics_state
+    end
+
+    def sub_orientation(pages_across, pages_down)
+      @page_width / pages_across > @page_height / pages_down ? :landscape : :portrait
+    end
+
+    # font methods
+    def set_default_font
+      font(@default_font[:name], @default_font[:size], @default_font)
+      @font
+    end
+
+    def check_set_font
+      set_default_font if @font.nil?
+      if (@last_page_font != @page_font) or (@last_font != @font)
+        @tw.set_font_and_size(@page_font, @font.size)
+        check_set_v_text_align(true)
+        @last_page_font = @page_font
+        @last_font = @font
+      end
+    end
+
+    def check_set_v_text_align(force=false)
+      if force or @last_v_text_align != @v_text_align
+        @v_text_align_pts = case @v_text_align
+        when :above  then -@font.height * 0.001 * @font.size
+        when :top    then -@font.ascent * 0.001 * @font.size
+        when :middle then -@font.ascent * 0.001 * @font.size / 2.0
+        when :below  then -@font.descent * 0.001 * @font.size
+        else 0.0 # :base
+        end
+        @tw.set_rise(@v_text_align_pts)
+        @last_v_text_align = @v_text_align
+      end
+    end
+    
+    def check_set_spacing
+      unless @word_spacing == @last_word_spacing
+        tw.set_word_spacing(@word_spacing)
+        @last_word_spacing = @word_spacing
+      end
+      unless @char_spacing == @last_char_spacing
+        tw.set_char_spacing(@char_spacing)
+        @last_char_spacing = @char_spacing
+      end
+    end
+
+    def check_set_scale
+      unless @scale == @last_scale
+        tw.set_horiz_scaling(@scale * 100)
+        @last_scale = @scale
+      end
+    end
+
+    def text_rendering_mode(options)
+      if options[:fill] and options[:stroke]
+        @text_rendering_mode = 2
+      elsif options[:stroke]
+        @text_rendering_mode = 1
+      elsif options[:fill]
+        @text_rendering_mode = 0
+      elsif options[:invisible]
+        @text_rendering_mode = 3 # Why is this an option in PDF?
+      else
+        @text_rendering_mode = 0
+      end
+    end
+
+    def text_clipping_mode(options)
+      if options[:fill] and options[:stroke]
+        @text_rendering_mode = 6
+      elsif options[:stroke]
+        @text_rendering_mode = 5
+      elsif options[:fill]
+        @text_rendering_mode = 4
+      else
+        @text_rendering_mode = 7
+      end
+    end
+
+    def check_set_text_rendering_mode
+      unless @text_rendering_mode == @last_text_rendering_mode
+        tw.set_rendering_mode(@text_rendering_mode)
+        @last_text_rendering_mode = @text_rendering_mode
+      end
+    end
+
+    # color methods
+    def check_set_line_color
+      unless @line_color == @last_line_color
+        r, g, b = rgb_from_color(@line_color)
+        if @in_path and @auto_path
+          gw.stroke
+          @in_path = false
+        end
+        if @in_misc
+          mw.set_rgb_color_stroke(r / 255.0, g / 255.0, b / 255.0)
+          @last_line_color = @line_color
+        end
+      end
+    end
+
+    def check_set_fill_color
+      unless @fill_color == @last_fill_color
+        r, g, b = rgb_from_color(@fill_color)
+        if @in_path and @auto_path
+          gw.stroke
+          @in_path = false
+        end
+        if @in_misc
+          mw.set_rgb_color_fill(r / 255.0, g / 255.0, b / 255.0)
+          @last_fill_color = @fill_color
+        end
+      end
+    end
+
+    def check_set_font_color
+      unless @font_color == @last_fill_color
+        r, g, b = rgb_from_color(@font_color)
+        if @in_path and @auto_path
+          gw.stroke
+          @in_path = false
+        end
+        if @in_misc
+          mw.set_rgb_color_fill(r / 255.0, g / 255.0, b / 255.0)
+          @last_fill_color = @font_color
+        end
+      end
+    end
+
+    def check_set_line_dash_pattern
+      unless [@line_dash_pattern, @line_cap_style] == [@last_line_dash_pattern, @last_line_cap_style]
+        if @in_path and @auto_path
+          gw.stroke
+          @in_path = false
+        end
+
+        if @line_dash_pattern.is_a?(Symbol)
+          dashes = (LINE_PATTERNS[@line_dash_pattern] || []).map { |p| p * @line_width.round }
+          pattern = gw.make_line_dash_pattern(dashes, 0)
+        else
+          pattern = @line_dash_pattern.to_s
+        end
+
+        gw.set_line_dash_pattern(pattern)
+        @last_line_dash_pattern = @line_dash_pattern
+
+        gw.set_line_cap_style(LINE_CAP_STYLES.index(@line_cap_style) || 0)
+        @last_line_cap_style = @line_cap_style
+      end
+    end
+
+    def check_set_line_width
+      unless @line_width == @last_line_width
+        if @in_path and @auto_path
+          gw.stroke
+          @in_path = false
+        end
+
+        gw.set_line_width(@line_width)
+        @last_line_width = @line_width
+        @last_line_dash_pattern = nil if @last_line_dash_pattern.is_a?(Symbol)
+      end      
+    end
+
+    def check_set(*options)
+      check_set_line_color          if options.include?(:line_color)
+      check_set_fill_color          if options.include?(:fill_color)
+      check_set_line_width          if options.include?(:line_width)
+      check_set_line_dash_pattern   if options.include?(:line_dash_pattern)
+      check_set_font                if options.include?(:font)
+      check_set_font_color          if options.include?(:font_color)
+      check_set_v_text_align        if options.include?(:v_text_align)
+      check_set_spacing             if options.include?(:spacing)
+      check_set_scale               if options.include?(:scale)
+      check_set_text_rendering_mode if options.include?(:text_rendering_mode)
+    end
+
+    def line_colors
+      @line_colors ||= ColorStack.new(self, :line_color)
+    end
+
+    def fill_colors
+      @fill_colors ||= ColorStack.new(self, :fill_color)
+    end
+
+    def auto_stroke_and_fill(options)
+      if @auto_path
+        gw.clip if options[:clip]
+        if (options[:stroke] and options[:fill])
+          gw.fill_and_stroke
+        elsif options[:stroke] then
+          gw.stroke
+        elsif options[:fill] then
+          gw.fill
+        else
+          gw.new_path
+        end
+        @in_path = false
+      end
+    end
+
+    # protected drawing methods
+    def draw_rounded_rectangle(x, y, width, height, options)
+      corners = options[:corners] || []
+      if corners.size == 1
+        xr1 = yr1 = xr2 = yr2 = xr3 = yr3 = xr4 = yr4 = corners[0]
+      elsif corners.size == 2
+        xr1 = yr1 = xr2 = yr2 = corners[0]
+        xr3 = yr3 = xr4 = yr4 = corners[1]
+      elsif corners.size == 4
+        xr1 = yr1 = corners[0]
+        xr2 = yr2 = corners[1]
+        xr3 = yr3 = corners[2]
+        xr4 = yr4 = corners[3]
+      elsif corners.size == 8
+        xr1, yr1, xr2, yr2, xr3, yr3, xr4, yr4 = corners
+      else
+        xr1 = yr1 = xr2 = yr2 = xr3 = yr3 = xr4 = yr4 = 0
+      end
+
+      q2p = get_quadrant_bezier_points(2, x         + xr1, y          + yr1, xr1, yr1)
+      q1p = get_quadrant_bezier_points(1, x + width - xr2, y          + yr2, xr2, yr2)
+      q4p = get_quadrant_bezier_points(4, x + width - xr3, y + height - yr3, xr3, yr3)
+      q3p = get_quadrant_bezier_points(3, x         + xr4, y + height - yr4, xr4, yr4)
+
+      qpa = [q1p, q2p, q3p, q4p]
+      if options[:reverse]
+        qpa.reverse!
+        qpa.each { |qp| qp.reverse! }
+      end
+
+      curve_points(qpa[0]); line_to(qpa[1][0].x, qpa[1][0].y)
+      curve_points(qpa[1]); line_to(qpa[2][0].x, qpa[2][0].y)
+      curve_points(qpa[2]); line_to(qpa[3][0].x, qpa[3][0].y)
+      curve_points(qpa[3]); line_to(qpa[0][0].x, qpa[0][0].y)
+    end
+    
+    def draw_rectangle_path(x, y, width, height, options)
+      move_to(x, y)
+      if options[:reverse]
+        line_to(x, y + height)
+        line_to(x + width, y + height)
+        line_to(x + width, y)
+      else
+        line_to(x + width, y)
+        line_to(x + width, y + height)
+        line_to(x, y + height)
+      end
+      line_to(x, y)
+    end
+
+    def draw_underline(pos1, pos2, position, thickness, angle)
+      # position and thickness are in points
+      if @units != :pt
+        pos1, pos2 = convert_units(pos1, @units, :pt), convert_units(pos2, @units, :pt)
+      end
+      save_units = units(:pt)
+      save_line_width = line_width(thickness)
+      off_x, off_y = rotate_xy_coordinate(0, position - @v_text_align_pts, angle)
+      move_to(pos1.x - off_x, pos1.y + off_y)
+      line_to(pos2.x - off_x, pos2.y + off_y)
+      line_width(save_line_width)
+      units(save_units)
+    end
+
+  public
+    DEFAULT_FONT = { :name => 'Helvetica', :size => 12 }
+
+    attr_reader :doc, :page
+    attr_reader :stream, :annotations
+    attr_reader :auto_path
+
+    def initialize(doc, options)
+      # doc: PdfDocumentWriter
+      @doc = doc
+      @options = options
+      @page_style = PageStyle.new(options)
+      @units = options[:units] || :pt
+      @v_text_align = options[:v_text_align] || :top
+      @page_width = @page_style.page_size.x2
+      @page_height = @page_style.page_size.y2
+      if @page = options[:_page]
+        @reused_page = true
+      else
+        @page = PdfObjects::PdfPage.new(@doc.next_seq, 0, @doc.catalog.pages)
+        @page.media_box = @page_style.page_size.clone
+        @page.crop_box = @page_style.crop_size.clone
+        @page.rotate = @page_style.rotate
+        @page.resources = @doc.resources
+        @doc.file.body << @page
+      end
+      @stream = ''
+      @annotations = []
+      @char_spacing = @word_spacing = 0.0
+      @last_char_spacing = @last_word_spacing = 0.0
+      @last_scale = @scale = 1.0
+      @last_text_rendering_mode = @text_rendering_mode = 0
+      @default_font = options[:font] || DEFAULT_FONT
+      @font_color = @default_font[:color] || 0
+      @fill_color = options[:fill_color] || 0xFFFFFF
+      @line_color = options[:line_color] || 0
+      @line_height = options[:line_height] || 1.7
+      line_width(options[:line_width] || 1.0, :pt)
+      @text_angle = 0.0
+      @auto_path = true
+      @underline = false
+      start_misc
+      sub_page(*options[:sub_page] + Array(options[:unscaled])) if options[:sub_page]
+      margins(options[:margins] || 0)
+      text_encoding(options[:text_encoding])
+      @indent = 0
+    end
+
+    def close
+      end_margins unless @matrix.nil?
+      end_sub_page unless @sub_page.nil?
+      end_text if @in_text
+      end_graph if @in_graph
+      end_misc if @in_misc
+      pdf_stream = if @options[:compress]
+        require 'zlib'
+        zipper = Zlib::Deflate.new
+        zstream = zipper.deflate(@stream, Zlib::FINISH)
+        zpdf_stream = PdfObjects::PdfStream.new(@doc.next_seq, 0, zstream)
+        zpdf_stream.filter = 'FlateDecode'
+        zpdf_stream
+      else
+        PdfObjects::PdfStream.new(@doc.next_seq, 0, @stream)
+      end
+      @doc.file.body << pdf_stream
+      @page.annots = @annotations if @annotations.size.nonzero?
+      @page.contents << pdf_stream
+      @doc.catalog.pages.kids << @page unless @reused_page
+      @stream = nil
+    end
+
+    def closed?
+      @stream.nil?
+    end
+
+    def units(units=nil)
+      return @units if units.nil? or units == @units
+      @loc = convert_units(@loc, @units, units)
+      @last_loc = convert_units(@last_loc, @units, units) unless @last_loc.nil?
+      prev_units, @units = @units, units
+      prev_units
+    end
+
+    def margins(*margins)
+      @margins ||= [0] * 4
+      return @margins.map { |m| from_points(@units, m) } unless [4,2,1].include?(margins.size)
+      margins = margins.first if margins.first.is_a?(Array)
+      @margins = case margins.size
+        when 4 then margins
+        when 2 then margins * 2
+        when 1 then margins * 4
+        else @margins
+        end.map { |m| to_points(@units, m) }
+      @margin_top, @margin_right, @margin_bottom, @margin_left = @margins
+      if (@matrix || IDENTITY_MATRIX)[4..5] != [@margin_left, -@margin_top]
+        if @matrix.nil?
+          @matrix = IDENTITY_MATRIX.dup
+        else
+          gw.restore_graphics_state
+        end
+        @matrix[4..5] = [@margin_left, -@margin_top]
+        gw.save_graphics_state
+        gw.concat_matrix(*@matrix)
+      end
+      @canvas_width = @page_width - @margin_left - @margin_right
+      @canvas_height = @page_height - @margin_top - @margin_bottom
+      move_to(0, 0)
+      nil
+    end
+
+    def page_width
+      from_points(@units, @page_width)
+    end
+
+    def page_height
+      from_points(@units, @page_height)
+    end
+
+    def margin_top
+      from_points(@units, @margin_top)
+    end
+
+    def margin_right
+      from_points(@units, @margin_right)
+    end
+
+    def margin_bottom
+      from_points(@units, @margin_bottom)
+    end
+
+    def margin_left
+      from_points(@units, @margin_left)
+    end
+
+    def canvas_width
+      from_points(@units, @canvas_width)
+    end
+
+    def canvas_height
+      from_points(@units, @canvas_height)
+    end
+
+    def tabs(tabs=nil)
+      return @tabs if tabs.nil?
+      return @tabs = nil if tabs == false or tabs.empty?
+      tabs = tabs.split(',') if tabs.respond_to?(:to_str)
+      @tabs = tabs.map { |stop| stop.to_f }.select { |stop| stop > 0 }.sort
+    end
+
+    def tab(&block)
+      return if @tabs.nil?
+      p = pen_pos
+      x = @tabs.detect { |stop| stop > p.x }
+      if x.nil?
+        dy = block_given? ? yield : height
+        move_to(@tabs.first, p.y + dy)
+      else
+        move_to(x, p.y)
+      end
+    end
+
+    def vtabs(tabs=nil)
+      return @vtabs if tabs.nil?
+      return @vtabs = nil if tabs == false or tabs.empty?
+      tabs = tabs.split(',') if tabs.respond_to?(:to_str)
+      @vtabs = tabs.map { |stop| stop.to_f }.select { |stop| stop > 0 }.sort
+    end
+
+    def vtab(&block)
+      return if @vtabs.nil?
+      p = pen_pos
+      y = @vtabs.detect { |stop| stop > p.y }
+      if y.nil?
+        move_to(p.x + yield, @vtabs.first) if block_given?
+      else
+        move_to(p.x, y)
+      end
+    end
+
+    def indent(value=nil, absolute=false)
+      return @indent if value.nil?
+      prev_indent, @indent = @indent, absolute ? value : @indent + value
+      @loc.x = @indent
+      prev_indent
+    end
+
+    def sub_page(x, pages_across, y, pages_down, unscaled=false)
+      unless @matrix.nil?
+        gw.restore_graphics_state
+        @matrix = nil
+      end
+      gw.restore_graphics_state unless @sub_page.nil?
+      return unless x && pages_across && y && pages_down
+      if unscaled
+        @canvas_width = @page_width.quo(pages_across)
+        @canvas_height = @page_height.quo(pages_down)
+        @sub_page = IDENTITY_MATRIX.dup
+        @sub_page[4] = @canvas_width * x
+        @sub_page[5] = @canvas_height * (pages_down - 1 - y)
+      else
+        ps = PageStyle.new(@options.merge(:orientation => sub_orientation(pages_across, pages_down)))
+        width = ps.page_size.x2
+        height = ps.page_size.y2
+
+        ratio_w = @page_width.quo(pages_across * width)
+        ratio_h = @page_height.quo(pages_down * height)
+        ratio = [ratio_w, ratio_h].min
+        @sub_page = IDENTITY_MATRIX.dup
+        @sub_page[0] = ratio
+        @sub_page[3] = ratio
+        @sub_page[4] = @page_width.quo(pages_across) * x
+        @sub_page[5] = @page_height.quo(pages_down) * (pages_down - 1 - y)
+        if ratio_w >= ratio_h
+          @page_width, @page_height = width, height
+        else
+          @page_width, @page_height = width, width / ratio_w
+        end
+      end
+
+      gw.save_graphics_state
+      gw.concat_matrix(*@sub_page)
+      @last_font = @last_page_font = nil
+    end
+
+    def move_to(x, y)
+      @loc = translate(x, y)
+      nil
+    end
+
+    def pen_pos(x=nil, y=nil)
+      return translate(@loc.x, @loc.y) if x.nil?
+      prev_loc = translate(@loc.x, @loc.y)
+      move_to(x, y)
+      prev_loc
+    end
+
+    def move_by(dx, dy)
+      p = pen_pos
+      move_to(p.x + dx, p.y + dy)
+    end
+
+    def line_to(x, y)
+      unless @last_loc == @loc
+        gw.stroke if @in_path and @auto_path
+        @in_path = false
+      end
+
+      check_set(:line_color, :line_width, :line_dash_pattern)
+
+      gw.move_to(to_points(@units, @loc.x), to_points(@units, @loc.y)) unless @in_path
+      move_to(x, y)
+      gw.line_to(to_points(@units, @loc.x), to_points(@units, @loc.y))
+      @in_path = true
+      @last_loc = @loc.clone
+      nil
+    end
+
+    def line(x, y, angle, length)
+      lx, ly = rotate_xy_coordinate(1, 0, angle)
+      move_to(x, y)
+      line_to(x + lx * length, y - ly * length)
+    end
+
+    def rectangle(x, y, width, height, options={}, &block)
+      border = options[:border].nil? ? true : options[:border]
+      fill = options[:fill].nil? ? false : options[:fill]
+      clip = options[:clip].nil? ? false : options[:clip] && block_given?
+      gw.stroke if @in_path and @auto_path
+
+      line_colors.push(border)
+      fill_colors.push(fill)
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+
+      if options[:corners]
+        draw_rounded_rectangle(x, y, width, height, options)
+      elsif options[:path] or options[:reverse]
+        draw_rectangle_path(x, y, width, height, options)
+      else
+        gw.rectangle(
+          to_points(@units, x),
+          @page_height - to_points(@units, y + height),
+          to_points(@units, width),
+          to_points(@units, height))
+      end
+
+      gw.save_graphics_state if clip
+      auto_stroke_and_fill(:stroke => border, :fill => fill, :clip => clip)
+      yield if block_given?
+      gw.restore_graphics_state if clip
+      line_colors.pop
+      fill_colors.pop
+      move_to(x + width, y)
+      nil
+    end
+
+    def curve(x0, y0, x1, y1, x2, y2, x3, y3)
+      move_to(x0, y0)
+      unless @last_loc == @loc
+        if @in_path and @auto_path
+          gw.stroke
+          @in_path = false
+        end
+      end
+      check_set(:line_color, :line_width, :line_dash_pattern)
+
+      gw.move_to(to_points(@units, @loc.x), to_points(@units, @loc.y)) unless @in_path
+      gw.curve_to(
+          to_points(@units, x1),
+          @page_height - to_points(@units, y1),
+          to_points(@units, x2),
+          @page_height - to_points(@units, y2),
+          to_points(@units, x3),
+          @page_height - to_points(@units, y3))
+      move_to(x3, y3)
+      @last_loc = @loc.clone
+      @in_path = true
+    end
+
+    def curve_points(points)
+      raise Exception.new("Need at least 4 points for curve") if points.size < 4
+      move_to(points[0].x, points[0].y)
+      unless @last_loc == @loc
+        if @in_path and @auto_path
+          gw.stroke
+          @in_path = false
+        end
+      end
+
+      check_set(:line_color, :line_width, :line_dash_pattern)
+
+      gw.move_to(to_points(@units, @loc.x), to_points(@units, @loc.y)) unless (@loc == @last_loc) and @in_path
+      i = 1
+      while i + 2 < points.size
+        gw.curve_to(
+          to_points(@units, points[i].x),
+          @page_height - to_points(@units, points[i].y),
+          to_points(@units, points[i+1].x),
+          @page_height - to_points(@units, points[i+1].y),
+          to_points(@units, points[i+2].x),
+          @page_height - to_points(@units, points[i+2].y)
+        )
+        move_to(points[i+2].x, points[i+2].y)
+        @last_loc = @loc.clone
+        i += 3
+      end
+      @in_path = true
+    end
+
+    # def curve_to(points)
+    # end
+
+    def points_for_circle(x, y, r)
+      points = (1..4).inject([]) { |points, q| points + get_quadrant_bezier_points(q, x, y, r) }
+      [12,8,4].each { |i| points.delete_at(i) }
+      points
+    end
+
+    def circle(x, y, r, options={}, &block)
+      border = options[:border].nil? ? true : options[:border]
+      fill = options[:fill].nil? ? false : options[:fill]
+      clip = options[:clip].nil? ? false : options[:clip] && block_given?
+
+      line_colors.push(border)
+      fill_colors.push(fill)
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+
+      points = points_for_circle(x, y, r)
+      points.reverse! if options[:reverse]
+      curve_points(points)
+
+      gw.save_graphics_state if clip
+      auto_stroke_and_fill(:stroke => border, :fill => fill, :clip => clip)
+      yield if block_given?
+      gw.restore_graphics_state if clip
+      line_colors.pop
+      fill_colors.pop
+      nil
+    end
+
+    def points_for_ellipse(x, y, rx, ry)
+      points = (1..4).inject([]) { |points, q| points + get_quadrant_bezier_points(q, x, y, rx, ry) }
+      [12,8,4].each { |i| points.delete_at(i) }
+      points
+    end
+
+    def ellipse(x, y, rx, ry, options={}, &block)
+      rotation = options[:rotation] || 0
+      border = options[:border].nil? ? true : options[:border]
+      fill = options[:fill].nil? ? false : options[:fill]
+      clip = options[:clip].nil? ? false : options[:clip] && block_given?
+
+      line_colors.push(border)
+      fill_colors.push(fill)
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+
+      points = points_for_ellipse(x, y, rx, ry)
+      points = rotate_points(make_loc(x, y), points, -rotation)
+      points.reverse! if options[:reverse]
+      curve_points(points)
+
+      gw.save_graphics_state if clip
+      auto_stroke_and_fill(:stroke => border, :fill => fill, :clip => clip)
+      yield if block_given?
+      gw.restore_graphics_state if clip
+      line_colors.pop
+      fill_colors.pop
+      nil
+    end
+
+    def points_for_arc(x, y, r, start_angle, end_angle)
+      return nil if start_angle == end_angle
+
+      num_arcs = 1
+      ccwcw = 1.0
+      arc_span = end_angle - start_angle
+      if end_angle < start_angle
+        ccwcw = -1.0
+      end
+      while arc_span.abs.quo(num_arcs) > 90.0
+        num_arcs += 1
+      end
+      angle_bump = arc_span.quo(num_arcs)
+      half_bump = 0.5 * angle_bump
+      cur_angle = start_angle + half_bump
+      points = []
+      num_arcs.times do |i|
+        points << points_for_arc_small(x, y, r, cur_angle, half_bump, ccwcw)
+        points.last.shift if i > 0
+        cur_angle = cur_angle + angle_bump
+      end
+      points.flatten
+    end
+
+    def arc(x, y, r, start_angle, end_angle, move_to0=false)
+      return if start_angle == end_angle
+
+      move_to0 = true unless @in_path
+      num_arcs = 1
+      ccwcw = 1.0
+      arc_span = end_angle - start_angle
+      if end_angle < start_angle
+        ccwcw = -1.0
+      end
+      while arc_span.abs.quo(num_arcs) > 90.0
+        num_arcs += 1
+      end
+      angle_bump = arc_span.quo(num_arcs)
+      half_bump = 0.5 * angle_bump
+      cur_angle = start_angle + half_bump
+      num_arcs.times do
+        arc_small(x, y, r, cur_angle, half_bump, ccwcw, move_to0)
+        move_to0 = false
+        cur_angle = cur_angle + angle_bump
+      end
+    end
+
+    def pie(x, y, r, start_angle, end_angle, options={})
+      border = options[:border].nil? ? true : options[:border]
+      fill = options[:fill].nil? ? false : options[:fill]
+      clip = options[:clip].nil? ? false : options[:clip] && block_given?
+      unless @last_loc == @loc
+        gw.stroke if @in_path and @auto_path
+        @in_path = false
+      end
+
+      line_colors.push(border)
+      fill_colors.push(fill)
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+
+      move_to(x, y)
+      gw.move_to(to_points(@units, @loc.x), to_points(@units, @loc.y))
+      @last_loc = @loc.clone
+      @in_path = true
+      start_angle, end_angle = end_angle, start_angle if options[:reverse]
+      arc(x, y, r, start_angle, end_angle)
+      line_to(x, y)
+
+      gw.save_graphics_state if clip
+      auto_stroke_and_fill(:stroke => border, :fill => fill, :clip => clip)
+      yield if block_given?
+      gw.restore_graphics_state if clip
+      line_colors.pop
+      fill_colors.pop
+      nil
+    end
+
+    def arch(x, y, r1, r2, start_angle, end_angle, options={}, &block)
+      return if start_angle == end_angle
+      start_angle, end_angle = end_angle, start_angle if options[:reverse]
+      border = options[:border].nil? ? true : options[:border]
+      fill = options[:fill].nil? ? false : options[:fill]
+      clip = options[:clip].nil? ? false : options[:clip] && block_given?
+      unless @last_loc == @loc
+        gw.stroke if @in_path and @auto_path
+        @in_path = false
+      end
+
+      line_colors.push(border)
+      fill_colors.push(fill)
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+      arc1 = points_for_arc(x, y, r1, start_angle, end_angle)
+      arc2 = points_for_arc(x, y, r2, end_angle, start_angle)
+      move_to(arc1.first.x, arc1.first.y)
+      gw.move_to(to_points(@units, @loc.x), to_points(@units, @loc.y))
+      curve_points(arc1)
+      line_to(arc2.first.x, arc2.first.y)
+      curve_points(arc2)
+      line_to(arc1.first.x, arc1.first.y)
+      
+      gw.save_graphics_state if clip
+      auto_stroke_and_fill(:stroke => border, :fill => fill, :clip => clip)
+      yield if block_given?
+      gw.restore_graphics_state if clip
+      line_colors.pop
+      fill_colors.pop
+      nil
+    end
+
+    def points_for_polygon(x, y, r, sides, options={})
+      step = 360.0 / sides
+      angle = step / 2 + 90
+      points = (0..sides).collect do
+        px, py = rotate_xy_coordinate(1, 0, angle)
+        angle += step
+        make_loc(x + px * r, y + py * r)
+      end
+      rotation = options[:rotation] || 0
+      points = rotate_points(make_loc(x, y), points, -rotation) unless rotation.zero?
+      points.reverse! if options[:reverse]
+      points
+    end
+
+    def polygon(x, y, r, sides, options={}, &block)
+      border = options[:border].nil? ? true : options[:border]
+      fill = options[:fill].nil? ? false : options[:fill]
+      clip = options[:clip].nil? ? false : options[:clip] && block_given?
+      unless @last_loc == @loc
+        gw.stroke if @in_path and @auto_path
+        @in_path = false
+      end
+
+      points = points_for_polygon(x, y, r, sides, options)
+      line_colors.push(border)
+      fill_colors.push(fill)
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+
+      points.each_with_index do |point, i|
+        if i == 0
+          move_to(point.x, point.y)
+        else
+          line_to(point.x, point.y)
+        end
+      end
+      gw.save_graphics_state if clip
+      auto_stroke_and_fill(:stroke => border, :fill => fill, :clip => clip)
+      yield if block_given?
+      gw.restore_graphics_state if clip
+      line_colors.pop
+      fill_colors.pop
+      nil
+    end
+
+    def star(x, y, r1, r2, points, options={}, &block)
+      return if points < 5
+      border = options[:border].nil? ? true : options[:border]
+      fill = options[:fill].nil? ? false : options[:fill]
+      clip = options[:clip].nil? ? false : options[:clip] && block_given?
+      unless @last_loc == @loc
+        gw.stroke if @in_path and @auto_path
+        @in_path = false
+      end
+
+      rotation = options[:rotation] || 0
+      r2 ||= (points - 2).quo(points * 1.5)
+      vertices1 = points_for_polygon(x, y, r1, points, options)
+      vertices2 = points_for_polygon(x, y, r2, points, options.merge(:rotation => rotation + (360.0 / points / 2)))
+      line_colors.push(border)
+      fill_colors.push(fill)
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+
+      move_to(vertices2[0].x, vertices2[0].y)
+      points.times do |i|
+        line_to(vertices1[i].x, vertices1[i].y)
+        line_to(vertices2[i+1].x, vertices2[i+1].y)
+      end
+      gw.save_graphics_state if clip
+      auto_stroke_and_fill(:stroke => border, :fill => fill, :clip => clip)
+      yield if block_given?
+      gw.restore_graphics_state if clip
+      line_colors.pop
+      fill_colors.pop
+      nil
+    end
+
+    def path(options={}, &block)
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+      stroke = options[:stroke].nil? ? false : options[:stroke]
+      fill = options[:fill].nil? ? false : options[:fill]
+      line_colors.push(stroke)
+      fill_colors.push(fill)
+      @auto_path = false
+      if block_given?
+        yield
+        if options[:fill] and options[:stroke]
+          gw.fill_and_stroke
+        elsif options[:stroke]
+          gw.stroke
+        elsif options[:fill]
+          gw.fill
+        else
+          gw.new_path
+        end
+        line_colors.pop
+        fill_colors.pop
+        @in_path = false
+        @auto_path = true
+      end
+    end
+
+    def fill
+      raise Exception.new("Not in graph") unless @in_graph
+      raise Exception.new("Not in path") unless @in_path
+
+      check_set(:fill_color)
+      gw.fill
+      line_colors.pop
+      fill_colors.pop
+      @in_path = false
+      @auto_path = true
+    end
+
+    def stroke
+      raise Exception.new("Not in graph") unless @in_graph
+      raise Exception.new("Not in path") unless @in_path
+
+      check_set(:line_color)
+      gw.stroke
+      line_colors.pop
+      fill_colors.pop
+      @in_path = false
+      @auto_path = true
+    end
+
+    def fill_and_stroke
+      raise Exception.new("Not in graph") unless @in_graph
+      raise Exception.new("Not in path") unless @in_path
+
+      check_set(:fill_color,:line_color)
+      gw.fill_and_stroke
+      line_colors.pop
+      fill_colors.pop
+      @in_path = false
+      @auto_path = true
+    end
+
+    def clip(options={}, &block)
+      gw.save_graphics_state
+      if @in_path
+        gw.clip
+        if options[:fill] and options[:stroke]
+          gw.fill_and_stroke
+        elsif options[:stroke]
+          gw.stroke
+        elsif options[:fill]
+          gw.fill
+        else
+          gw.new_path
+        end
+      end
+      save_text_rendering_mode = @text_rendering_mode
+      text_clipping_mode(options)
+      yield if block_given?
+      # gw.clip
+      gw.restore_graphics_state
+      @text_rendering_mode = save_text_rendering_mode
+      @in_path = false
+      @auto_path = true
+    end
+
+    def line_cap_style(style=nil)
+      return @line_cap_style || :butt_cap if style.nil?
+      prev_line_cap_style, @line_cap_style = @line_cap_style, style.to_sym if LINE_CAP_STYLES.include?(style.to_sym)
+      prev_line_cap_style
+    end
+
+    def line_dash_pattern(pattern=nil)
+      return @line_dash_pattern if pattern.nil?
+      prev_line_dash_pattern, @line_dash_pattern = @line_dash_pattern, pattern
+      prev_line_dash_pattern
+    end
+
+    def line_width(value=nil, units=nil)
+      return from_points(@units, @line_width || 0) if value.nil?
+      return from_points(value, @line_width || 0) if value.is_a?(Symbol)
+      prev_line_width = @line_width || 0
+      if !units.nil?
+        u, value = units.to_sym, value.to_f
+      elsif value.respond_to?(:to_str) and value =~ /\D+/
+        u, value = $&.to_sym, value.to_f
+      else
+        u = @units
+      end
+      @line_width = to_points(u, value)
+      from_points(@units, prev_line_width)
+    end
+
+    def line_height(height=nil)
+      return @line_height if height.nil?
+      prev_line_height, @line_height = @line_height, height
+      prev_line_height
+    end
+
+    def named_colors
+      @doc.named_colors
+    end
+
+    def line_color(color=nil)
+      return @line_color if color.nil?
+      if color.is_a?(Array)
+        r, g, b = color
+        prev_line_color, @line_color = @line_color, color_from_rgb(r, g, b)
+      else
+        prev_line_color, @line_color = @line_color, color
+      end
+      prev_line_color
+    end
+
+    def fill_color(color=nil)
+      return @fill_color if color.nil?
+      if color.is_a?(Array)
+        r, g, b = color
+        prev_fill_color, @fill_color = @fill_color, color_from_rgb(r, g, b)
+      else
+        prev_fill_color, @fill_color = @fill_color, color
+      end
+      prev_fill_color
+    end
+
+    def print(text, options={}, &block)
+      text = text.to_s
+      return if text.empty?
+      text = @ic.iconv(text) unless @ic.nil?
+      align = options[:align]
+      angle = options[:angle] || 0.0
+      @scale = options[:scale] || 1.0
+      prev_underline = underline(options[:underline]) unless options[:underline].nil?
+      prev_v_text_align = v_text_align(options[:v_text_align]) unless options[:v_text_align].nil?
+      clip = options[:clip] && block_given?
+      if clip
+        gw.save_graphics_state
+        text_clipping_mode(options)
+      end
+      start_text unless @in_text
+      check_set(:font, :font_color, :line_color, :v_text_align, :spacing, :scale, :text_rendering_mode)
+      ds = width(text, true)
+      if align
+        prev_loc = @loc.clone
+        @loc = case align
+        when :left then @loc
+        when :center then add_vector(@loc, angle + 180, ds.quo(2))
+        when :right then add_vector(@loc, angle + 180, ds)
+        end
+      end
+      if (@text_angle != angle) or (angle != 0.0)
+        set_text_angle(angle, @loc.x, @loc.y)
+      elsif @loc != @last_loc
+        tw.move_by(to_points(@units, @loc.x - @last_loc.x), to_points(@units, @loc.y - @last_loc.y))
+      end
+      tw.show(text)
+      # if @ic.nil?
+      #   tw.show(text)
+      # else
+      #   text = @ic.iconv(text)
+      #   tw.show_wide(text)
+      # end
+      @last_loc = @loc.clone
+      new_loc = (angle == 0.0) ? Location.new(@loc.x + ds, @loc.y) : add_vector(@loc, angle, ds)
+      draw_underline(translate_p(@last_loc), translate_p(new_loc), @font.underline_position, @font.underline_thickness, angle) if @underline
+      underline(prev_underline) unless options[:underline].nil?
+      v_text_align(prev_v_text_align) unless options[:v_text_align].nil?
+      @loc = align ? prev_loc : new_loc
+      if clip
+        yield
+        gw.restore_graphics_state
+      end
+      nil
+    end
+
+    def print_xy(x, y, text, options={}, &block)
+      move_to(x, y)
+      print(text, options, &block)
+    end
+
+    def puts(text='', options={}, &block)
+      # if it's not a real string, assume it's an enumeration of strings
+      unless text.respond_to?(:to_str)
+        text.each { |t| puts(t, options) }
+      else
+        prev_loc = @loc.clone
+        print(text, options, &block)
+        @loc = options[:indent] ? Location.new(prev_loc.x, prev_loc.y - height) : Location.new(@indent, prev_loc.y - height)
+      end
+      nil
+    end
+
+    def puts_xy(x, y, text, options={}, &block)
+      move_to(x, y)
+      prev_indent = indent(x, true)
+      puts(text, options, &block)
+      indent(prev_indent, true)
+      nil
+    end
+
+    def new_line(count=1)
+      @loc = Location.new(@indent, @loc.y - height * count)
+      nil
+    end
+
+    def width(text, encoded=false)
+      set_default_font if @font.nil?
+      result = 0.0
+      fsize = @font.size * 0.001
+      text = @ic.iconv(text) unless @ic.nil? or encoded
+      text.each_byte do |b|
+        result += fsize * @font.widths[b] + @char_spacing
+        result += @word_spacing if b == 32 # space
+      end
+      from_points(@units, result - @char_spacing)
+    end
+
+    def wrap(text, width)
+      re = /\n|\t|[ ]|[\S]+-+|[\S]+/
+      words = text.scan(re)
+      word_tuples = words.map { |word| [width(word), word] }
+      line_length = 0
+      lines = word_tuples.inject(['']) do |lines, tuple|
+        if tuple[1] == "\n"
+          lines << ''
+          line_length = 0
+        elsif line_length == 0
+          unless tuple[1] == ' '
+            lines.last << tuple[1]
+            line_length += tuple[0]
+          end
+        elsif line_length + tuple[0] > width
+          lines << ''
+          line_length = 0
+          redo
+        else          
+          lines.last << tuple[1]
+          line_length += tuple[0]
+        end
+        lines
+      end
+    end
+
+    def text_ascent(units=nil)
+      units ||= @units
+      set_default_font if @font.nil?
+      0.001 * @font.ascent * @font.size.quo(UNIT_CONVERSION[units])
+    end
+
+    def text_height(units=nil)
+      units ||= @units
+      set_default_font if @font.nil?
+      0.001 * @font.height * @font.size.quo(UNIT_CONVERSION[units])
+    end
+
+    def height(text='', units=nil)
+      units ||= @units
+      set_default_font if @font.nil?
+      if text.respond_to?(:to_str)
+        text_height(units) * @line_height
+      else
+        text.inject(0) { |total, line| total + height(line, units) }
+      end
+    end
+
+    def paragraph(text, options={})
+      width = options[:width] || canvas_width - pen_pos.x
+      height = options[:height] || canvas_height - pen_pos.y
+      if bul = bullet(options[:bullet])
+        save_loc = pen_pos
+        bul.proc.call(self)
+        move_to(save_loc.x + from_points(units, bul.width), save_loc.y)
+        width -= from_points(units, bul.width)
+      end
+      prev_underline, ul = @underline, options[:underline].nil? ? @underline : options[:underline]
+      unless text.is_a?(PdfText::RichText)
+        text = PdfText::RichText.new(text, font, :color => @font_color, 
+          :char_spacing => @char_spacing, :word_spacing => @word_spacing, 
+          :underline => ul)
+      end
+      dy = 0
+      while dy + from_points(@units, text.height) < height and line = text.next(to_points(@units, width))
+        save_loc = pen_pos
+        line_dy = line.height.quo(UNIT_CONVERSION[units]) * @line_height
+        case options[:align]
+        when :center then move_to(save_loc.x + (width - from_points(@units, line.width)) / 2.0, save_loc.y)
+        when :right then move_to(save_loc.x + width - from_points(@units, line.width), save_loc.y)
+        when :justify then
+          width_pt = to_points(@units, width)
+          delta_pt = width_pt - line.width
+          words = (line.tokens / 2) + 1
+          if delta_pt.abs.quo(width_pt) < 0.4
+            if words == 1
+              @word_spacing = 0
+              @char_spacing = delta_pt.quo(line.chars - 1)
+            elsif delta_pt.abs / words > 3
+              @word_spacing = 3
+              delta_pt -= (words - 1) * @word_spacing
+              @char_spacing = delta_pt.quo(line.chars - 1)
+            else
+              @word_spacing = delta_pt.quo(words - 1)
+              @char_spacing = 0
+            end
+          end
+        end
+        while piece = line.shift
+          font(piece.font)
+          font_color piece.color
+          underline piece.underline
+          print(piece.text)
+        end
+        @word_spacing = @char_spacing = 0.0 if options[:align] == :justify
+        dy += line_dy
+        move_to(save_loc.x, save_loc.y + line_dy)
+      end
+      underline(prev_underline)
+      move_by(-from_points(units, bul.width), 0) unless bul.nil?
+      return text.empty? ? nil : text
+    end
+
+    def paragraph_xy(x, y, text, options={})
+      move_to(x, y)
+      paragraph(text, options)
+    end
+
+    def v_text_align(vta=nil)
+      return @v_text_align if vta.nil?
+      prev_vta, @v_text_align = @v_text_align, vta
+      prev_vta
+    end
+
+    def underline(underline=nil)
+      return @underline if underline.nil?
+      prev_underline, @underline = @underline, underline
+      prev_underline
+    end
+
+    def type1_font_names
+      @doc.type1_font_names
+    end
+
+    def truetype_font_names
+      @doc.truetype_font_names
+    end
+
+    def select_font(name, size, options={})
+      unless @ic.nil?
+        @ic.close
+        @ic = nil
+      end
+      weight = options[:weight] || ''
+      style = weight + (options[:style] || '')
+      font = Font.new(name, size, style, options[:color], pdf_encoding(options[:encoding] || 'WinAnsiEncoding', name))
+      font.sub_type = options[:sub_type] || 'Type1'
+      punc = (font.sub_type == 'TrueType') ? ',' : '-'
+      full_name = name.gsub(' ','')
+      full_name << punc << font.style unless font.style.empty?
+      if @options[:built_in_fonts]
+        if font.sub_type == 'Type1'
+          metrics = PdfK::font_metrics(full_name)
+        elsif font.sub_type == 'TrueType'
+          metrics = PdfTT::font_metrics(full_name)
+        end
+      else
+        if font.sub_type == 'Type1'
+          weight = 'Bold' if weight.empty? and /Bold/i =~ style
+          afm = AFM::find_font(name, weight, style)
+          full_name = afm.font_name unless afm.nil?
+          metrics = AFM::font_metrics(full_name, :encoding => font.encoding)
+        elsif font.sub_type == 'TrueType'
+          raise Exception.new("Non-built-in TrueType fonts not supported yet.")
+        elsif font.sub_type == 'Type0'
+          # metrics = AFM::font_metrics(full_name, :encoding => :unicode)
+          # require 'iconv'
+          # @ic = Iconv.new('UCS-2BE', iconv_encoding(font.encoding))
+        else
+          raise Exception.new("Unsupported subtype #{font.sub_type}.")
+        end
+      end
+      unless text_encoding.nil? or (font.encoding == 'StandardEncoding') or (font.encoding == text_encoding)
+        @ic = Iconv.new(iconv_encoding(font.encoding)+'//IGNORE', iconv_encoding(text_encoding))
+      end
+      font.widths, font.ascent, font.descent = metrics.widths, metrics.ascent, metrics.descent
+      font.height = font.ascent + font.descent.abs
+      font.underline_position = metrics.underline_position * -0.001 * font.size
+      font.underline_thickness = metrics.underline_thickness * 0.001 * font.size
+      font_key = "#{full_name}/#{font.encoding}-#{font.sub_type}"
+      page_font = @doc.fonts[font_key]
+      unless page_font
+        widths = nil
+        if metrics.needs_descriptor
+          descriptor = PdfObjects::PdfFontDescriptor.new(@doc.next_seq, 0, full_name, metrics.flags, metrics.b_box, 
+            metrics.missing_width, metrics.stem_v, metrics.stem_h, metrics.italic_angle,
+            metrics.cap_height, metrics.x_height, metrics.ascent, metrics.descent, metrics.leading,
+            metrics.max_width, metrics.avg_width)
+          @doc.file.body << descriptor
+          widths = PdfObjects::IndirectObject.new(@doc.next_seq, 0, PdfObjects::PdfInteger.ary(metrics.widths))
+          @doc.file.body << widths
+        else
+          descriptor = nil
+          widths = nil
+        end
+        page_font = "F#{@doc.fonts.size}"
+        f = PdfObjects::PdfFont.new(@doc.next_seq, 0, font.sub_type, full_name, 0, 255, widths, descriptor)
+        @doc.file.body << f
+        if PdfObjects::PdfFont.standard_encoding?(font.encoding)
+          f.encoding = font.encoding
+        else
+          encoding = @doc.encodings[font.encoding]
+          if encoding.nil?
+            encoding = PdfObjects::PdfFontEncoding.new(@doc.next_seq, 0, 'WinAnsiEncoding', metrics.differences)
+            @doc.encodings[font.encoding] = encoding
+            @doc.file.body << encoding
+          end
+          f.encoding = encoding.reference_object
+          # raise Exception.new("Unsupported encoding #{font.encoding}")
+        end
+        @doc.resources.fonts[page_font] = f.reference_object
+        @doc.fonts[font_key] = page_font
+      end
+      font_color(options[:color]) if options[:color]
+      text_rendering_mode(options)
+      [font, page_font]
+    end
+
+    def font(name=nil, size=nil, options={})
+      return @font || set_default_font if name.nil?
+      prev_font = @font
+      if name.is_a?(Font)
+        @font = name
+        name, size = @font.name, @font.size
+        options.update(:style => @font.style, :color => @font.color, :encoding => @font.encoding, :sub_type => @font.sub_type)
+      end
+      size ||= @font.nil? ? @default_font[:size] : @font.size
+      @font, @page_font = select_font(name, size, options)
+      prev_font
+    end
+
+    def font_style(style=nil)
+      set_default_font if @font.nil?
+      return @font.style if style.nil?
+      prev_style = @font.style
+      font(@font.name, @font.size, :style => style, :color => @font.color, :encoding => @font.encoding, :sub_type => @font.sub_type)
+      prev_style
+    end
+
+    def font_size(size=nil)
+      set_default_font if @font.nil?
+      return @font.size if size.nil?
+      prev_size = @font.size
+      font(@font.name, size, :style => @font.style, :color => @font.color, :encoding => @font.encoding, :sub_type => @font.sub_type)
+      prev_size
+    end
+
+    def font_color(color=nil)
+      return @font_color if color.nil?
+      if color.is_a?(Array)
+        r, g, b = color
+        prev_font_color, @font_color = @font_color, color_from_rgb(r, g, b)
+      else
+        prev_font_color, @font_color = @font_color, color
+      end
+      @font.color = @font_color unless @font.nil?
+      prev_font_color
+    end
+
+    def font_encoding(encoding=nil)
+      set_default_font if @font.nil?
+      return @font.encoding if encoding.nil?
+      prev_encoding = @font.encoding
+      font(@font.name, @font.size, :style => @font.style, :color => @font.color, :encoding => encoding, :sub_type => @font.sub_type)
+      prev_encoding
+    end
+
+    def load_image(image_file_name, stream=nil)
+      image, name = @doc.images[image_file_name]
+      return [image, name] unless image.nil?
+      stream ||= open(image_file_name, ImageReadMode) { |io| io.read }
+      image = PdfObjects::PdfImage.new(@doc.next_seq, 0, stream)
+      image.width, image.height, components, image.bits_per_component = jpeg_dimensions(stream)
+      image.color_space = { 1 => 'DeviceGray', 3 => 'DeviceRGB', 4 => 'DeviceCMYK' }[components]
+      image.filter = 'DCTDecode'
+      name = "Im#{@doc.images.size}"
+      @doc.file.body << image
+      @doc.resources.x_objects[name] = image.reference_object
+      @doc.images[image_file_name] = [image, name]
+      [image, name]
+    end
+
+    def print_image_file(image_file_name, x=nil, y=nil, width=nil, height=nil)
+      image, name = load_image(image_file_name)
+      x ||= pen_pos.x
+      y ||= pen_pos.y
+      if width.nil? and height.nil?
+        width, height = image.width, image.height
+      elsif width.nil?
+        height = to_points(@units, height)
+        width = height * image.width.quo(image.height)
+      elsif height.nil?
+        width = to_points(@units, width)
+        height = width * image.height.quo(image.width)
+      else
+        width, height = to_points(@units, width), to_points(@units, height)
+      end
+      end_path if @in_path
+      gw.save_graphics_state
+      gw.concat_matrix(width, 0, 0, height, to_points(@units, x), to_points(@units, page_height - y) - height)
+      mw.x_object(name)
+      gw.restore_graphics_state
+      [from_points(@units, width), from_points(@units, height)]
+    end
+
+    def print_image(data, x=nil, y=nil, width=nil, height=nil)
+      image_file_name = data.hash.to_s
+      image, name = load_image(image_file_name, data)
+      print_image_file(image_file_name, x, y, width, height)
+    end
+
+    def print_link(s, uri)
+      # TODO
+    end
+
+    def bullet(name, options={}, &block)
+      return nil if name.nil?
+      return @doc.bullets[name.to_sym] unless block_given?
+      if width = options[:width]
+        units = options[:units] || self.units
+        width = to_points(units, width)
+      end          
+      @doc.bullets[name.to_sym] = Bullet.new(name.to_s, width || 36, block)
+    end
+
+    def rotate(angle, x, y, &block)
+      return unless block_given?
+      end_path if @in_path
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+
+      theta = angle.degrees
+      v_cos = Math::cos(theta)
+      v_sin = Math::sin(theta)
+
+      xx, xy = to_points(@units, x), @page_height - to_points(@units, y)
+      rot_x, rot_y = rotate_xy_coordinate(xx, xy, angle)
+      gw.save_graphics_state
+      gw.concat_matrix(v_cos, v_sin, -v_sin, v_cos, xx - rot_x, xy - rot_y)
+      @last_page_font = nil
+      yield
+      gw.restore_graphics_state
+      @last_page_font = nil
+    end
+
+    def scale(x, y, scale_x, scale_y, &block)
+      return unless x && scale_x && y && scale_y && block_given?
+      end_path if @in_path
+      check_set(:line_color, :line_width, :line_dash_pattern, :fill_color)
+      sub_area = IDENTITY_MATRIX.dup
+      # a: Sx (horizontal scaling, 1 unit in new is x units in old)
+      # b: 
+      # c: 
+      # d: Sy (vertical scaling, 1 unit in new is y units in old)
+      # e: Tx (horizontal translation of the origin)
+      # f: Ty (vertical translation of the origin)
+      sub_area[0] = scale_x
+      sub_area[3] = scale_y
+      sub_area[4] = to_points(@units, x)
+      sub_area[5] = to_points(@units, -y)
+      save_page_height = @page_height
+      @page_height = save_page_height.quo(scale_y)
+      gw.save_graphics_state
+      gw.concat_matrix(*sub_area)
+      @last_page_font = nil
+      yield
+      end_text if @in_text
+      end_graph if @in_graph
+      gw.restore_graphics_state
+      @last_page_font = nil
+      @page_height = save_page_height
+    end
+
+    def text_encoding(value=nil)
+      return @text_encoding if value.nil?
+      @text_encoding = value
+    end
+  end
+end