rrtf 0.1.2 → 1.0.0

data/lib/rrtf/node/node.rb

@@ -0,0 +1,53 @@
+module RRTF
+  # This class represents an element within an RTF document. The class provides
+  # a base class for more specific node types.
+  class Node
+     # Node parent.
+     attr_accessor :parent
+
+     # Constructor for the Node class.
+     #
+     # ==== Parameters
+     # parent::  A reference to the Node that owns the new Node. May be nil
+     #           to indicate a base or root node.
+     def initialize(parent)
+        @parent = parent
+     end
+
+     # This method retrieves a Node objects previous peer node, returning nil
+     # if the Node has no previous peer.
+     def previous_node
+        peer = nil
+        if !parent.nil? and parent.respond_to?(:children)
+           index = parent.children.index(self)
+           peer  = index > 0 ? parent.children[index - 1] : nil
+        end
+        peer
+     end
+
+     # This method retrieves a Node objects next peer node, returning nil
+     # if the Node has no previous peer.
+     def next_node
+        peer = nil
+        if !parent.nil? and parent.respond_to?(:children)
+           index = parent.children.index(self)
+           peer  = parent.children[index + 1]
+        end
+        peer
+     end
+
+     # This method is used to determine whether a Node object represents a
+     # root or base element. The method returns true if the Nodes parent is
+     # nil, false otherwise.
+     def is_root?
+        @parent.nil?
+     end
+
+     # This method traverses a Node tree to locate the root element.
+     def root
+        node = self
+        node = node.parent while !node.parent.nil?
+        node
+     end
+  end # End of the Node class.
+end

data/lib/rrtf/node/paragraph_node.rb

@@ -0,0 +1,11 @@
+module RRTF
+  # This class represents a paragraph within an RTF document.
+  class ParagraphNode < CommandNode
+    def initialize(parent, style=nil)
+      prefix = '\pard'
+      prefix << style.prefix(parent.root) if style
+
+      super(parent, prefix, '\par')
+    end
+  end
+end

data/lib/rrtf/node/table_cell_node.rb

