nurettin-prawn 1.0.0.rc1

data/manual/bounding_box/nesting.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# 
+# Normally when we provide the top left corner of a bounding box we
+# express the coordinates relative to the margin box. This is not the
+# case when we have nested bounding boxes. Once nested the inner bounding box
+# coordinates are relative to the outter bounding box.
+#
+# This example shows some nested bounding boxes with fixed and stretchy heights.
+# Note how the <code>cursor</code> method returns coordinates relative to
+# the current bounding box.
+#
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[.. example_helper]))
+
+filename = File.basename(__FILE__).gsub('.rb', '.pdf')
+Prawn::Example.generate(filename) do
+  def box_content(string)
+    text string
+    transparent(0.5) { stroke_bounds }
+  end
+  
+  gap = 20
+  bounding_box([50, cursor], :width => 400, :height => 200) do
+    box_content("Fixed height")
+    
+    bounding_box([gap, cursor - gap], :width => 300) do
+      text "Stretchy height"
+      
+      bounding_box([gap, bounds.top - gap], :width => 100) do
+        text "Stretchy height"
+        transparent(0.5) { dash(1); stroke_bounds; undash }
+      end
+      
+      bounding_box([gap * 7, bounds.top - gap], :width => 100, :height => 50) do
+        box_content("Fixed height")
+      end
+      
+      transparent(0.5) { dash(1); stroke_bounds; undash }
+    end
+    
+    bounding_box([gap, cursor - gap], :width => 300, :height => 50) do
+      box_content("Fixed height")
+    end
+  end
+end

data/manual/bounding_box/russian_boxes.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+#
+# This example is mostly just for fun, and shows how nested bounding boxes
+# can simplify calculations. See the "Bounding Box" section of the manual
+# for more basic uses.
+#
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[.. example_helper]))
+
+filename = File.basename(__FILE__).gsub('.rb', '.pdf')
+Prawn::Example.generate(filename) do
+  def combine(a1, a2)
+    output = []
+    a1.each do |i1|
+      a2.each do |i2|
+        output += [[i1,i2]]
+      end
+    end
+    output
+  end
+
+  def recurse_bounding_box(max_depth=4, depth=1)
+    width = (bounds.width-15)/2
+    height = (bounds.height-15)/2
+    left_top_corners = combine([5, bounds.right-width-5],
+                               [bounds.top-5, height+5])
+    left_top_corners.each do |lt|
+      bounding_box(lt, :width => width, :height => height) do
+        stroke_bounds
+        recurse_bounding_box(max_depth, depth+1) if depth < max_depth
+      end
+    end
+  end
+
+  # Set up a bbox from the dashed line to the bottom of the page
+  bounding_box([0, cursor], :width => bounds.width, :height => cursor) do
+    recurse_bounding_box
+  end
+end
+

data/manual/bounding_box/stretchy.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+# 
+# Bounding Boxes accept an optional <code>:height</code> parameter. Unless it
+# is provided the bounding box will be stretchy. It will expand the height to
+# fit all content generated inside it.
+#
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[.. example_helper]))
+
+filename = File.basename(__FILE__).gsub('.rb', '.pdf')
+Prawn::Example.generate(filename) do
+  y_position = cursor
+  bounding_box([0, y_position], :width => 200, :height => 100) do
+    text "This bounding box has a height of 100. If this text gets too large " +
+         "it will flow to the next page."
+    
+    transparent(0.5) { stroke_bounds }
+  end
+  
+  bounding_box([300, y_position], :width => 200) do
+    text "This bounding box has variable height. No matter how much text is " +
+         "written here, the height will expand to fit."
+    
+    text " _" * 100
+    
+    text " *" * 100
+    
+    transparent(0.5) { stroke_bounds }
+  end
+  
+end

