rrtf 0.1.2 → 1.0.0

data/lib/rrtf/node/text_node.rb

@@ -0,0 +1,76 @@
+require 'stringio'
+
+module RRTF
+  # This class represents a specialisation of the Node class to refer to a Node
+  # that simply contains text.
+  class TextNode < Node
+    # Actual text
+     attr_accessor :text
+
+     # This is the constructor for the TextNode class.
+     #
+     # ==== Parameters
+     # parent::  A reference to the Node that owns the TextNode. Must not be
+     #           nil.
+     # text::    A String containing the node text. Defaults to nil.
+     #
+     # ==== Exceptions
+     # RTFError::  Generated whenever an nil parent object is specified to
+     #             the method.
+     def initialize(parent, text=nil)
+        super(parent)
+        if parent.nil?
+           RTFError.fire("Nil parent specified for text node.")
+        end
+        @parent = parent
+        @text   = text
+     end
+
+     # This method concatenates a String on to the end of the existing text
+     # within a TextNode object.
+     #
+     # ==== Parameters
+     # text::  The String to be added to the end of the text node.
+     def append(text)
+       @text = (@text.nil?) ? text.to_s : @text + text.to_s
+     end
+
+     # This method inserts a String into the existing text within a TextNode
+     # object. If the TextNode contains no text then it is simply set to the
+     # text passed in. If the offset specified is past the end of the nodes
+     # text then it is simply appended to the end.
+     #
+     # ==== Parameters
+     # text::    A String containing the text to be added.
+     # offset::  The numbers of characters from the first character to insert
+     #           the new text at.
+     def insert(text, offset)
+        if !@text.nil?
+           @text = @text[0, offset] + text.to_s + @text[offset, @text.length]
+        else
+           @text = text.to_s
+        end
+     end
+
+     # This method generates the RTF equivalent for a TextNode object. This
+     # method escapes any special sequences that appear in the text.
+     def to_rtf
+       rtf=(@text.nil? ? '' : @text.gsub("{", "\\{").gsub("}", "\\}").gsub("\\", "\\\\"))
+       # This is from lfarcy / rtf-extensions
+       # I don't see the point of coding different 128<n<256 range
+
+       #f1=lambda { |n| n < 128 ? n.chr : n < 256 ? "\\'#{n.to_s(16)}" : "\\u#{n}\\'3f" }
+       # Encode as Unicode.
+
+       f=lambda { |n| n < 128 ? n.chr : "\\u#{n}\\'3f" }
+       # Ruby 1.9 is safe, cause detect original encoding
+       # and convert text to utf-16 first
+       if RUBY_VERSION>"1.9.0"
+         return rtf.encode("UTF-16LE", :undef=>:replace).each_codepoint.map(&f).join('')
+       else
+         # You SHOULD use UTF-8 as input, ok?
+         return rtf.unpack('U*').map(&f).join('')
+       end
+     end
+  end # End of the TextNode class.
+end

data/lib/rrtf/page.rb

@@ -0,0 +1,7 @@
+require 'rrtf/page/margin'
+require 'rrtf/page/size'
+
+# Encapsulates classes that represent various aspects of a page in an RTF
+# document.
+module RRTF::Page
+end

data/lib/rrtf/page/margin.rb