@@ -0,0 +1,233 @@
+module RRTF
+  # This class represents a cell within an RTF table. The TableCellNode is a
+  # specialised command node that is forbidden from creating tables or having
+  # its parent changed.
+  class TableCellNode < CommandNode
+     # A definition for the default width for the cell.
+     DEFAULT_WIDTH                              = 300
+     # Top border
+     TOP = 0
+     # Right border
+     RIGHT = 1
+     # Bottom border
+     BOTTOM = 2
+     # Left border
+     LEFT = 3
+     # Width of cell
+     attr_accessor :width
+     # Attribute accessor.
+     attr_reader :shading_colour, :style
+
+     # This is the constructor for the TableCellNode class.
+     #
+     # ==== Parameters
+     # row::     The row that the cell belongs to.
+     # width::   The width to be assigned to the cell. This defaults to
+     #           TableCellNode::DEFAULT_WIDTH.
+     # style::   The style that is applied to the cell. This must be a
+     #           ParagraphStyle class. Defaults to nil.
+     # top::     The border width for the cells top border. Defaults to nil.
+     # right::   The border width for the cells right hand border. Defaults to
+     #           nil.
+     # bottom::  The border width for the cells bottom border. Defaults to nil.
+     # left::    The border width for the cells left hand border. Defaults to
+     #           nil.
+     #
+     # ==== Exceptions
+     # RTFError::  Generated whenever an invalid style setting is specified.
+     def initialize(row, width=DEFAULT_WIDTH, style=nil, top=nil, right=nil,
+                    bottom=nil, left=nil)
+        super(row, nil)
+        if !style.nil? and !style.is_paragraph_style?
+           RTFError.fire("Non-paragraph style specified for TableCellNode "\
+                         "constructor.")
+        end
+
+        @width          = (width != nil && width > 0) ? width : DEFAULT_WIDTH
+        @borders        = [(top != nil && top > 0) ? top : nil,
+                           (right != nil && right > 0) ? right : nil,
+                           (bottom != nil && bottom > 0) ? bottom : nil,
+                           (left != nil && left > 0) ? left : nil]
+        @shading_colour = nil
+        @style          = style
+     end
+
+     # Attribute mutator.
+     #
+     # ==== Parameters
+     # style::  A reference to the style object to be applied to the cell.
+     #          Must be an instance of the ParagraphStyle class. Set to nil
+     #          to clear style settings.
+     #
+     # ==== Exceptions
+     # RTFError::  Generated whenever an invalid style setting is specified.
+     def style=(style)
+        if !style.nil? and !style.is_paragraph_style?
+           RTFError.fire("Non-paragraph style specified for TableCellNode "\
+                         "constructor.")
+        end
+        @style = style
+     end
+
+     # This method assigns a width, in twips, for the borders on all sides of
+     # the cell. Negative widths will be ignored and a width of zero will
+     # switch the border off.
+     #
+     # ==== Parameters
+     # width::  The setting for the width of the border.
+     def border_width=(width)
+        size = width.nil? ? 0 : width
+        if size > 0
+           @borders[TOP] = @borders[RIGHT] = @borders[BOTTOM] = @borders[LEFT] = size.to_i
+        else
+           @borders = [nil, nil, nil, nil]
+        end
+     end
+
+     # This method assigns a border width to the top side of a table cell.
+     # Negative values are ignored and a value of 0 switches the border off.
+     #
+     # ==== Parameters
+     # width::  The new border width setting.
+     def top_border_width=(width)
+        size = width.nil? ? 0 : width
+        if size > 0
+           @borders[TOP] = size.to_i
+        else
+           @borders[TOP] = nil
+        end
+     end
+
+     # This method assigns a border width to the right side of a table cell.
+     # Negative values are ignored and a value of 0 switches the border off.
+     #
+     # ==== Parameters
+     # width::  The new border width setting.
+     def right_border_width=(width)
+        size = width.nil? ? 0 : width
+        if size > 0
+           @borders[RIGHT] = size.to_i
+        else
+           @borders[RIGHT] = nil
+        end
+     end
+
+     # This method assigns a border width to the bottom side of a table cell.
+     # Negative values are ignored and a value of 0 switches the border off.
+     #
+     # ==== Parameters
+     # width::  The new border width setting.
+     def bottom_border_width=(width)
+        size = width.nil? ? 0 : width
+        if size > 0
+           @borders[BOTTOM] = size.to_i
+        else
+           @borders[BOTTOM] = nil
+        end
+     end
+
+     # This method assigns a border width to the left side of a table cell.
+     # Negative values are ignored and a value of 0 switches the border off.
+     #
+     # ==== Parameters
+     # width::  The new border width setting.
+     def left_border_width=(width)
+        size = width.nil? ? 0 : width
+        if size > 0
+           @borders[LEFT] = size.to_i
+        else
+           @borders[LEFT] = nil
+        end
+     end
+
+     # This method alters the shading colour associated with a TableCellNode
+     # object.
+     #
+     # ==== Parameters
+     # colour::  A reference to the Colour object to use in shading the cell.
+     #           Assign nil to clear cell shading.
+     def shading_colour=(colour)
+        root.colours << colour
+        @shading_colour = colour
+     end
+
+     # This method retrieves an array with the cell border width settings.
+     # The values are inserted in top, right, bottom, left order.
+     def border_widths
+        widths = []
+        @borders.each {|entry| widths.push(entry.nil? ? 0 : entry)}
+        widths
+     end
+
+     # This method fetches the width for top border of a cell.
+     def top_border_width
+        @borders[TOP].nil? ? 0 : @borders[TOP]
+     end
+
+     # This method fetches the width for right border of a cell.
+     def right_border_width
+        @borders[RIGHT].nil? ? 0 : @borders[RIGHT]
+     end
+
+     # This method fetches the width for bottom border of a cell.
+     def bottom_border_width
+        @borders[BOTTOM].nil? ? 0 : @borders[BOTTOM]
+     end
+
+     # This method fetches the width for left border of a cell.
+     def left_border_width
+        @borders[LEFT].nil? ? 0 : @borders[LEFT]
+     end
+
+     # This method overloads the paragraph method inherited from the
+     # ComamndNode class to forbid the creation of paragraphs.
+     #
+     # ==== Parameters
+     # style::  The paragraph style, ignored
+     def paragraph(style=nil)
+        RTFError.fire("TableCellNode#paragraph() called. Table cells cannot "\
+                      "contain paragraphs.")
+     end
+
+     # This method overloads the parent= method inherited from the Node class
+     # to forbid the alteration of the cells parent.
+     #
+     # ==== Parameters
+     # parent::  A reference to the new node parent.
+     def parent=(parent)
+        RTFError.fire("Table cell nodes cannot have their parent changed.")
+     end
+
+     # This method overrides the table method inherited from CommandNode to
+     # forbid its use in table cells.
+     #
+     # ==== Parameters
+     # rows::     The number of rows for the table.
+     # columns::  The number of columns for the table.
+     # *widths::  One or more integers representing the widths for the table
+     #            columns.
+     def table(rows, columns, *widths)
+        RTFError.fire("TableCellNode#table() called. Nested tables not allowed.")
+     end
+
+     # This method generates the RTF document text for a TableCellNode object.
+     def to_rtf
+        text      = StringIO.new
+        separator = split? ? "\n" : " "
+        line      = (separator == " ")
+
+        text << "\\pard\\intbl"
+        text << @style.prefix(root) if @style != nil
+        text << separator
+        self.each do |entry|
+           text << "\n" if line
+           line = true
+           text << entry.to_rtf
+        end
+        text << (split? ? "\n" : " ")
+        text << "\\cell"
+
+        text.string
+     end
+  end # End of the TableCellNode class.
+end