data/manual/document_and_page_options/background.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+#
+# Pass an image path to the <code>:background</code> option and it will be used
+# as the background for all pages.
+# This option can only be used on document creation. 
+#
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[.. example_helper]))
+
+img = "#{Prawn::DATADIR}/images/letterhead.jpg"
+
+Prawn::Document.generate("background.pdf",
+                         :background => img,
+                         :margin => 100
+) do
+  text "My report caption", :size => 18, :align => :right
+
+  move_down font.height * 2
+
+  text "Here is my text explaning this report. " * 20, 
+       :size => 12, :align => :left, :leading => 2
+
+  move_down font.height
+
+  text "I'm using a soft background. " * 40,
+       :size => 12, :align => :left, :leading => 2
+end

data/manual/document_and_page_options/document_and_page_options.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+#
+# Examples for stamps and repeaters.
+#
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[.. example_helper]))
+
+Prawn::Example.generate("document_and_page_options.pdf",
+                        :page_size => "FOLIO") do
+  
+  package "document_and_page_options" do |p|
+    
+    p.example "page_size",    :eval_source => false, :full_source => true
+    p.example "page_margins", :eval_source => false, :full_source => true
+    p.example "background",   :eval_source => false, :full_source => true
+    p.example "metadata",     :eval_source => false, :full_source => true
+    
+    p.intro do
+      prose("So far we've already seen how to create new documents and start new pages. This chapter expands on the previous examples by showing other options avialable. Some of the options are only available when creating new documents.
+
+      The examples show:")
+
+      list( "How to configure page size",
+            "How to configure page margins",
+            "How to use a background image",
+            "How to add metadata to the generated PDF"
+          )
+    end
+    
+  end
+end

data/manual/document_and_page_options/metadata.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+#
+# To set the document metadata just pass a hash to the <code>:info</code>
+# option when creating new documents.
+#
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[.. example_helper]))
+
+Prawn::Document.generate("metadata.pdf",
+  :info => {
+    :Title        => "My title",
+    :Author       => "John Doe",
+    :Subject      => "My Subject",
+    :Keywords     => "test metadata ruby pdf dry",
+    :Creator      => "ACME Soft App", 
+    :Producer     => "Prawn",
+    :CreationDate => Time.now,
+    :Grok         => "Test Property"
+  }) do
+  
+  text "This is a test of setting metadata properties via the info option."
+  text "It allows one to specify non standard properties like 'Grok'."
+end

data/manual/document_and_page_options/page_margins.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+#
+# The default margin for pages is 0.5 inch but you can change that with the
+# <code>:margin</code> option or if you'd like to have different margins you
+# can use the <code>:left_margin</code>, <code>:right_margin</code>,
+# <code>:top_margin</code>, <code>:bottom_margin</code> options.
+#
+# These options are available both for starting new pages and creating new
+# documents.
+#
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[.. example_helper]))
+
+Prawn::Document.generate("page_margins.pdf",
+                         :margin => 100
+) do
+  text "100 pts margins."
+  stroke_bounds
+
+  start_new_page(:left_margin => 300)
+  text "300 pts margin on the left."
+  stroke_bounds
+  
+  start_new_page(:top_margin => 300)
+  text "300 pts margin both on the top and on the left. Notice that whenever " +
+       "you set an option for a new page it will remain the default for the " +
+       "following pages."
+  stroke_bounds
+
+  start_new_page(:margin => 50)
+  text "50 pts margins. Using the margin option will reset previous specific " +
+       "calls to left, right, top and bottom margins."
+  stroke_bounds
+  
+  start_new_page(:margin => [50, 100, 150, 200])
+  text "There is also the shorthand CSS like syntax used here."
+  stroke_bounds
+end

data/manual/document_and_page_options/page_size.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+#
+# Prawn comes with support for most of the common page sizes so you'll only need
+# to provide specific values if your intended format is not supported. To see a
+# list with all supported sizes take a look at: https://github.com/prawnpdf/prawn/blob/master/lib/prawn/document/page_geometry.rb
+#
+# To define the size use <code>:page_size</code> when creating new documents
+# and <code>:size</code> when starting new pages. The default page size for new
+# documents is LETTER (612.00 x 792.00).
+#
+# You may also define the orientation of the page to be either portrait
+# (default) or landscape. Use <code>:page_layout</code> when creating new
+# documents and <code>:layout</code> when starting new pages.
+#
+require File.expand_path(File.join(File.dirname(__FILE__),
+                                   %w[.. example_helper]))
+
+Prawn::Document.generate("page_size.pdf",
+                         :page_size   => "EXECUTIVE",
+                         :page_layout => :landscape
+) do
+  text "EXECUTIVE landscape page."
+
+  custom_size = [275, 326]
+  
+  ["A4", "TABLOID", "B7", custom_size ].each do |size|
+    
+    start_new_page(:size => size, :layout => :portrait)
+    text "#{size} portrait page."
+    
+    start_new_page(:size => size, :layout => :landscape)
+    text "#{size} landscape page."
+  end
+end

