rhodes 3.3.3.beta.4 → 3.3.3

data/lib/extensions/pdf-writer/pdf/writer/fonts/ZapfDingbats.afm

@@ -0,0 +1,225 @@
+StartFontMetrics 4.1
+Comment Copyright (c) 1985, 1987, 1988, 1989, 1997 Adobe Systems Incorporated. All Rights Reserved.
+Comment Creation Date: Thu May  1 15:14:13 1997
+Comment UniqueID 43082
+Comment VMusage 45775 55535
+FontName ZapfDingbats
+FullName ITC Zapf Dingbats
+FamilyName ZapfDingbats
+Weight Medium
+ItalicAngle 0
+IsFixedPitch false
+CharacterSet Special
+FontBBox -1 -143 981 820 
+UnderlinePosition -100
+UnderlineThickness 50
+Version 002.000
+Notice Copyright (c) 1985, 1987, 1988, 1989, 1997 Adobe Systems Incorporated. All Rights Reserved.ITC Zapf Dingbats is a registered trademark of International Typeface Corporation.
+EncodingScheme FontSpecific
+StdHW 28
+StdVW 90
+StartCharMetrics 202
+C 32 ; WX 278 ; N space ; B 0 0 0 0 ;
+C 33 ; WX 974 ; N a1 ; B 35 72 939 621 ;
+C 34 ; WX 961 ; N a2 ; B 35 81 927 611 ;
+C 35 ; WX 974 ; N a202 ; B 35 72 939 621 ;
+C 36 ; WX 980 ; N a3 ; B 35 0 945 692 ;
+C 37 ; WX 719 ; N a4 ; B 34 139 685 566 ;
+C 38 ; WX 789 ; N a5 ; B 35 -14 755 705 ;
+C 39 ; WX 790 ; N a119 ; B 35 -14 755 705 ;
+C 40 ; WX 791 ; N a118 ; B 35 -13 761 705 ;
+C 41 ; WX 690 ; N a117 ; B 34 138 655 553 ;
+C 42 ; WX 960 ; N a11 ; B 35 123 925 568 ;
+C 43 ; WX 939 ; N a12 ; B 35 134 904 559 ;
+C 44 ; WX 549 ; N a13 ; B 29 -11 516 705 ;
+C 45 ; WX 855 ; N a14 ; B 34 59 820 632 ;
+C 46 ; WX 911 ; N a15 ; B 35 50 876 642 ;
+C 47 ; WX 933 ; N a16 ; B 35 139 899 550 ;
+C 48 ; WX 911 ; N a105 ; B 35 50 876 642 ;
+C 49 ; WX 945 ; N a17 ; B 35 139 909 553 ;
+C 50 ; WX 974 ; N a18 ; B 35 104 938 587 ;
+C 51 ; WX 755 ; N a19 ; B 34 -13 721 705 ;
+C 52 ; WX 846 ; N a20 ; B 36 -14 811 705 ;
+C 53 ; WX 762 ; N a21 ; B 35 0 727 692 ;
+C 54 ; WX 761 ; N a22 ; B 35 0 727 692 ;
+C 55 ; WX 571 ; N a23 ; B -1 -68 571 661 ;
+C 56 ; WX 677 ; N a24 ; B 36 -13 642 705 ;
+C 57 ; WX 763 ; N a25 ; B 35 0 728 692 ;
+C 58 ; WX 760 ; N a26 ; B 35 0 726 692 ;
+C 59 ; WX 759 ; N a27 ; B 35 0 725 692 ;
+C 60 ; WX 754 ; N a28 ; B 35 0 720 692 ;
+C 61 ; WX 494 ; N a6 ; B 35 0 460 692 ;
+C 62 ; WX 552 ; N a7 ; B 35 0 517 692 ;
+C 63 ; WX 537 ; N a8 ; B 35 0 503 692 ;
+C 64 ; WX 577 ; N a9 ; B 35 96 542 596 ;
+C 65 ; WX 692 ; N a10 ; B 35 -14 657 705 ;
+C 66 ; WX 786 ; N a29 ; B 35 -14 751 705 ;
+C 67 ; WX 788 ; N a30 ; B 35 -14 752 705 ;
+C 68 ; WX 788 ; N a31 ; B 35 -14 753 705 ;
+C 69 ; WX 790 ; N a32 ; B 35 -14 756 705 ;
+C 70 ; WX 793 ; N a33 ; B 35 -13 759 705 ;
+C 71 ; WX 794 ; N a34 ; B 35 -13 759 705 ;
+C 72 ; WX 816 ; N a35 ; B 35 -14 782 705 ;
+C 73 ; WX 823 ; N a36 ; B 35 -14 787 705 ;
+C 74 ; WX 789 ; N a37 ; B 35 -14 754 705 ;
+C 75 ; WX 841 ; N a38 ; B 35 -14 807 705 ;
+C 76 ; WX 823 ; N a39 ; B 35 -14 789 705 ;
+C 77 ; WX 833 ; N a40 ; B 35 -14 798 705 ;
+C 78 ; WX 816 ; N a41 ; B 35 -13 782 705 ;
+C 79 ; WX 831 ; N a42 ; B 35 -14 796 705 ;
+C 80 ; WX 923 ; N a43 ; B 35 -14 888 705 ;
+C 81 ; WX 744 ; N a44 ; B 35 0 710 692 ;
+C 82 ; WX 723 ; N a45 ; B 35 0 688 692 ;
+C 83 ; WX 749 ; N a46 ; B 35 0 714 692 ;
+C 84 ; WX 790 ; N a47 ; B 34 -14 756 705 ;
+C 85 ; WX 792 ; N a48 ; B 35 -14 758 705 ;
+C 86 ; WX 695 ; N a49 ; B 35 -14 661 706 ;
+C 87 ; WX 776 ; N a50 ; B 35 -6 741 699 ;
+C 88 ; WX 768 ; N a51 ; B 35 -7 734 699 ;
+C 89 ; WX 792 ; N a52 ; B 35 -14 757 705 ;
+C 90 ; WX 759 ; N a53 ; B 35 0 725 692 ;
+C 91 ; WX 707 ; N a54 ; B 35 -13 672 704 ;
+C 92 ; WX 708 ; N a55 ; B 35 -14 672 705 ;
+C 93 ; WX 682 ; N a56 ; B 35 -14 647 705 ;
+C 94 ; WX 701 ; N a57 ; B 35 -14 666 705 ;
+C 95 ; WX 826 ; N a58 ; B 35 -14 791 705 ;
+C 96 ; WX 815 ; N a59 ; B 35 -14 780 705 ;
+C 97 ; WX 789 ; N a60 ; B 35 -14 754 705 ;
+C 98 ; WX 789 ; N a61 ; B 35 -14 754 705 ;
+C 99 ; WX 707 ; N a62 ; B 34 -14 673 705 ;
+C 100 ; WX 687 ; N a63 ; B 36 0 651 692 ;
+C 101 ; WX 696 ; N a64 ; B 35 0 661 691 ;
+C 102 ; WX 689 ; N a65 ; B 35 0 655 692 ;
+C 103 ; WX 786 ; N a66 ; B 34 -14 751 705 ;
+C 104 ; WX 787 ; N a67 ; B 35 -14 752 705 ;
+C 105 ; WX 713 ; N a68 ; B 35 -14 678 705 ;
+C 106 ; WX 791 ; N a69 ; B 35 -14 756 705 ;
+C 107 ; WX 785 ; N a70 ; B 36 -14 751 705 ;
+C 108 ; WX 791 ; N a71 ; B 35 -14 757 705 ;
+C 109 ; WX 873 ; N a72 ; B 35 -14 838 705 ;
+C 110 ; WX 761 ; N a73 ; B 35 0 726 692 ;
+C 111 ; WX 762 ; N a74 ; B 35 0 727 692 ;
+C 112 ; WX 762 ; N a203 ; B 35 0 727 692 ;
+C 113 ; WX 759 ; N a75 ; B 35 0 725 692 ;
+C 114 ; WX 759 ; N a204 ; B 35 0 725 692 ;
+C 115 ; WX 892 ; N a76 ; B 35 0 858 705 ;
+C 116 ; WX 892 ; N a77 ; B 35 -14 858 692 ;
+C 117 ; WX 788 ; N a78 ; B 35 -14 754 705 ;
+C 118 ; WX 784 ; N a79 ; B 35 -14 749 705 ;
+C 119 ; WX 438 ; N a81 ; B 35 -14 403 705 ;
+C 120 ; WX 138 ; N a82 ; B 35 0 104 692 ;
+C 121 ; WX 277 ; N a83 ; B 35 0 242 692 ;
+C 122 ; WX 415 ; N a84 ; B 35 0 380 692 ;
+C 123 ; WX 392 ; N a97 ; B 35 263 357 705 ;
+C 124 ; WX 392 ; N a98 ; B 34 263 357 705 ;
+C 125 ; WX 668 ; N a99 ; B 35 263 633 705 ;
+C 126 ; WX 668 ; N a100 ; B 36 263 634 705 ;
+C 128 ; WX 390 ; N a89 ; B 35 -14 356 705 ;
+C 129 ; WX 390 ; N a90 ; B 35 -14 355 705 ;
+C 130 ; WX 317 ; N a93 ; B 35 0 283 692 ;
+C 131 ; WX 317 ; N a94 ; B 35 0 283 692 ;
+C 132 ; WX 276 ; N a91 ; B 35 0 242 692 ;
+C 133 ; WX 276 ; N a92 ; B 35 0 242 692 ;
+C 134 ; WX 509 ; N a205 ; B 35 0 475 692 ;
+C 135 ; WX 509 ; N a85 ; B 35 0 475 692 ;
+C 136 ; WX 410 ; N a206 ; B 35 0 375 692 ;
+C 137 ; WX 410 ; N a86 ; B 35 0 375 692 ;
+C 138 ; WX 234 ; N a87 ; B 35 -14 199 705 ;
+C 139 ; WX 234 ; N a88 ; B 35 -14 199 705 ;
+C 140 ; WX 334 ; N a95 ; B 35 0 299 692 ;
+C 141 ; WX 334 ; N a96 ; B 35 0 299 692 ;
+C 161 ; WX 732 ; N a101 ; B 35 -143 697 806 ;
+C 162 ; WX 544 ; N a102 ; B 56 -14 488 706 ;
+C 163 ; WX 544 ; N a103 ; B 34 -14 508 705 ;
+C 164 ; WX 910 ; N a104 ; B 35 40 875 651 ;
+C 165 ; WX 667 ; N a106 ; B 35 -14 633 705 ;
+C 166 ; WX 760 ; N a107 ; B 35 -14 726 705 ;
+C 167 ; WX 760 ; N a108 ; B 0 121 758 569 ;
+C 168 ; WX 776 ; N a112 ; B 35 0 741 705 ;
+C 169 ; WX 595 ; N a111 ; B 34 -14 560 705 ;
+C 170 ; WX 694 ; N a110 ; B 35 -14 659 705 ;
+C 171 ; WX 626 ; N a109 ; B 34 0 591 705 ;
+C 172 ; WX 788 ; N a120 ; B 35 -14 754 705 ;
+C 173 ; WX 788 ; N a121 ; B 35 -14 754 705 ;
+C 174 ; WX 788 ; N a122 ; B 35 -14 754 705 ;
+C 175 ; WX 788 ; N a123 ; B 35 -14 754 705 ;
+C 176 ; WX 788 ; N a124 ; B 35 -14 754 705 ;
+C 177 ; WX 788 ; N a125 ; B 35 -14 754 705 ;
+C 178 ; WX 788 ; N a126 ; B 35 -14 754 705 ;
+C 179 ; WX 788 ; N a127 ; B 35 -14 754 705 ;
+C 180 ; WX 788 ; N a128 ; B 35 -14 754 705 ;
+C 181 ; WX 788 ; N a129 ; B 35 -14 754 705 ;
+C 182 ; WX 788 ; N a130 ; B 35 -14 754 705 ;
+C 183 ; WX 788 ; N a131 ; B 35 -14 754 705 ;
+C 184 ; WX 788 ; N a132 ; B 35 -14 754 705 ;
+C 185 ; WX 788 ; N a133 ; B 35 -14 754 705 ;
+C 186 ; WX 788 ; N a134 ; B 35 -14 754 705 ;
+C 187 ; WX 788 ; N a135 ; B 35 -14 754 705 ;
+C 188 ; WX 788 ; N a136 ; B 35 -14 754 705 ;
+C 189 ; WX 788 ; N a137 ; B 35 -14 754 705 ;
+C 190 ; WX 788 ; N a138 ; B 35 -14 754 705 ;
+C 191 ; WX 788 ; N a139 ; B 35 -14 754 705 ;
+C 192 ; WX 788 ; N a140 ; B 35 -14 754 705 ;
+C 193 ; WX 788 ; N a141 ; B 35 -14 754 705 ;
+C 194 ; WX 788 ; N a142 ; B 35 -14 754 705 ;
+C 195 ; WX 788 ; N a143 ; B 35 -14 754 705 ;
+C 196 ; WX 788 ; N a144 ; B 35 -14 754 705 ;
+C 197 ; WX 788 ; N a145 ; B 35 -14 754 705 ;
+C 198 ; WX 788 ; N a146 ; B 35 -14 754 705 ;
+C 199 ; WX 788 ; N a147 ; B 35 -14 754 705 ;
+C 200 ; WX 788 ; N a148 ; B 35 -14 754 705 ;
+C 201 ; WX 788 ; N a149 ; B 35 -14 754 705 ;
+C 202 ; WX 788 ; N a150 ; B 35 -14 754 705 ;
+C 203 ; WX 788 ; N a151 ; B 35 -14 754 705 ;
+C 204 ; WX 788 ; N a152 ; B 35 -14 754 705 ;
+C 205 ; WX 788 ; N a153 ; B 35 -14 754 705 ;
+C 206 ; WX 788 ; N a154 ; B 35 -14 754 705 ;
+C 207 ; WX 788 ; N a155 ; B 35 -14 754 705 ;
+C 208 ; WX 788 ; N a156 ; B 35 -14 754 705 ;
+C 209 ; WX 788 ; N a157 ; B 35 -14 754 705 ;
+C 210 ; WX 788 ; N a158 ; B 35 -14 754 705 ;
+C 211 ; WX 788 ; N a159 ; B 35 -14 754 705 ;
+C 212 ; WX 894 ; N a160 ; B 35 58 860 634 ;
+C 213 ; WX 838 ; N a161 ; B 35 152 803 540 ;
+C 214 ; WX 1016 ; N a163 ; B 34 152 981 540 ;
+C 215 ; WX 458 ; N a164 ; B 35 -127 422 820 ;
+C 216 ; WX 748 ; N a196 ; B 35 94 698 597 ;
+C 217 ; WX 924 ; N a165 ; B 35 140 890 552 ;
+C 218 ; WX 748 ; N a192 ; B 35 94 698 597 ;
+C 219 ; WX 918 ; N a166 ; B 35 166 884 526 ;
+C 220 ; WX 927 ; N a167 ; B 35 32 892 660 ;
+C 221 ; WX 928 ; N a168 ; B 35 129 891 562 ;
+C 222 ; WX 928 ; N a169 ; B 35 128 893 563 ;
+C 223 ; WX 834 ; N a170 ; B 35 155 799 537 ;
+C 224 ; WX 873 ; N a171 ; B 35 93 838 599 ;
+C 225 ; WX 828 ; N a172 ; B 35 104 791 588 ;
+C 226 ; WX 924 ; N a173 ; B 35 98 889 594 ;
+C 227 ; WX 924 ; N a162 ; B 35 98 889 594 ;
+C 228 ; WX 917 ; N a174 ; B 35 0 882 692 ;
+C 229 ; WX 930 ; N a175 ; B 35 84 896 608 ;
+C 230 ; WX 931 ; N a176 ; B 35 84 896 608 ;
+C 231 ; WX 463 ; N a177 ; B 35 -99 429 791 ;
+C 232 ; WX 883 ; N a178 ; B 35 71 848 623 ;
+C 233 ; WX 836 ; N a179 ; B 35 44 802 648 ;
+C 234 ; WX 836 ; N a193 ; B 35 44 802 648 ;
+C 235 ; WX 867 ; N a180 ; B 35 101 832 591 ;
+C 236 ; WX 867 ; N a199 ; B 35 101 832 591 ;
+C 237 ; WX 696 ; N a181 ; B 35 44 661 648 ;
+C 238 ; WX 696 ; N a200 ; B 35 44 661 648 ;
+C 239 ; WX 874 ; N a182 ; B 35 77 840 619 ;
+C 241 ; WX 874 ; N a201 ; B 35 73 840 615 ;
+C 242 ; WX 760 ; N a183 ; B 35 0 725 692 ;
+C 243 ; WX 946 ; N a184 ; B 35 160 911 533 ;
+C 244 ; WX 771 ; N a197 ; B 34 37 736 655 ;
+C 245 ; WX 865 ; N a185 ; B 35 207 830 481 ;
+C 246 ; WX 771 ; N a194 ; B 34 37 736 655 ;
+C 247 ; WX 888 ; N a198 ; B 34 -19 853 712 ;
+C 248 ; WX 967 ; N a186 ; B 35 124 932 568 ;
+C 249 ; WX 888 ; N a195 ; B 34 -19 853 712 ;
+C 250 ; WX 831 ; N a187 ; B 35 113 796 579 ;
+C 251 ; WX 873 ; N a188 ; B 36 118 838 578 ;
+C 252 ; WX 927 ; N a189 ; B 35 150 891 542 ;
+C 253 ; WX 970 ; N a190 ; B 35 76 931 616 ;
+C 254 ; WX 918 ; N a191 ; B 34 99 884 593 ;
+EndCharMetrics
+EndFontMetrics