data/lib/rrtf/node/table_node.rb

@@ -0,0 +1,136 @@
+module RRTF
+  # This class represents a table node within an RTF document. Table nodes are
+  # specialised container nodes that contain only TableRowNodes and have their
+  # size specified when they are created an cannot be resized after that.
+  class TableNode < ContainerNode
+     # Cell margin. Default to 100
+     attr_accessor :cell_margin
+
+     # This is a constructor for the TableNode class.
+     #
+     # ==== Parameters
+     # parent::   A reference to the node that owns the table.
+     # rows::     The number of rows in the table.
+     # columns::  The number of columns in the table.
+     # *widths::  One or more integers specifying the widths of the table
+     #            columns.
+     def initialize(parent, *args, &block)
+       if args.size>=2
+        rows=args.shift
+        columns=args.shift
+        widths=args
+        super(parent) do
+           entries = []
+           rows.times {entries.push(TableRowNode.new(self, columns, *widths))}
+           entries
+        end
+
+       elsif block
+         block.arity<1 ? self.instance_eval(&block) : block.call(self)
+       else
+         raise "You should use 0 or >2 args"
+       end
+        @cell_margin = 100
+     end
+
+     # Attribute accessor.
+     def rows
+        entries.size
+     end
+
+     # Attribute accessor.
+     def columns
+        entries[0].length
+     end
+
+     # This method assigns a border width setting to all of the sides on all
+     # of the cells within a table.
+     #
+     # ==== Parameters
+     # width::  The border width setting to apply. Negative values are ignored
+     #          and zero switches the border off.
+     def border_width=(width)
+        self.each {|row| row.border_width = width}
+     end
+
+     # This method assigns a shading colour to a specified row within a
+     # TableNode object.
+     #
+     # ==== Parameters
+     # index::   The offset from the first row of the row to have shading
+     #           applied to it.
+     # colour::  A reference to a Colour object representing the shading colour
+     #           to be used. Set to nil to clear shading.
+     def row_shading_colour(index, colour)
+        row = self[index]
+        row.shading_colour = colour if row != nil
+     end
+
+     # This method assigns a shading colour to a specified column within a
+     # TableNode object.
+     #
+     # ==== Parameters
+     # index::   The offset from the first column of the column to have shading
+     #           applied to it.
+     # colour::  A reference to a Colour object representing the shading colour
+     #           to be used. Set to nil to clear shading.
+     def column_shading_colour(index, colour)
+        self.each do |row|
+           cell = row[index]
+           cell.shading_colour = colour if cell != nil
+        end
+     end
+
+     # This method provides a means of assigning a shading colour to a
+     # selection of cells within a table. The method accepts a block that
+     # takes three parameters - a TableCellNode representing a cell within the
+     # table, an integer representing the x offset of the cell and an integer
+     # representing the y offset of the cell. If the block returns true then
+     # shading will be applied to the cell.
+     #
+     # ==== Parameters
+     # colour::  A reference to a Colour object representing the shading colour
+     #           to be applied. Set to nil to remove shading.
+     def shading_colour(colour)
+        if block_given?
+           0.upto(self.size - 1) do |x|
+              row = self[x]
+              0.upto(row.size - 1) do |y|
+                 apply = yield row[y], x, y
+                 row[y].shading_colour = colour if apply
+              end
+           end
+        end
+     end
+
+     # This method overloads the store method inherited from the ContainerNode
+     # class to forbid addition of further nodes.
+     #
+     # ==== Parameters
+     # node::  A reference to the node to be added.
+     def store(node)
+        RTFError.fire("Table nodes cannot have nodes added to.")
+     end
+
+     # This method generates the RTF document text for a TableCellNode object.
+     def to_rtf
+        text = StringIO.new
+        size = 0
+
+        self.each do |row|
+           if size > 0
+              text << "\n"
+           else
+              size = 1
+           end
+           text << row.to_rtf
+        end
+
+        text.string.sub(/\\row(?!.*\\row)/m, "\\lastrow\n\\row")
+     end
+
+     alias :column_shading_color :column_shading_colour
+     alias :row_shading_color :row_shading_colour
+     alias :shading_color :shading_colour
+  end # End of the TableNode class.
+end