data/manual/example_file.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+module Prawn
+  
+  # The Prawn::ExampleFile class is a utility class to ease the manipulation
+  # and extraction of source code and comments from the actual example files
+  #
+  class ExampleFile
+    attr_reader :package, :filename
+    
+    # Stores the file data, filename and parent, which will be either an
+    # ExampleSection or an ExamplePackage.
+    #
+    # Available boolean options are:
+    # 
+    # <tt>:eval_source</tt>:: Evals the example source code (default: true)
+    # <tt>:full_source</tt>:: Extract the full source code when true. Extract
+    # only the code between the generate block when false (default: false)
+    #
+    def initialize(parent, filename, options={})
+      @parent   = parent.is_a?(String) ? ExamplePackage.new(parent) : parent
+      
+      @filename = filename
+      @data     = read_file(@parent.folder_name, filename)
+      
+      @options  = {:eval_source => true, :full_source => false}.merge(options)
+    end
+    
+    # Return the example source code excluding the initial comments and
+    # require calls
+    #
+    def full_source
+      @data.gsub(/# encoding.*?\n.*require.*?\n\n/m, "\n").strip
+    end
+    
+    # Return the example source contained inside the first generate block or
+    # the full source if no generate block is found
+    #
+    def generate_block_source
+      block = @data.slice(/\w+\.generate.*? do\n(.*)end/m, 1)
+        
+      return full_source unless block
+      
+      block.gsub(/^( ){2}/, "")
+    end
+    
+    # Return either the full_source or the generate_block_source according
+    # to the options
+    #
+    def source
+      @options[:full_source] ? full_source : generate_block_source
+    end
+    
+    # Return true if the example source should be evaluated inline within
+    # the manual according to the options
+    #
+    def eval?
+      @options[:eval_source]
+    end
+    
+    # Retrieve the comments between the encoding declaration and the require
+    # call for example_helper.rb
+    #
+    # Then removes the '#' signs, reflows the line breaks and return the result
+    #
+    def introduction_text
+      intro = @data.slice(/# encoding.*?\n(.*)require File\.expand_path/m, 1)
+      intro.gsub!(/\n# (?=\S)/m, ' ')
+      intro.gsub!(/^#/, '')
+      intro.gsub!("\n", "\n\n")
+      intro.rstrip!
+      intro
+    end
+    
+    # Returns a human friendly version of the example file name
+    #
+    def name
+      @name ||= @filename[/(.*)\.rb/, 1].gsub("_", " ").capitalize
+    end
+    
+    # Returns this example's parent original folder name
+    #
+    def parent_folder_name
+      @parent.folder_name
+    end
+    
+    # Returns the human friendly version of this example parent name
+    #
+    def parent_name
+      @parent.name
+    end
+    
+    # Renders this example to a pdf
+    #
+    def render(pdf)
+      pdf.render_example(self)
+    end
+    
+  private
+  
+    # Read the data from a file in a given package
+    #
+    def read_file(folder_name, filename)
+      data = File.read(File.expand_path(File.join(
+        File.dirname(__FILE__), folder_name, filename)))
+      
+      # XXX If we ever have manual files with source encodings other than
+      # UTF-8, we will need to fix this to work on Ruby 1.9.
+      if data.respond_to?(:encode!)
+        data.encode!("UTF-8")
+      end
+      data
+    end
+    
+  end
+end

data/manual/example_helper.rb

@@ -0,0 +1,430 @@
+# encoding: utf-8
+#
+# Helper for organizing examples
+#
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'prawn'
+require 'prawn/security'
+require 'prawn/layout'
+
+require 'enumerator'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'example_file'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'example_section'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'example_package'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'syntax_highlight'))
+
+Prawn.debug = true
+
+module Prawn
+  
+  # The Prawn::Example class holds all the helper methods used to generate the
+  # Prawn by example manual.
+  #
+  # The overall structure is to have single example files grouped by package
+  # folders. Each package has a package builder file (with the same name as the
+  # package folder) that defines the inner structure of subsections and
+  # examples. The manual is then built by loading all the packages and some
+  # standalone pages.
+  #
+  # To see one of the examples check manual/basic_concepts/cursor.rb
+  #
+  # To see one of the package builders check
+  # manual/basic_concepts/basic_concepts.rb
+  #
+  # To see how the manual is built check manual/manual/manual.rb (Yes that's a
+  # whole load of manuals)
+  #
+  class Example < Prawn::Document
+    
+    # Values used for the manual design:
+    
+    # This is the default value for the margin box
+    #
+    BOX_MARGIN   = 36
+    
+    # Additional indentation to keep the line measure with a reasonable size
+    # 
+    INNER_MARGIN = 30
+    
+    # Vertical Rhythm settings
+    #
+    RHYTHM  = 10
+    LEADING = 2
+    
+    # Colors
+    #
+    BLACK      = "000000"
+    LIGHT_GRAY = "F2F2F2"
+    GRAY       = "DDDDDD"
+    DARK_GRAY  = "333333"
+    BROWN      = "A4441C"
+    ORANGE     = "F28157"
+    LIGHT_GOLD = "FBFBBE"
+    DARK_GOLD  = "EBE389"
+    BLUE       = "0000D0"
+    
+    # Used to generate the url for the example files
+    #
+    MANUAL_URL = "http://github.com/prawnpdf/prawn/tree/master/manual"
+    
+    
+    # Loads a package. Used on the manual.
+    #
+    def load_package(package)
+      load_file(package, package)
+    end
+    
+    # Loads a page with outline support. Used on the manual.
+    #
+    def load_page(page)
+      load_file("manual", page)
+
+      outline.define do
+        section(page.gsub("_", " ").capitalize, :destination => page_number)
+      end
+    end
+
+    # Opens a file in a given package and evals the source
+    #
+    def load_file(package, file)
+      start_new_page
+      example = ExampleFile.new(package, "#{file}.rb")
+      eval example.generate_block_source
+    end
+    
+    
+    # Creates a new ExamplePackage object and yields it to a block in order for
+    # it to be populated with examples, sections and some introduction text.
+    # Used on the package files.
+    #
+    def package(package, &block)
+      ep = ExamplePackage.new(package)
+      ep.instance_eval(&block)
+      ep.render(self)
+    end
+    
+    # Renders an ExamplePackage cover page.
+    #
+    # Starts a new page and renders the package introduction text.
+    #
+    def render_package_cover(package)
+      header(package.name)
+      instance_eval &(package.intro_block)
+
+      outline.define do
+        section(package.name, :destination => page_number, :closed => true)
+      end
+    end
+    
+    # Add the ExampleSection to the document outline within the appropriate
+    # package.
+    #
+    def render_section(section)
+      outline.add_subsection_to(section.package_name) do 
+        outline.section(section.name, :closed => true)
+      end
+    end
+    
+    # Renders an ExampleFile.
+    #
+    # Starts a new page and renders an introductory text, the example source and
+    # evaluates the example source inline whenever that is appropriate according
+    # to the ExampleFile directives.
+    #
+    def render_example(example)
+      start_new_page
+      
+      outline.add_subsection_to(example.parent_name) do 
+        outline.page(:destination => page_number, :title => example.name)
+      end
+      
+      example_header(example.parent_folder_name, example.filename)
+  
+      prose(example.introduction_text)
+      
+      code(example.source)
+      
+      if example.eval?
+        eval_code(example.source) 
+      else
+        source_link(example)
+      end
+      
+      reset_settings
+    end
+    
+    # Render the example header. Used on the example pages of the manual
+    #
+    def example_header(package, example)
+      header_box do
+        register_fonts
+        font('DejaVu', :size => 18) do
+          formatted_text([ { :text => package, :color => BROWN  },
+                           { :text => "/",     :color => BROWN  },
+                           { :text => example, :color => ORANGE }
+                         ], :valign => :center)
+        end
+      end
+    end
+    
+    # Register fonts used on the manual
+    #
+    def register_fonts
+      kai_file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+      font_families["Kai"] = {
+        :normal => { :file => kai_file, :font => "Kai" }
+      }
+
+      dejavu_file = "#{Prawn::DATADIR}/fonts/DejaVuSans.ttf"
+      font_families["DejaVu"] = {
+        :normal => { :file => dejavu_file, :font => "DejaVu" }
+      }
+    end
+    
+    # Render a block of text after processing code tags and URLs to be used with
+    # the inline_format option.
+    #
+    # Used on the introducory text for example pages of the manual and on
+    # package pages intro
+    #
+    def prose(str)
+      
+      # Process the <code> tags
+      str.gsub!(/<code>([^<]+?)<\/code>/,
+          "<font name='Courier'><b>\\1<\/b><\/font>")
+
+      # Process the links
+      str.gsub!(/(https?:\/\/\S+)/,
+                  "<color rgb='#{BLUE}'><link href=\"\\1\">\\1</link></color>")
+      
+      inner_box do
+        font("Helvetica", :size => 11) do
+          str.split(/\n\n+/).each do |paragraph|
+            
+            text(paragraph.gsub(/\s+/," "),
+                 :align         => :justify,
+                 :inline_format => true,
+                 :leading       => LEADING,
+                 :color         => DARK_GRAY)
+            
+            move_down(RHYTHM)
+          end
+        end
+      end
+      
+      move_down(RHYTHM)
+    end
+    
+    # Render a code block. Used on the example pages of the manual
+    #
+    def code(str)
+      pre_text = str.gsub(' ', Prawn::Text::NBSP)
+      pre_text = ::CodeRay.scan(pre_text, :ruby).to_prawn
+      
+      font('Courier', :size => 9.5) do
+        colored_box(pre_text, :fill_color => DARK_GRAY)
+      end
+    end
+
+    # Renders a dashed line and evaluates the code inline
+    #
+    def eval_code(source)
+      move_down(RHYTHM)
+
+      dash(3)
+      stroke_color(BROWN)
+      stroke_horizontal_line(-BOX_MARGIN, bounds.width + BOX_MARGIN)
+      stroke_color(BLACK)
+      undash
+
+      move_down(RHYTHM*3)
+      begin
+        eval(source)
+      rescue => e
+        puts "Error evaluating example: #{e.message}"
+        puts
+        puts "---- Source: ----"
+        puts source
+      end
+    end
+
+    # Renders a box with the link for the example file
+    #
+    def source_link(example)
+      url = "#{MANUAL_URL}/#{example.parent_folder_name}/#{example.filename}"
+      
+      reason = [{ :text  => "This code snippet was not evaluated inline. " +
+                            "You may see its output by running the " +
+                            "example file located here:\n",
+                  :color => DARK_GRAY },
+                  
+                { :text   => url,
+                  :color  => BLUE,
+                  :link   => url}
+               ]
+      
+      font('Helvetica', :size => 9) do
+        colored_box(reason,
+                    :fill_color   => LIGHT_GOLD,
+                    :stroke_color => DARK_GOLD,
+                    :leading      => LEADING*3)
+      end
+    end
+    
+    # Render a page header. Used on the manual lone pages and package
+    # introductory pages
+    #
+    def header(str)
+      header_box do
+        register_fonts
+        font('DejaVu', :size => 24) do
+          text(str, :color  => BROWN, :valign => :center)
+        end
+      end
+    end
+    
+    # Render the arguments as a bulleted list. Used on the manual package
+    # introductory pages
+    #
+    def list(*items)
+      move_up(RHYTHM)
+      
+      inner_box do
+        font("Helvetica", :size => 11) do
+          items.each do |li|
+            float { text("•", :color => DARK_GRAY) }
+            indent(RHYTHM) do
+              text(li.gsub(/\s+/," "), 
+                   :inline_format => true,
+                   :color         => DARK_GRAY,
+                   :leading       => LEADING)
+            end
+
+            move_down(RHYTHM)
+          end
+        end
+      end
+    end
+    
+    # Renders the page-wide headers
+    #
+    def header_box(&block)
+      bounding_box([-bounds.absolute_left, cursor + BOX_MARGIN],
+                   :width  => bounds.absolute_left + bounds.absolute_right,
+                   :height => BOX_MARGIN*2 + RHYTHM*2) do
+        
+        fill_color LIGHT_GRAY
+        fill_rectangle([bounds.left, bounds.top],
+                        bounds.right,
+                        bounds.top - bounds.bottom)
+        fill_color BLACK
+        
+        indent(BOX_MARGIN + INNER_MARGIN, &block)
+      end
+      
+      stroke_color GRAY
+      stroke_horizontal_line(-BOX_MARGIN, bounds.width + BOX_MARGIN, :at => cursor)
+      stroke_color BLACK
+      
+      move_down(RHYTHM*3)
+    end
+    
+    # Renders a Bounding Box for the inner margin
+    #
+    def inner_box(&block)
+      bounding_box([INNER_MARGIN, cursor],
+                   :width => bounds.width - INNER_MARGIN*2,
+                   &block)
+    end
+    
+    # Renders a Bounding Box with some background color and the formatted text
+    # inside it
+    #
+    def colored_box(box_text, options={})
+      options = { :fill_color   => DARK_GRAY,
+                  :stroke_color => nil,
+                  :text_color   => LIGHT_GRAY,
+                  :leading      => LEADING
+                }.merge(options)
+      
+      register_fonts
+      text_options = { :leading        => options[:leading], 
+                       :fallback_fonts => ["DejaVu", "Kai"]
+                     }
+      
+      box_height = height_of_formatted(box_text, text_options)
+      
+      bounding_box([INNER_MARGIN + RHYTHM, cursor],
+                   :width => bounds.width - (INNER_MARGIN+RHYTHM)*2) do
+        
+        fill_color   options[:fill_color]
+        stroke_color options[:stroke_color] || options[:fill_color]
+        fill_and_stroke_rounded_rectangle(
+            [bounds.left - RHYTHM, cursor],
+            bounds.left + bounds.right + RHYTHM*2,
+            box_height + RHYTHM*2,
+            5
+        )
+        fill_color   BLACK
+        stroke_color BLACK
+        
+        pad(RHYTHM) do
+          formatted_text(box_text, text_options)
+        end
+      end
+      
+      move_down(RHYTHM*2)
+    end
+    
+    # Draws X and Y axis rulers beginning at the margin box origin. Used on
+    # examples.
+    #
+    def stroke_axis(options={})
+      options = { :height => (cursor - 20).to_i,
+                  :width => bounds.width.to_i
+                }.merge(options)
+      
+      dash(1, :space => 4)
+      stroke_horizontal_line(-21, options[:width], :at => 0)
+      stroke_vertical_line(-21, options[:height], :at => 0)
+      undash
+      
+      fill_circle [0, 0], 1
+      
+      (100..options[:width]).step(100) do |point|
+        fill_circle [point, 0], 1
+        draw_text point, :at => [point-5, -10], :size => 7
+      end
+
+      (100..options[:height]).step(100) do |point|
+        fill_circle [0, point], 1
+        draw_text point, :at => [-17, point-2], :size => 7
+      end
+    end
+    
+    # Reset some of the Prawn settings including graphics and text to their
+    # defaults.
+    # 
+    # Used after rendering examples so that each new example starts with a clean
+    # slate.
+    #
+    def reset_settings
+      
+      # Text settings
+      font("Helvetica", :size => 12)
+      default_leading 0
+      self.text_direction = :ltr
+      
+      # Graphics settings
+      self.line_width = 1
+      self.cap_style  = :butt
+      self.join_style = :miter
+      undash
+      fill_color   BLACK
+      stroke_color BLACK
+    end
+
+  end
+end