@@ -0,0 +1,98 @@
+module RRTF::Page
+  # Represents the left, right, top, and bottom margin in a document page.
+  # @author Wesley Hileman
+  # @since 1.0.0
+  class Margin
+    attr_accessor :left, :right, :top, :bottom
+
+    # Extracts a margin object from a string.
+    # @see .parse_string
+    #
+    # @param (see {.parse_string})
+    # @return [Margin] the margin object created from the string.
+    # @example Parse margin from a String
+    #   Margin.from_string("12.1pt, 2.2in, 5cm, 4in")
+    #   # => #<RRTF::Margin:0x007fa1b3094500 @left=242, @right=3168, @top=2834, @bottom=5760>
+    def self.from_string(string)
+      self.new(parse_string(string))
+    end
+
+    # Extracts a margin hash from a string.
+    # @param [String] string the string from which to parse the margin, taking
+    #   one of the following formats: "<marg:all>", "<marg:lr>,<marg:tb>", or
+    #   "<marg:l>,<marg:r>,<marg:t>,<marg:b>" where each number may be suffixed
+    #   by an optional unit (see {Utilities.value2twips}).
+    # @return [Hash<String, Integer>] the margin hash created from the string.
+    # @raise [RTFError] if the string cannot be converted into a margin hash.
+    # @example Parse margin from a String
+    #   Margin.parse_string("12.1pt, 2.2in, 5cm, 4in")
+    #   # => {"top"=>2834, "bottom"=>5760, "left"=>242, "right"=>3168} (twips)
+    def self.parse_string(string)
+      values = string.split(',').map(&:strip).collect{ |str| RRTF::Utilities.value2twips(str) }
+      case values.length
+      when 1
+        tblr = values.first
+        {"top" => tblr, "bottom" => tblr, "left" => tblr, "right" => tblr}
+      when 2
+        tb = values.last
+        lr = values.first
+        {"top" => tb, "bottom" => tb, "left" => lr, "right" => lr}
+      when 4
+        l = values[0]
+        r = values[1]
+        t = values[2]
+        b = values[3]
+        {"top" => t, "bottom" => b, "left" => l, "right" => r}
+      else
+        RRTF::RTFError.fire("Invalid margin '#{string}'.")
+      end # case
+    end
+
+    # Builds a new margin object from a string or hash.
+    # @note Margins are stored internally in twentieth points (twips).
+    # @see .from_string
+    # @see .parse_string
+    # @see RRTF::Utilities.value2twips
+    #
+    # @param [String, Hash] value the value from which to parse the margin.
+    # @option value [Integer] "left" the left margin in twips.
+    # @option value [Integer] "right" the right margin in twips.
+    # @option value [Integer] "top" the top margin in twips.
+    # @option value [Integer] "bottom" the bottom margin in twips.
+    def initialize(value = nil)
+      options = {
+        # default 1 inch margins
+        "left" => 1440,
+        "right" => 1440,
+        "top" => 1440,
+        "bottom" => 1440
+      }
+
+      case value
+      when String
+        options = options.merge(self.class.parse_string(value))
+      when Hash
+        options = options.merge(value)
+      when nil
+      else
+        RRTF::RTFError.fire("Cannot create margin from '#{value}'.")
+      end # case
+
+      @left = options.delete("left")
+      @right = options.delete("right")
+      @top = options.delete("top")
+      @bottom = options.delete("bottom")
+    end # initialize
+
+    def ==(obj)
+      obj.class == self.class && obj.state == state
+    end
+    alias_method :eql?, :==
+
+    protected
+
+    def state
+      [@left, @top, @right, @bottom]
+    end
+  end # class Margin
+end # module Page

data/lib/rrtf/page/size.rb