data/lib/rrtf/node/table_row_node.rb

@@ -0,0 +1,92 @@
+module RRTF
+  # This class represents a row within an RTF table. The TableRowNode is a
+  # specialised container node that can hold only TableCellNodes and, once
+  # created, cannot be resized. Its also not possible to change the parent
+  # of a TableRowNode object.
+  class TableRowNode < ContainerNode
+     # This is the constructor for the TableRowNode class.
+     #
+     # ===== Parameters
+     # table::   A reference to table that owns the row.
+     # cells::   The number of cells that the row will contain.
+     # widths::  One or more integers specifying the widths for the table
+     #           columns
+     def initialize(table, cells, *widths)
+        super(table) do
+           entries = []
+           cells.times do |index|
+              entries.push(TableCellNode.new(self, widths[index]))
+           end
+           entries
+        end
+     end
+
+     # Attribute accessors
+     def length
+        entries.size
+     end
+
+     # This method assigns a border width setting to all of the sides on all
+     # of the cells within a table row.
+     #
+     # ==== Parameters
+     # width::  The border width setting to apply. Negative values are ignored
+     #          and zero switches the border off.
+     def border_width=(width)
+        self.each {|cell| cell.border_width = width}
+     end
+
+     # This method overloads the parent= method inherited from the Node class
+     # to forbid the alteration of the cells parent.
+     #
+     # ==== Parameters
+     # parent::  A reference to the new node parent.
+     def parent=(parent)
+        RTFError.fire("Table row nodes cannot have their parent changed.")
+     end
+
+     # This method sets the shading colour for a row.
+     #
+     # ==== Parameters
+     # colour::  A reference to the Colour object that represents the new
+     #           shading colour. Set to nil to switch shading off.
+     def shading_colour=(colour)
+        self.each {|cell| cell.shading_colour = colour}
+     end
+
+     # This method overloads the store method inherited from the ContainerNode
+     # class to forbid addition of further nodes.
+     #
+     # ==== Parameters
+     # node::  A reference to the node to be added.
+     #def store(node)
+     #   RTFError.fire("Table row nodes cannot have nodes added to.")
+     #end
+
+     # This method generates the RTF document text for a TableCellNode object.
+     def to_rtf
+        text   = StringIO.new
+        temp   = StringIO.new
+        offset = 0
+
+        text << "\\trowd\\tgraph#{parent.cell_margin}"
+        self.each do |entry|
+           widths = entry.border_widths
+           colour = entry.shading_colour
+
+           text << "\n"
+           text << "\\clbrdrt\\brdrw#{widths[0]}\\brdrs" if widths[0] != 0
+           text << "\\clbrdrl\\brdrw#{widths[3]}\\brdrs" if widths[3] != 0
+           text << "\\clbrdrb\\brdrw#{widths[2]}\\brdrs" if widths[2] != 0
+           text << "\\clbrdrr\\brdrw#{widths[1]}\\brdrs" if widths[1] != 0
+           text << "\\clcbpat#{root.colours.index(colour)}" if colour != nil
+           text << "\\cellx#{entry.width + offset}"
+           temp << "\n#{entry.to_rtf}"
+           offset += entry.width
+        end
+        text << "#{temp.string}\n\\row"
+
+        text.string
+     end
+  end # End of the TableRowNode class.
+end