data/lib/extensions/pdf-writer/pdf/writer/graphics.rb

@@ -0,0 +1,813 @@
+#--
+# 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: graphics.rb 166 2007-11-08 18:22:05Z sandal $
+#++
+  # Points for use in the drawing of polygons.
+class PDF::Writer::PolygonPoint
+  def initialize(x, y, connector = :line)
+    @x, @y, @connector = x, y, connector
+  end
+
+  attr_reader :x, :y, :connector
+end
+
+  # This module contains graphics primitives. Objects that include this
+  # module must respond to #add_content.
+  #
+  # The PDF::Writer coordinate system is in PDF userspace units. The
+  # coordinate system in PDF::Writer is slightly different than might be
+  # expected, in that <tt>(0, 0)</tt> is at the lower left-hand corner of
+  # the canvas (page), not the normal top left-hand corner of the canvas.
+  # (See the diagram below.)
+  #
+  #     Y     Y
+  #    0+-----+X
+  #     |     |
+  #     |     |
+  #     |     |
+  #    0+-----+X
+  #     0     0
+  #
+  # Each primitive provided below indicates the <em>New Point</em>, or the
+  # coordinates new drawing point at the completion of the drawing
+  # operation. Drawing operations themselves do *not* draw or fill the path.
+  # This must be done by one of the stroke or fill operators, #stroke,
+  # #close_stroke, #fill, #close_fill, #fill_stroke, or #close_fill_stroke.
+  #
+  # Drawing operations return +self+ (the canvas) so that operations may be
+  # chained.
+module PDF::Writer::Graphics
+    # Close the current path by appending a straight line segment from the
+    # drawing point to the starting point of the path. If the path is
+    # closed, this does nothing. This operator terminates the current
+    # subpath.
+  def close
+    add_content(" h")
+    self
+  end
+
+    # Stroke the path. This operation terminates a path object and draws it.
+  def stroke
+    add_content(" S")
+    self
+  end
+
+    # Close the current path by appending a straight line segment from the
+    # drawing point to the starting point of the path, and then stroke it.
+    # This does the same as #close followed by #stroke.
+  def close_stroke
+    add_content(" s")
+    self
+  end
+
+    # Fills the path. Open subpaths are implicitly closed before being
+    # filled. PDF offers two methods for determining the fill region. The
+    # first is called the "nonzero winding number" and is the default fill.
+    # The second is called "even-odd".
+    #
+    # Use the even-odd rule (called with <tt>#fill(:even_odd)</tt>) with
+    # caution, as this will cause certain portions of the path to be
+    # considered outside of the fill region, resulting in interesting cutout
+    # patterns.
+  def fill(rule = nil)
+    if :even_odd == rule
+      add_content(" f*")
+    else
+      add_content(" f")
+    end
+    self
+  end
+
+    # Close the current path by appending a straight line segment from the
+    # drawing point to the starting point of the path, and then fill it.
+    # This does the same as #close followed by #fill.
+    #
+    # See #fill for more information on fill rules.
+  def close_fill(rule = nil)
+    close
+    fill(rule)
+    self
+  end
+
+    # Fills and then strokes the path. Open subpaths are implicitly closed
+    # before being filled. This is the same as constructing two identical
+    # path objects, calling #fill on one and #stroke on the other. Paths
+    # filled and stroked in this manner are treated as if they were one
+    # object for PDF transparency purposes (the PDF transparency model is
+    # not yet supported by PDF::Writer).
+    #
+    # See #fill for more information on fill rules.
+  def fill_stroke(rule = nil)
+    if :even_odd == rule
+      add_content(" B*")
+    else
+      add_content(" B")
+    end
+    self
+  end
+
+    # Closes, fills and then strokes the path. Open subpaths are explicitly
+    # closed before being filled (as if #close and then #fill_stroke had
+    # been called). This is the same as constructing two identical path
+    # objects, calling #fill on one and #stroke on the other. Paths filled
+    # and stroked in this manner are treated as if they were one object for
+    # PDF transparency purposes (PDF transparency is not yet supported by
+    # PDF::Writer).
+    #
+    # See #fill for more information on fill rules.
+  def close_fill_stroke(rule = nil)
+    if :even_odd == rule
+      add_content(" b*")
+    else
+      add_content(" b")
+    end
+    self
+  end
+
+    # Move the drawing point to the specified coordinates <tt>(x, y)</tt>.
+    #
+    # New Point:: <tt>(x, y)</tt>
+    # Subpath::   New
+  def move_to(x, y)
+    add_content("\n%.3f %.3f m" % [ x, y ])
+    self
+  end
+
+    # Draw a straight line from the drawing point to <tt>(x, y)</tt>.
+    #
+    # New Point:: <tt>(x, y)</tt>
+    # Subpath::   Current
+  def line_to(x, y)
+    add_content("\n%.3f %.3f l" % [ x, y ])
+    self
+  end
+
+    # Draws a cubic Bezier curve from the drawing point to <tt>(x2, y2)</tt>
+    # using <tt>(x0, y0)</tt> and <tt>(x1, y1)</tt> as the control points
+    # for the curve.
+    #
+    # New Point:: <tt>(x2, y2)</tt>
+    # Subpath::   Current
+  def curve_to(x0, y0, x1, y1, x2, y2)
+    add_content("\n%.3f %.3f %.3f %.3f %.3f %.3f c" % [ x0, y0, x1, y1, x2, y2 ])
+    self
+  end
+
+    # Draws a cubic Bezier curve from the drawing point to <tt>(x1, y1)</tt>
+    # using the drawing point and <tt>(x0, y0)</tt> as the control points
+    # for the curve.
+    #
+    # New Point:: <tt>(x1, y1)</tt>
+    # Subpath::   Current
+  def scurve_to(x0, y0, x1, y1)
+    add_content("\n%.3f %.3f %.3f %.3f v" % [ x0, y0, x1, y1 ])
+    self
+  end
+
+    # Draws a cubic Bezier curve from the drawing point to <tt>(x1, y1)</tt>
+    # using <tt>(x0, y0)</tt> and <tt>(x1, y1)</tt> as the control points
+    # for the curve.
+    #
+    # New Point:: <tt>(x1, y1)</tt>
+    # Subpath::   Current
+  def ecurve_to(x0, y0, x1, y1)
+    add_content("\n%.3f %.3f %.3f %.3f y" % [ x0, y0, x1, y1 ])
+    self
+  end
+
+    # Draw a straight line from <tt>(x0, y0)</tt> to <tt>(x1, y1)</tt>. The
+    # line is a new subpath.
+    #
+    # New Point:: <tt>(x1, y1)</tt>.
+    # Subpath::   New
+  def line(x0, y0, x1, y1)
+    move_to(x0, y0).line_to(x1, y1)
+  end
+
+    # Draw a cubic Bezier curve from <tt>(x0, y0)</tt> to <tt>(x3, y3)</tt>
+    # using <tt>(x1, y1)</tt> and <tt>(x2, y2)</tt> as control points.
+    #
+    # New Point:: <tt>(x3, y3)</tt>
+    # Subpath::   New
+  def curve(x0, y0, x1, y1, x2, y2, x3, y3)
+    move_to(x0, y0).curve_to(x1, y1, x2, y2, x3, y3)
+  end
+
+    # Draw a cubic Bezier curve from <tt>(x0, y0)</tt> to <tt>(x2, y2)</tt>
+    # using <tt>(x0, y0)</tt> and <tt>(x1, y1)</tt> as control points.
+    #
+    # New Point:: <tt>(x2, y2)</tt>
+    # Subpath::   New
+  def scurve(x0, y0, x1, y1, x2, y2)
+    move_to(x0, y0).scurve_to(x1, y1, x2, y2)
+  end
+
+    # Draw a cubic Bezier curve from <tt>(x0, y0)</tt> to <tt>(x2, y2)</tt>
+    # using <tt>(x1, y1)</tt> and <tt>(x2, y2)</tt> as control points.
+    #
+    # New Point:: <tt>(x2, y2)</tt>
+    # Subpath::   New
+  def ecurve(x0, y0, x1, y1, x2, y2)
+    move_to(x0, y0).ecurve_to(x1, y1, x2, y2)
+  end
+
+    # This constant is used to approximate a symmetrical arc using a cubic
+    # Bezier curve.
+  KAPPA = 4.0 * ((Math.sqrt(2) - 1.0) / 3.0)
+
+    # Draws a circle of radius +r+ with the centre-point at <tt>(x, y)</tt>
+    # as a complete subpath. The drawing point will be moved to the
+    # centre-point upon completion of the drawing the circle.
+  def circle_at(x, y, r)
+    ellipse_at(x, y, r, r)
+  end
+
+    # Draws an ellipse of +x+ radius <tt>r1</tt> and +y+ radius <tt>r2</tt>
+    # with the centre-point at <tt>(x, y)</tt> as a complete subpath. The
+    # drawing point will be moved to the centre-point upon completion of the
+    # drawing the ellipse.
+  def ellipse_at(x, y, r1, r2 = r1)
+    l1 = r1 * KAPPA
+    l2 = r2 * KAPPA
+    move_to(x + r1, y)
+      # Upper right hand corner
+    curve_to(x + r1, y + l1, x + l2, y + r2, x,      y + r2)
+      # Upper left hand corner
+    curve_to(x - l2, y + r2, x - r1, y + l1, x - r1, y)
+      # Lower left hand corner
+    curve_to(x - r1, y - l1, x - l2, y - r2, x,      y - r2)
+      # Lower right hand corner
+    curve_to(x + l2, y - r2, x + r1, y - l1, x + r1, y)
+    move_to(x, y)
+  end
+
+    # Draw an ellipse centered at <tt>(x, y)</tt> with +x+ radius
+    # <tt>r1</tt> and +y+ radius <tt>r2</tt>. A partial ellipse can be drawn
+    # by specifying the starting and finishing angles.
+    #
+    # New Point:: <tt>(x, y)</tt>
+    # Subpath::   New
+  def ellipse2_at(x, y, r1, r2 = r1, start = 0, stop = 359.99, segments = 8)
+    segments = 2 if segments < 2
+
+    start = PDF::Math.deg2rad(start)
+    stop  = PDF::Math.deg2rad(stop)
+
+    arc     = stop - start
+    segarc  = arc / segments.to_f
+    dtm     = segarc / 3.0
+
+    theta = start
+    a0 = x + r1 * Math.cos(theta)
+    b0 = y + r2 * Math.sin(theta)
+    c0 = -r1 * Math.sin(theta)
+    d0 = r2 * Math.cos(theta)
+
+    move_to(a0, b0)
+
+    (1..segments).each do |ii|
+      theta = ii * segarc + start
+
+      a1 = x + r1 * Math.cos(theta)
+      b1 = y + r2 * Math.sin(theta)
+      c1 = -r1 * Math.sin(theta)
+      d1 = r2 * Math.cos(theta)
+
+      curve_to(a0 + (c0 * dtm),
+               b0 + (d0 * dtm),
+               a1 - (c1 * dtm),
+               b1 - (d1 * dtm), a1, b1)
+
+      a0 = a1
+      b0 = b1
+      c0 = c1
+      d0 = d1
+    end
+
+    move_to(x, y)
+    self
+  end
+
+    # Draws an ellipse segment. Draws a closed partial ellipse.
+    #
+    # New Point:: <tt>(x, y)</tt>
+    # Subpath::   New
+  def segment_at(x, y, r1, r2 = r1, start = 0, stop = 360, segments = 8)
+    ellipse2_at(x, y, r1, r2, start, stop, segments)
+
+    start = PDF::Math.deg2rad(start)
+    stop  = PDF::Math.deg2rad(stop)
+
+    ax = x + r1 * Math.cos(start)
+    ay = y + r2 * Math.sin(start)
+    bx = x + r1 * Math.cos(stop)
+    by = y + r2 * Math.sin(stop)
+
+    move_to(ax, ay)
+    line_to(x, y)
+    line_to(bx, by)
+    move_to(x, y)
+    self
+  end
+
+    # Draw a polygon. +points+ is an array of PolygonPoint objects, or an
+    # array that can be converted to an array of PolygonPoint objects with
+    # <tt>PDF::Writer::PolygonPoint.new(*value)</tt>.
+    #
+    # New Point:: <tt>(points[-1].x, points[-1].y)</tt>
+    # Subpath::   New
+  def polygon(points)
+    points = points.map { |pp|
+      pp.kind_of?(Array) ? PDF::Writer::PolygonPoint.new(*pp) : pp
+    }
+
+    point = points.shift
+
+    move_to(point.x, point.y)
+
+    while not points.empty?
+      point = points.shift
+
+      case point.connector
+      when :curve
+        c1 = point
+        c2 = points.shift
+        point = points.shift
+
+        curve_to(c1.x, c1.y, c2.x, c2.y, point.x, point.y)
+      when :scurve
+        c1 = point
+        point = points.shift
+        scurve_to(c1.x, c1.y, point.x, point.y)
+      when :ecurve
+        c1 = point
+        point = points.shift
+        ecurve_to(c1.x, c1.y, point.x, point.y)
+      else
+        line_to(point.x, point.y)
+      end
+    end
+
+    self
+  end
+
+    # Draw a rectangle. The first corner is <tt>(x, y)</tt> and the second
+    # corner is <tt>(x + w, y - h)</tt>.
+    #
+    # New Point:: <tt>(x + w, y - h)</tt>
+    # Subpath::   Current
+  def rectangle(x, y, w, h = w)
+    add_content("\n%.3f %.3f %.3f %.3f re" % [ x, y, w, h ])
+    self
+  end
+
+    # Draw a rounded rectangle with corners <tt>(x, y)</tt> and <tt>(x + w,
+    # y - h)</tt> and corner radius +r+. The radius should be significantly
+    # smaller than +h+ and +w+.
+    #
+    # New Point:: <tt>(x + w, y - h)</tt>
+    # Subpath::   New
+  def rounded_rectangle(x, y, w, h, r)
+    x1 = x
+    x2 = x1 + w
+    y1 = y
+    y2 = y1 - h
+
+    r1 = r
+    r2 = r / 2.0
+
+    points = [
+      [ x1 + r1, y1,      :line  ],
+      [ x2 - r1, y1,      :line  ],
+      [ x2 - r2, y1,      :curve ], # cp1
+      [ x2,      y1 - r2,        ], # cp2
+      [ x2,      y1 - r1,        ], # ep
+      [ x2,      y2 + r1, :line  ],
+      [ x2,      y2 + r2, :curve ], # cp1
+      [ x2 - r2, y2,             ], # cp2
+      [ x2 - r1, y2,             ], # ep
+      [ x1 + r1, y2,      :line  ],
+      [ x1 + r2, y2,      :curve ], # cp1
+      [ x1,      y2 + r2,        ], # cp2
+      [ x1,      y2 + r1,        ], # ep
+      [ x1,      y1 - r1, :line  ],
+      [ x1,      y1 - r2, :curve ], # cp1
+      [ x1 + r2, y1,             ], # cp2
+      [ x1 + r1, y1,             ], # ep
+    ]
+    polygon(points)
+    move_to(x2, y2)
+    self
+  end
+  
+    # Draws a star centered on <tt>(x, y)</tt> with +rays+ portions of
+    # +length+ from the centre. Stars with an odd number of rays should have
+    # the top ray pointing toward the top of the document. This will not
+    # create a "star" with fewer than four points.
+    #
+    # New Point:: <tt>(cx, cy)</tt>
+    # Subpath::   New
+  def star(cx, cy, length, rays = 5)
+    rays = 4 if rays < 4
+    points = []
+    part = Math::PI / rays.to_f
+
+    0.step((rays * 4), 2) do |ray|
+      if ((ray / 2) % 2 == 0)
+        dist = length / 2.0
+      else
+        dist = length
+      end
+
+      x = cx + Math.cos((1.5 + ray / 2.0) * part) * dist
+      y = cy + Math.sin((1.5 + ray / 2.0) * part) * dist
+      points << [ x, y ]
+    end
+
+    polygon(points)
+    move_to(cx, cy)
+    self
+  end
+
+    # This sets the line drawing style. This *must* be a
+    # PDF::Writer::StrokeStyle object.
+  def stroke_style(style)
+    stroke_style!(style) if @current_stroke_style.nil? or style != @current_stroke_style
+  end
+
+    # Forces the line drawing style to be set, even if it's the same as the
+    # current color. Emits the current stroke style if +nil+ is provided.
+  def stroke_style!(style = nil)
+    @current_stroke_style = style if style
+    add_content "\n#{@current_stroke_style.render}" if @current_stroke_style
+  end
+
+    # Returns the current stroke style.
+  def stroke_style?
+    @current_stroke_style
+  end
+
+    # Set the text rendering style. This may be one of the following
+    # options:
+    #
+    # 0:: fill
+    # 1:: stroke
+    # 2:: fill then stroke
+    # 3:: invisible
+    # 4:: fill and add to clipping path
+    # 5:: stroke and add to clipping path
+    # 6:: fill and stroke and add to clipping path
+    # 7:: add to clipping path
+  def text_render_style(style)
+    text_render_style!(style) unless @current_text_render_style and style == @current_text_render_style
+  end
+
+    # Forces the text rendering style to be set, even if it's the same as
+    # the current style.
+  def text_render_style!(style)
+    @current_text_render_style = style
+  end
+
+    # Reutnrs the current text rendering style.
+  def text_render_style?
+    @current_text_render_style
+  end
+
+    # Sets the color for fill operations.
+  def fill_color(color)
+    fill_color!(color) if @current_fill_color.nil? or color != @current_fill_color
+  end
+
+    # Forces the color for fill operations to be set, even if the color 
+    # is the same as the current color. Does nothing if +nil+ is provided.
+  def fill_color!(color = nil)
+    if color
+      @current_fill_color = color
+      add_content "\n#{@current_fill_color.pdf_fill}"
+    end
+  end
+
+    # Returns the current fill color.
+  def fill_color?
+    @current_fill_color
+  end
+
+    # Sets the color for stroke operations.
+  def stroke_color(color)
+    stroke_color!(color) if @current_stroke_color.nil? or color != @current_stroke_color
+  end
+
+    # Forces the color for stroke operations to be set, even if the color
+    # is the same as the current color. Does nothing if +nil+ is provided.
+  def stroke_color!(color = nil)
+    if color
+      @current_stroke_color = color
+      add_content "\n#{@current_stroke_color.pdf_stroke}"
+    end
+  end
+
+    # Returns the current stroke color.
+  def stroke_color?
+    @current_stroke_color
+  end
+
+    # Add an image from a file to the current page at position <tt>(x,
+    # y)</tt> (the lower left-hand corner of the image). The image will be
+    # scaled to +width+ by +height+ units. The image may be a PNG or JPEG
+    # image.
+    #
+    # The +image+ parameter may be a filename or an object that returns the
+    # full image data when #read is called with no parameters (such as an IO
+    # object). If 'open-uri' is loaded, then the image name may be an URI.
+    #
+    # In PDF::Writer 1.1 or later, the new +link+ parameter is a hash with
+    # two keys:
+    #
+    # <tt>:type</tt>::    The type of link, either <tt>:internal</tt> or
+    #                     <tt>:external</tt>.
+    # <tt>:target</tt>::  The destination of the link. For an
+    #                     <tt>:internal</tt> link, this is an internal
+    #                     cross-reference destination. For an
+    #                     <tt>:external</tt> link, this is an URI.
+    #
+    # This will automatically make the image a clickable link if set.
+  def add_image_from_file(image, x, y, width = nil, height = nil, link = nil)
+    data = nil
+
+    if image.respond_to?(:read)
+      data = image.read
+    else
+      open(image, 'rb') { |ff| data = ff.read }
+    end
+
+    add_image(data, x, y, width, height, nil, link)
+  end
+
+    # Add an image from a loaded image (JPEG or PNG) resource at position
+    # <tt>(x, y)</tt> (the lower left-hand corner of the image) and scaled
+    # to +width+ by +height+ units. If provided, +image_info+ is a
+    # PDF::Writer::Graphics::ImageInfo object.
+    #
+    # In PDF::Writer 1.1 or later, the new +link+ parameter is a hash with
+    # two keys:
+    #
+    # <tt>:type</tt>::    The type of link, either <tt>:internal</tt> or
+    #                     <tt>:external</tt>.
+    # <tt>:target</tt>::  The destination of the link. For an
+    #                     <tt>:internal</tt> link, this is an internal
+    #                     cross-reference destination. For an
+    #                     <tt>:external</tt> link, this is an URI.
+    #
+    # This will automatically make the image a clickable link if set.
+  def add_image(image, x, y, width = nil, height = nil, image_info = nil, link = nil)
+    if image.kind_of?(PDF::Writer::External::Image)
+      label       = image.label
+      image_obj   = image
+      image_info ||= image.image_info
+    else
+      image_info ||= PDF::Writer::Graphics::ImageInfo.new(image)
+
+      tt = Time.now
+      @images << tt
+      id = @images.index(tt)
+      label = "I#{id}"
+      image_obj = PDF::Writer::External::Image.new(self, image, image_info, label)
+      @images[id] = image_obj
+    end
+
+    if width.nil? and height.nil?
+      width   = image_info.width
+      height  = image_info.height
+    end
+
+    width  ||= height / image_info.height.to_f * image_info.width
+    height ||= width * image_info.height / image_info.width.to_f
+
+    tt = "\nq\n%.3f 0 0 %.3f %.3f %.3f cm\n/%s Do\nQ"
+    add_content(tt % [ width, height, x, y, label ])
+
+    if link
+      case link[:type]
+      when :internal
+        add_internal_link(link[:target], x, y, x + width, y + height)
+      when :external
+        add_link(link[:target], x, y, x + width, y + height)
+      end
+    end
+
+    image_obj
+  end
+
+    # Add an image easily to a PDF document. +image+ is the name of a JPG or
+    # PNG image. +options+ is a Hash:
+    #
+    # <tt>:pad</tt>::           The number of PDF userspace units that will
+    #                           be on all sides of the image. The default is
+    #                           <tt>5</tt> units.
+    # <tt>:width</tt>::         The desired width of the image. The image
+    #                           will be resized to this width with the
+    #                           aspect ratio kept. If unspecified, the
+    #                           image's natural width will be used.
+    # <tt>:resize</tt>::        How to resize the image, either :width
+    #                           (resizes the image to be as wide as the
+    #                           margins) or :full (resizes the image to be
+    #                           as large as possible). May be a numeric
+    #                           value, used as a multiplier for the image
+    #                           size (e.g., 0.5 will shrink the image to
+    #                           half-sized). If this and <tt>:width</tt> are
+    #                           unspecified, the image's natural size will be
+    #                           used. Mutually exclusive with the
+    #                           <tt>:width<tt> option.
+    # <tt>:justification</tt>:: The placement of the image. May be :center,
+    #                           :right, or :left. Defaults to :left.
+    # <tt>:border</tt>::        The border options. No default border. If
+    #                           specified, must be either +true+, which uses
+    #                           the default border, or a Hash.
+    # <tt>:link</tt>::          Makes the image a clickable link.
+    #
+    # Image borders are specified as a hash with two options:
+    #
+    # <tt>:color</tt>:: The colour of the border. Defaults to 50% grey.
+    # <tt>:style</tt>:: The stroke style of the border. This must be a
+    #                   StrokeStyle object and defaults to the default line.
+    #
+    # Image links are defined as a hash with two options:
+    #
+    # <tt>:type</tt>::    The type of link, either <tt>:internal</tt> or
+    #                     <tt>:external</tt>.
+    # <tt>:target</tt>::  The destination of the link. For an
+    #                     <tt>:internal</tt> link, this is an internal
+    #                     cross-reference destination. For an
+    #                     <tt>:external</tt> link, this is an URI.
+  def image(image, options = {})
+    width   = options[:width]
+    pad     = options[:pad]           || 5
+    resize  = options[:resize]
+    just    = options[:justification] || :left
+    border  = options[:border]
+    link    = options[:link]
+
+    if image.kind_of?(PDF::Writer::External::Image)
+      info        = image.image_info
+      image_data  = image
+    else
+      if image.respond_to?(:read)
+        image_data = image.read
+      else
+        image_data = open(image, "rb") { |file| file.read }
+      end
+      info = PDF::Writer::Graphics::ImageInfo.new(image_data)
+    end
+
+    raise "Unsupported Image Type" unless %w(JPEG PNG).include?(info.format)
+
+    width   = info.width if width.nil?
+    aspect  = info.width.to_f / info.height.to_f
+
+      # Get the maximum width of the image on insertion.
+    if @columns_on
+      max_width = @columns[:width] - (pad * 2)
+    else
+      max_width = @page_width - (pad * 2) - @left_margin - @right_margin
+    end
+
+    if resize == :full or resize == :width or width > max_width
+      width = max_width
+    end
+
+      # Keep the height in an appropriate aspect ratio of the width.
+    height = (width / aspect.to_f)
+
+      # Resize the image.
+    if resize.kind_of?(Numeric)
+      width   *= resize
+      height  *= resize
+    end
+
+      # Resize the image *again*, if it is wider than what is available.
+    if width > max_width
+      height = (width / aspect.to_f)
+    end
+
+      # If the height is greater than the available space:
+    havail = @y - @bottom_margin - (pad * 2)
+    if height > havail
+        # If the image is to be resized to :full (remaining space
+        # available), adjust the image size appropriately. Otherwise, start
+        # a new page and flow to the next page.
+      if resize == :full
+        height = havail
+        width = (height * aspect)
+      else
+        start_new_page
+      end
+    end
+
+      # Find the x and y positions.
+    y = @y - pad - height
+    x = @left_margin + pad
+
+    if (width < max_width)
+      case just
+      when :center
+        x += (max_width - width) / 2.0
+      when :right
+        x += (max_width - width)
+      end
+    end
+
+    image_obj = add_image(image_data, x, y, width, height, info)
+
+    if border
+      border = {} if true == border
+      border[:color]  ||= Color::RGB::Grey50
+      border[:style]  ||= PDF::Writer::StrokeStyle::DEFAULT
+
+      save_state
+      stroke_color border[:color] 
+      stroke_style border[:style] 
+      rectangle(x, y - pad, width, height - pad).stroke
+      restore_state
+    end
+
+    if link
+      case link[:type]
+      when :internal
+        add_internal_link(link[:target], x, y - pad, x + width, y + height - pad)
+      when :external
+        add_link(link[:target], x, y - pad, x + width, y + height - pad)
+      end
+    end
+
+    @y = @y - pad - height
+
+    image_obj
+  end
+
+    # Translate the coordinate system axis by the specified user space
+    # coordinates.
+  def translate_axis(x, y)
+    add_content("\n1 0 0 1 %.3f %.3f cm" % [ x, y ])
+    self
+  end
+
+    # Rotate the axis of the coordinate system by the specified clockwise
+    # angle.
+  def rotate_axis(angle)
+    rad = PDF::Math.deg2rad(angle)
+    tt  = "\n%.3f %.3f %.3f %.3f 0 0 cm"
+    tx  = [ Math.cos(rad), Math.sin(rad), -Math.sin(rad), Math.cos(rad) ]
+    add_content(tt % tx)
+    self
+  end
+
+    # Scale the coordinate system axis by the specified factors.
+  def scale_axis(x = 1, y = 1)
+    add_content("\n%.3f 0 0 %.3f 0 0 cm" % [ x, y ])
+    self
+  end
+
+    # Skew the coordinate system axis by the specified angles.
+  def skew_axis(xangle = 0, yangle = 0)
+    xr = PDF::Math.deg2rad(xangle)
+    yr = PDF::Math.deg2rad(yangle)
+
+    xr = Math.tan(xr) if xangle != 0
+    yr = Math.tan(yr) if yangle != 0
+
+    add_content("\n1 %.3f %.3f 1 0 0 cm" % [ xr, yr ])
+    self
+  end
+
+    # Transforms the coordinate axis with the appended matrix. All
+    # transformations (including those above) are performed with this
+    # matrix. The transformation matrix is:
+    #
+    #   +-     -+
+    #   | a c e |
+    #   | b d f |
+    #   | 0 0 1 |
+    #   +-     -+
+    #
+    # The six values are represented as a six-digit vector: [ a b c d e f ]
+    #
+    # * Axis translation uses [ 1 0 0 1 x y ] where x and y are the new
+    #   (0,0) coordinates in the old axis system.
+    # * Scaling uses [ sx 0 0 sy 0 0 ] where sx and sy are the scaling
+    #   factors.
+    # * Rotation uses [ cos(a) sin(a) -sin(a) cos(a) 0 0 ] where a is the
+    #   angle, measured in radians.
+    # * X axis skewing uses [ 1 0 tan(a) 1 0 0 ] where a is the angle,
+    #   measured in radians.
+    # * Y axis skewing uses [ 1 tan(a) 0 1 0 0 ] where a is the angle,
+    #   measured in radians.
+  def transform_matrix(a, b, c, d, e, f)
+    add_content("\n%.3f %.3f %.3f %.3f %.3f %.3f cm" % [ a, b, c, d, e, f ])
+  end
+end