@@ -0,0 +1,98 @@
+module RRTF::Page
+  # Represents the size of a page (width and height).
+  # @author Wesley Hileman
+  # @since 1.0.0
+  class Size
+    attr_accessor :width, :height
+
+    # Dictionary of standard paper sizes in twips.
+    DICTIONARY = {
+      "A0"                  => {"width" => 47685, "height" => 67416},
+      "A1"                  => {"width" => 33680, "height" => 47685},
+      "A2"                  => {"width" => 23814, "height" => 33680},
+      "A3"                  => {"width" => 16840, "height" => 23814},
+      "A4"                  => {"width" => 11907, "height" => 16840},
+      "A5"                  => {"width" => 8392, "height" => 11907},
+      "LETTER"              => {"width" => 12247, "height" => 15819},
+      "LEGAL"               => {"width" => 12247, "height" => 20185},
+      "EXECUTIVE"           => {"width" => 10773, "height" => 14402},
+      "LEDGER_TABLOID"      => {"width" => 15819, "height" => 24494}
+    }.freeze
+
+    # Converts a string representing a paper size into a paper object.
+    # @see .parse_string
+    #
+    # @param (see {.parse_string})
+    # @return [Size] the paper object representing the width & height of the paper.
+    def self.from_string(string)
+      self.new(self.parse_string(string))
+    end
+
+    # Converts a string representing a paper size into an ordered pair
+    # (a two-item array) representing the width and height of the paper.
+    # @see Utilities.value2twips
+    #
+    # @param [String] string the string to be parsed that can take on one of
+    #   two formats: (1) "<SIZE>" where SIZE is an entry in {DICTIONARY}
+    #   or (2) "WIDTH, HEIGHT" where WIDTH and HEIGHT are width and height
+    #   strings with optional units suffix (see {Utilities.value2twips},
+    #   default is twips)
+    # @return [Hash<String, Integer>] the ordered pair (hash with keys "width" and "height")
+    #   representing the width and height of the paper.
+    def self.parse_string(string)
+      # first, try to lookup in size dictionary
+      size = DICTIONARY[string]
+      return size unless size.nil?
+
+      # if not found, try to extract width and height from string
+      parts = string.split(',').map(&:strip).map{ |str| RRTF::Utilities.value2twips(str) }
+      if parts.length == 2
+        return {"width" => parts [0], "height" => parts[1]}
+      end # if
+
+      # unable to parse string
+      RTFError.fire("Unable to parse size from string '#{string}'.")
+    end
+
+    # This is the constructor for the Paper class. All dimension parameters
+    # to this method are in twips.
+    # @note Paper size is stored internally in twentieth points (twips).
+    # @see .from_string
+    # @see .parse_string
+    # @see RRTF::Utilities.value2twips
+    #
+    # @param [String, Hash] value from which to parse the size.
+    # @option value [Integer] "width" the width of the paper in portrait mode (twips).
+    def initialize(value = nil)
+      # default options
+      options = {
+        "width" => 12247,
+        "height" => 15819
+      }
+
+      case value
+      when String
+        options = options.merge(self.class.parse_string(value))
+      when Hash
+        options = options.merge(value)
+      when nil
+      else
+        RRTF::RTFError.fire("Invalid page size format #{value}.")
+      end # case
+
+      @width  = options.delete("width")
+      @height = options.delete("height")
+    end
+
+    def ==(obj)
+      obj.class == self.class && obj.state == state
+    end
+    alias_method :eql?, :==
+
+    protected
+
+    def state
+      [@width, @height]
+    end
+  end # class Size
+end # module Page

data/lib/rrtf/properties.rb

@@ -0,0 +1,3 @@
+require 'rrtf/properties/properties'
+require 'rrtf/properties/document_properties'
+require 'rrtf/properties/geometry_properties'

data/lib/rrtf/properties/document_properties.rb

@@ -0,0 +1,34 @@
+require 'stringio'
+
+module RRTF
+  # This class represents properties that are to be applied at the
+  # document level.
+  # @author Wesley Hileman
+  # @since 1.0.0
+  class DocumentProperties < Properties
+    include DocumentFormatting
+    include PageFormatting
+
+     # This is a constructor for the DocumentProperties class.
+     #
+     # @param [Hash] options
+     # @option options (see {DocumentFormatting#initialize_document_formatting})
+     # @option options (see {PageFormatting#initialize_page_formatting})
+     def initialize(options = {})
+       initialize_document_formatting(options)
+       initialize_page_formatting(options)
+     end
+
+     # Converts a document properties object into an RTF sequence.
+     #
+     # @return [String] the RTF sequence corresponding to the properties object.
+     def to_rtf
+       rtf = StringIO.new
+
+       rtf << document_formatting_to_rtf
+       rtf << page_formatting_to_rtf
+
+       rtf.string
+     end
+  end # End of the DocumentProperties class
+end # module RRTF

data/lib/rrtf/properties/geometry_properties.rb

@@ -0,0 +1,380 @@
+require 'stringio'
+
+module RRTF
+  # This class represents properties that are to be applied to geometry
+  # objects.
+  # @author Wesley Hileman
+  # @since 1.0.0
+  class GeometryProperties < Properties
+
+    HORIZONTAL_REFERENCE_DICTIONARY = {
+      "MARGIN"          => 0,
+      "PAGE"            => 1,
+      "COLUMN"          => 2,
+      "CHARACTER"       => 3,
+      "LEFT_MARGIN"     => 4,
+      "RIGHT_MARGIN"    => 5,
+      "INSIDE_MARGIN"   => 6,
+      "OUTSIDE_MARGIN"  => 7
+    }.freeze
+
+    VERTICAL_REFERENCE_DICTIONARY = {
+      "MARGIN"          => 0,
+      "PAGE"            => 1,
+      "PARAGRAPH"       => 2,
+      "LINE"            => 3,
+      "TOP_MARGIN"      => 4,
+      "BOTTOM_MARGIN"   => 5,
+      "INSIDE_MARGIN"   => 6,
+      "OUTSIDE_MARGIN"  => 7
+    }.freeze
+
+    HORIZONTAL_ALIGNMENT_DICTIONARY = {
+      "ABSOLUTE"        => 0,
+      "LEFT"            => 1,
+      "CENTER"          => 2,
+      "RIGHT"           => 3,
+      "INSIDE"          => 4,
+      "OUTSIDE"         => 5
+    }.freeze
+
+    VERTICAL_ALIGNMENT_DICTIONARY = {
+      "ABSOLUTE"        => 0,
+      "TOP"             => 1,
+      "CENTER"          => 2,
+      "BOTTOM"          => 3,
+      "INSIDE"          => 4,
+      "OUTSIDE"         => 5
+    }.freeze
+
+    WIDTH_REFERENCE_DICTIONARY = {
+      "MARGIN"          => 0,
+      "PAGE"            => 1,
+      "LEFT_MARGIN"     => 2,
+      "RIGHT_MARGIN"    => 3,
+      "INSIDE_MARGIN"   => 4,
+      "OUTSIDE_MARGIN"  => 5
+    }.freeze
+
+    HEIGHT_REFERENCE_DICTIONARY = {
+      "MARGIN"          => 0,
+      "PAGE"            => 1,
+      "TOP_MARGIN"      => 2,
+      "BOTTOM_MARGIN"   => 3,
+      "INSIDE_MARGIN"   => 4,
+      "OUTSIDE_MARGIN"  => 5
+    }.freeze
+
+    TEXT_WRAP_DICTIONARY = {
+      "INLINE"                => {"WRAP" => 1, "SIDE" => nil},
+      "AROUND_BOTH"           => {"WRAP" => 2, "SIDE" => 0},
+      "AROUND_LEFT"           => {"WRAP" => 2, "SIDE" => 1},
+      "AROUND_RIGHT"          => {"WRAP" => 2, "SIDE" => 2},
+      "AROUND_LARGEST"        => {"WRAP" => 2, "SIDE" => 3},
+      "NONE"                  => {"WRAP" => 3, "SIDE" => nil},
+      "TIGHT_AROUND_BOTH"     => {"WRAP" => 4, "SIDE" => 0},
+      "TIGHT_AROUND_LEFT"     => {"WRAP" => 4, "SIDE" => 1},
+      "TIGHT_AROUND_RIGHT"    => {"WRAP" => 4, "SIDE" => 2},
+      "TIGHT_AROUND_LARGEST"  => {"WRAP" => 4, "SIDE" => 3},
+    }.freeze
+
+    GEOMERTY_TYPE_DICTIONARY = {
+      "CUSTOM"                => 0,
+      "RECTANGLE"             => 1,
+      "ROUND_RECTANGLE"       => 2,
+      "ELLIPSE"               => 3,
+      "DIAMOND"               => 4,
+      "ISOSCELES_TRIANGLE"    => 5,
+      "RIGHT_TRIANGLE"        => 6,
+      "PARALLELOGRAM"         => 7,
+      "TRAPEZOID"             => 8,
+      "HEXAGON"               => 9,
+      "OCTAGON"               => 10,
+      "PENTAGON"              => 56,
+      "LINE"                  => 20,
+      "TEXT_BOX"              => 202
+    }.freeze
+
+    TEXT_ANCHOR_DICTIONARY = {
+      "TOP"                       => 0,
+      "MIDDLE"                    => 1,
+      "BOTTOM"                    => 2,
+      "TOP_CENTERED"              => 3,
+      "MIDDLE_CENTERED"           => 4,
+      "BOTTOM_CENTERED"           => 5,
+      "TOP_BASELINE"              => 6,
+      "BOTTOM_BASELINE"           => 7,
+      "TOP_CENTERED_BASELINE"     => 8,
+      "BOTTOM_CENTERED_BASELINE"  => 9
+    }.freeze
+
+    # @note The upper three bits store segment stype, lower 13 bits store the
+    #   number of segments of that type to appear in series (always 1 -- except
+    #   for control segments -- for the non-compressed encoding used here
+    #   where the codes for segments of the same type that appear in series are
+    #   repeated).
+    PATH_SEGMENT_DICTIONARY = {
+      # draw a line from the current point to a specified end point
+      # [requires one additional point]
+      "LINE_TO"                   => "0001".to_i(16),
+      # draw a cubic bezier curve using the current point, two control points,
+      # and an end point [requires three additional points]
+      "CUBIC_BEZIER_TO"           => "2001".to_i(16),
+      # draw a line from the current point to the starting point and close
+      # the path [requires no additional points]
+      "CLOSE_PATH"                => "6001".to_i(16),
+      # start a path (control segment) [requires one point]
+      "START_AT"                  => "4000".to_i(16),
+      # end a path (control segment) [requires no points]
+      "END"                       => "8000".to_i(16)
+    }.freeze
+
+     # This is a constructor for the GeometryProperties class.
+     #
+     # @param [Hash] options
+     def initialize(options = {})
+       @type                        = GEOMERTY_TYPE_DICTIONARY[options.delete("type")]
+       @rotation                    = Utilities.value2geomfrac(options.delete("rotate"))
+       @left                        = Utilities.value2twips(options.delete("left"))
+       @right                       = Utilities.value2twips(options.delete("right"))
+       @top                         = Utilities.value2twips(options.delete("top"))
+       @bottom                      = Utilities.value2twips(options.delete("bottom"))
+       @z_index                     = options.delete("z_index")
+       @horizontal_reference        = HORIZONTAL_REFERENCE_DICTIONARY[options.delete("horizontal_reference")] || HORIZONTAL_REFERENCE_DICTIONARY["MARGIN"]
+       @vertical_reference          = VERTICAL_REFERENCE_DICTIONARY[options.delete("vertical_reference")] || VERTICAL_REFERENCE_DICTIONARY["MARGIN"]
+       @text_wrap                   = TEXT_WRAP_DICTIONARY[options.delete("text_wrap")]
+       @below_text                  = Utilities.value2geombool(options.delete("below_text"))
+       @lock_anchor                 = options.delete("lock_anchor")
+       @horizontal_alignment        = HORIZONTAL_ALIGNMENT_DICTIONARY[options.delete("horizontal_alignment")] || HORIZONTAL_ALIGNMENT_DICTIONARY["ABSOLUTE"]
+       @vertical_alignment          = VERTICAL_ALIGNMENT_DICTIONARY[options.delete("vertical_alignment")] || VERTICAL_ALIGNMENT_DICTIONARY["ABSOLUTE"]
+       @allow_overlap               = Utilities.value2geombool(options.delete("allow_overlap"))
+       @width_reference             = WIDTH_REFERENCE_DICTIONARY[options.delete("width_reference")] || WIDTH_REFERENCE_DICTIONARY["MARGIN"]
+       @height_reference            = HEIGHT_REFERENCE_DICTIONARY[options.delete("height_reference")] || HEIGHT_REFERENCE_DICTIONARY["MARGIN"]
+       @width, @width_units         = Utilities.parse_string_with_units(options.delete("width"))
+       @height, @height_units       = Utilities.parse_string_with_units(options.delete("height"))
+       @width                       = Utilities.value2twips("#{@width}#{@width_units}") unless @width.nil? || @width_units == '%'
+       @height                      = Utilities.value2twips("#{@height}#{@height_units}") unless @height.nil? || @height_units == '%'
+       @fill_color                  = options.delete("fill_color")
+       @has_fill                    = Utilities.value2geombool(options.delete("has_fill") || !@fill_color.nil?)
+       @line_color                  = options.delete("line_color")
+       @line_width                  = Utilities.value2emu(options.delete("line_width"))
+       @has_line                    = Utilities.value2geombool(options.delete("has_line") || !@line_color.nil? || !@line_width.nil?)
+       @text_margin                 = options.delete("text_margin")
+       @text_anchor                 = TEXT_ANCHOR_DICTIONARY[options.delete("text_anchor")]
+       @fit_to_text                 = Utilities.value2geombool(options.delete("fit_to_text"))
+       @fit_text_to_shape           = Utilities.value2geombool(options.delete("fit_text_to_shape"))
+       @flip_horizontal             = Utilities.value2geombool(options.delete("flip_horizontal"))
+       @flip_vertical               = Utilities.value2geombool(options.delete("flip_vertical"))
+       @path                        = options.delete("path")
+       @path_coordinate_origin      = options.delete("path_coordinate_origin") || [0, 0]
+       @path_coordinate_limits      = options.delete("path_coordinate_limits") || [21600, 21600]
+
+       parse_dimensions!
+       parse_color! :fill_color, :line_color
+       parse_margin! :text_margin
+       parse_path!
+
+       unless options.empty?
+         RTFError.fire("Unreconized geometry options #{options}.")
+       end # unless
+     end # initialize()
+
+     # Converts a geometry properties object into an RTF sequence.
+     #
+     # @return [String] the RTF sequence corresponding to the properties object.
+     def to_rtf
+       rtf = StringIO.new
+
+       # keyword properties
+       rtf << "\\shpleft#{@left}"                         unless @left.nil?
+       rtf << "\\shpright#{@right}"                       unless @right.nil?
+       rtf << "\\shptop#{@top}"                           unless @top.nil?
+       rtf << "\\shpbottom#{@bottom}"                     unless @bottom.nil?
+       rtf << "\\shpz#{@z_index}"                         unless @z_index.nil?
+       rtf << "\\shpbxpage"                               if @horizontal_reference == HORIZONTAL_REFERENCE_DICTIONARY["PAGE"]
+       rtf << "\\shpbxmargin"                             if @horizontal_reference == HORIZONTAL_REFERENCE_DICTIONARY["MARGIN"]
+       rtf << "\\shpbxcolumn"                             if @horizontal_reference == HORIZONTAL_REFERENCE_DICTIONARY["COLUMN"]
+       rtf << "\\shpbxignore"                             unless @vertical_reference.nil?
+       rtf << "\\shpbypage"                               if @vertical_reference == VERTICAL_REFERENCE_DICTIONARY["PAGE"]
+       rtf << "\\shpbymargin"                             if @vertical_reference == VERTICAL_REFERENCE_DICTIONARY["MARGIN"]
+       rtf << "\\shpbypara"                               if @vertical_reference == VERTICAL_REFERENCE_DICTIONARY["PARAGRAPH"]
+       rtf << "\\shpbyignore"                             unless @vertical_reference.nil?
+       rtf << "\\shpwr#{@text_wrap["WRAP"]}"              unless @text_wrap.nil? || @text_wrap["WRAP"].nil?
+       rtf << "\\shpwrk#{@text_wrap["SIDE"]}"             unless @text_wrap.nil? || @text_wrap["SIDE"].nil?
+       rtf << "\\shpfblwtxt#{@below_text}"                unless @below_text.nil?
+       rtf << "\\shplockanchor"                           if @lock_anchor
+
+       rtf << "\n"
+
+       # object properties
+       rtf << build_property("shapeType", @type)                          unless @type.nil?
+       rtf << build_property("rotation", @rotation)                       unless @rotation.nil?
+       rtf << build_property("posh", @horizontal_alignment)               unless @horizontal_alignment.nil?
+       rtf << build_property("posrelh", @horizontal_reference)            unless @horizontal_reference.nil?
+       rtf << build_property("posv", @vertical_alignment)                 unless @vertical_alignment.nil?
+       rtf << build_property("posrelv", @vertical_reference)              unless @vertical_reference.nil?
+       rtf << build_property("fAllowOverlap", @allow_overlap)             unless @allow_overlap.nil?
+       rtf << build_property("pctHoriz", @width)                          unless @width.nil? || @width_units != '%'
+       rtf << build_property("pctVert", @height)                          unless @height.nil? || @height_units != '%'
+       rtf << build_property("sizerelh", @width_reference)                unless @width_reference.nil?
+       rtf << build_property("sizerelv", @height_reference)               unless @height_reference.nil?
+       rtf << build_property("fFilled", @has_fill)                        unless @has_fill.nil?
+       rtf << build_property("fillColor", @fill_color)                    unless @fill_color.nil?
+       rtf << build_property("fLine", @has_line)                          unless @has_fill.nil?
+       rtf << build_property("lineColor", @line_color)                    unless @line_color.nil?
+       rtf << build_property("lineWidth", @line_width)                    unless @line_width.nil?
+       rtf << build_property("dxTextLeft", @text_margin_left)             unless @text_margin_left.nil?
+       rtf << build_property("dxTextRight", @text_margin_right)           unless @text_margin_right.nil?
+       rtf << build_property("dyTextTop", @text_margin_top)               unless @text_margin_top.nil?
+       rtf << build_property("dyTextBottom", @text_margin_bottom)         unless @text_margin_bottom.nil?
+       rtf << build_property("anchorText", @text_anchor)                  unless @text_anchor.nil?
+       rtf << build_property("fBehindDocument", @below_text)              unless @below_text.nil?
+       rtf << build_property("fFitShapeToText", @fit_to_text)             unless @fit_to_text.nil?
+       rtf << build_property("fFitTextToShape", @fit_text_to_shape)       unless @fit_text_to_shape.nil?
+       rtf << build_property("fFlipH", @flip_horizontal)                  unless @flip_horizontal.nil?
+       rtf << build_property("fFlipV", @flip_vertical)                    unless @flip_vertical.nil?
+       rtf << build_property("geoLeft", @path_coordinate_origin[0])       unless @path.nil? || @path_coordinate_origin.nil?
+       rtf << build_property("geoTop", @path_coordinate_origin[1])        unless @path.nil? || @path_coordinate_origin.nil?
+       rtf << build_property("geoRight", @path_coordinate_limits[0])      unless @path.nil? || @path_coordinate_limits.nil?
+       rtf << build_property("geoBottom", @path_coordinate_limits[1])     unless @path.nil? || @path_coordinate_limits.nil?
+       rtf << build_property("pVerticies", @path_verticies)               unless @path.nil? || @path_verticies.nil?
+       rtf << build_property("pSegmentInfo", @path_segment_info)          unless @path.nil? || @path_segment_info.nil?
+       rtf << build_property("pConnectionSites", @path_connection_sites)  unless @path.nil? || @path_connection_sites.nil?
+       rtf << build_property("fLineOK", 1)
+       rtf << build_property("fFillOK", 1)
+       rtf << build_property("f3DOK", 1)
+
+       rtf.string
+     end
+
+     private
+
+     def build_property(name, value)
+       "{\\sp{\\sn #{name}}{\\sv #{value}}}\n"
+     end
+
+     def build_array(array, bytes_per_element)
+       "#{bytes_per_element};#{array.length};#{array.join(';')}"
+     end
+
+     def array2emu(array)
+       array.collect{ |el| Utilities.value2emu(el) }
+     end
+
+     def parse_dimensions!
+       unless @width.nil?
+         if @width_units == '%'
+           @percent_width = @width
+         else
+           case [@left.nil?, @right.nil?]
+           when [true, true]
+             @left = 0
+             @right = @width
+           when [true, false]
+             @left = @right - @width
+           when [false, true]
+             @right = @left + @width
+           end # case
+         end # if
+       end # unless
+
+       unless @height.nil?
+         if @height_units == '%'
+           @percent_height = @height
+         else
+           case [@top.nil?, @bottom.nil?]
+           when [true, true]
+             @top = 0
+             @bottom = @height
+           when [true, false]
+             @top = @bottom - @height
+           when [false, true]
+             @bottom = @top + @height
+           end # case
+         end # if
+       end # unless
+     end # parse_dimensions()
+
+     def parse_color!(*color_attrs)
+       color_attrs.each do |color_attr|
+         color = instance_variable_get(:"@#{color_attr}")
+
+         unless color.nil?
+           case color
+           when String
+             color = Colour.from_string(color).to_decimal("reverse_bytes" => true)
+           when Colour
+             color = color.to_decimal
+           else
+             RTFError.fire("Unsupported color format #{color}.")
+           end # case
+         end # unless
+
+         instance_variable_set(:"@#{color_attr}", color)
+       end # each
+     end # parse_color()
+
+     def parse_margin!(*margin_attrs)
+       margin_attrs.each do |margin_attr|
+         margin = instance_variable_get("@#{margin_attr}")
+         next if margin.nil?
+
+         margin = Page::Margin.new(margin)
+         left = Utilities.value2emu(margin.left+'twip')
+         right = Utilities.value2emu(margin.right+'twip')
+         top = Utilities.value2emu(margin.top+'twip')
+         bottom = Utilities.value2emu(margin.bottom+'twip')
+
+         instance_variable_set("@#{margin_attr}", margin)
+         instance_variable_set("@#{margin_attr}_left", left)
+         instance_variable_set("@#{margin_attr}_right", right)
+         instance_variable_set("@#{margin_attr}_top", top)
+         instance_variable_set("@#{margin_attr}_bottom", bottom)
+       end
+     end # parse_margin()
+
+     def parse_path!
+       return if @path.nil?
+
+       verticies = []
+       connection_sites = []
+       seg_info = []
+
+       unless @path.is_a?(Array) && @path.collect{ |tup| tup.is_a?(Array) && (1..5).include?(tup.length) }.all?
+         RTFError.fire("Path segments must be an array of arrays with length 1 through 5.")
+       end # unless
+
+       sx = (@path_coordinate_limits[0] - @path_coordinate_origin[0]).to_f/(Utilities.value2emu("#{@width}twip")).to_f
+       sy = (@path_coordinate_limits[1] - @path_coordinate_origin[1]).to_f/(Utilities.value2emu("#{@height}twip")).to_f
+
+       @path.each do |seg|
+         # first item in segment array gives the segment type
+         type = seg[0]
+
+         if PATH_SEGMENT_DICTIONARY[type].nil?
+           RTFError.fire("Invalid segment type '#{type}'.")
+         end # case
+
+         if seg.length > 1
+           # remaining items give the points associated with the segment
+           # (last element is the end point; bezier curves also have a control
+           # point before last point; the starting point is given by the end
+           # point of the last segment)
+           points = seg[1..(seg.length - 1)].collect{ |p| array2emu(p) }.collect{ |p| [(p[0]*sx).round, (p[1]*sy).round] }
+           verticies += points
+           # the last point is the endpoint for the segment that forms a
+           # "connection site" with the next segment
+           connection_sites << points.last
+         end # if
+
+         # add appropriate code to the segment information array indicating the
+         # type of segment to create
+         seg_info << PATH_SEGMENT_DICTIONARY[type]
+       end # each
+
+       @path_verticies        = build_array(verticies.collect{ |v| "(#{v[0]},#{v[1]})" }, 8)
+       @path_connection_sites = build_array(connection_sites.collect{ |s| "(#{s[0]},#{s[1]})" }, 8)
+       @path_segment_info     = build_array(seg_info, 2)
+     end # parse_path()
+  end # End of the DocumentProperties class
+end # module RRTF