rrtf 0.1.2 → 1.0.0

data/lib/rrtf/node/footer_node.rb

@@ -0,0 +1,47 @@
+module RRTF
+  # This class represents a document footer.
+  class FooterNode < CommandNode
+     # A definition for a header type.
+     UNIVERSAL                                  = :footer
+
+     # A definition for a header type.
+     LEFT_PAGE                                  = :footerl
+
+     # A definition for a header type.
+     RIGHT_PAGE                                 = :footerr
+
+     # A definition for a header type.
+     FIRST_PAGE                                 = :footerf
+
+     # Attribute accessor.
+     attr_reader :type
+
+     # Attribute mutator.
+     attr_writer :type
+
+
+     # This is the constructor for the FooterNode class.
+     #
+     # ==== Parameters
+     # document::  A reference to the Document object that will own the new
+     #             footer.
+     # type::      The style type for the new footer. Defaults to a value of
+     #             FooterNode::UNIVERSAL.
+     def initialize(document, type=UNIVERSAL)
+        super(document, "\\#{type.id2name}", nil, false)
+        @type = type
+     end
+
+     # This method overloads the footnote method inherited from the CommandNode
+     # class to prevent footnotes being added to footers.
+     #
+     # ==== Parameters
+     # text::  Not used.
+     #
+     # ==== Exceptions
+     # RTFError::  Always generated whenever this method is called.
+     def footnote(text)
+        RTFError.fire("Footnotes are not permitted in page footers.")
+     end
+  end # End of the FooterNode class.
+end

data/lib/rrtf/node/geometry_node.rb

@@ -0,0 +1,65 @@
+module RRTF
+  # This class represents a geometry object (shape or text box) within an RTF
+  # document.
+  # @author Wesley Hileman
+  # @since 1.0.0
+  class GeometryNode < CommandNode
+
+    attr_reader :properties
+
+    # Constructor for the GeometryNode class.
+    #
+    # @param [Hash, GeometryProperties] properties a hash or GeometryProperties
+    #   object specifying the properties of the geometry object.
+    def initialize(parent, properties = nil)
+      case properties
+      when Hash
+        @properties = GeometryProperties.new(properties)
+      when GeometryProperties
+        @properties = properties
+      else
+        RTFError.fire("Invalid geometry properties '#{properties}'.")
+      end unless properties.nil?
+
+      prefix = '{\shp{\*\shpinst'
+      prefix << @properties.to_rtf unless properties.nil?
+
+      super(parent, prefix, '}}', false, false)
+    end
+
+    def to_rtf
+      text = StringIO.new
+
+      text << @prefix
+
+      unless self.size() == 0
+        text << '{\shptxt'
+        self.each do |entry|
+           text << "\n"
+           text << entry.to_rtf
+        end # each
+        text << '}'
+      end # unless
+
+      text << @suffix
+
+      text.string
+    end
+
+    # Overrides the {CommandNode#geometry} method to prevent geometry objects
+    # from being nested in other geometry objects.
+    #
+    # @raise [RTFError] whenever called.
+    def geometry(properties = nil)
+      RTFError.fire("Cannot place a geometry object inside of another.")
+    end
+
+    # Overrides the {CommandNode#<<} method to prevent text from being added
+    # to geometry objects directly. Calls {#paragraph} instead.
+    #
+    # @raise [RTFError] whenever called.
+    def <<(text)
+      self.paragraph << text
+    end
+  end # class GeometryNode
+end # module RRTF

data/lib/rrtf/node/header_node.rb

@@ -0,0 +1,47 @@
+module RRTF
+  # This class represents a document header.
+  class HeaderNode < CommandNode
+     # A definition for a header type.
+     UNIVERSAL                                  = :header
+
+     # A definition for a header type.
+     LEFT_PAGE                                  = :headerl
+
+     # A definition for a header type.
+     RIGHT_PAGE                                 = :headerr
+
+     # A definition for a header type.
+     FIRST_PAGE                                 = :headerf
+
+     # Attribute accessor.
+     attr_reader :type
+
+     # Attribute mutator.
+     attr_writer :type
+
+
+     # This is the constructor for the HeaderNode class.
+     #
+     # ==== Parameters
+     # document::  A reference to the Document object that will own the new
+     #             header.
+     # type::      The style type for the new header. Defaults to a value of
+     #             HeaderNode::UNIVERSAL.
+     def initialize(document, type=UNIVERSAL)
+        super(document, "\\#{type.id2name}", nil, false)
+        @type = type
+     end
+
+     # This method overloads the footnote method inherited from the CommandNode
+     # class to prevent footnotes being added to headers.
+     #
+     # ==== Parameters
+     # text::  Not used.
+     #
+     # ==== Exceptions
+     # RTFError::  Always generated whenever this method is called.
+     def footnote(text)
+        RTFError.fire("Footnotes are not permitted in page headers.")
+     end
+  end # End of the HeaderNode class.
+end

data/lib/rrtf/node/image_node.rb

@@ -0,0 +1,175 @@
+require 'fastimage'
+
+module RRTF
+  # This class represents an image within a RTF document. Currently only the
+  # PNG, JPEG and Windows Bitmap formats are supported. Efforts are made to
+  # identify the file type but these are not guaranteed to work.
+  # @author Peter Wood
+  # @author Wesley Hileman
+  # @since legacy
+  class ImageNode < Node
+    # Supported image types.
+    TYPE_DICTIONARY = {
+      :png => 'pngblip',
+      :jpeg => 'jpegblip',
+      :bmp => 'dibitmap0' # device independent bitmap
+    }.freeze
+
+    # Supported sizing modes.
+    SIZING_MODE_DICTIONARY = {
+      # Size the image absolutely according to the given width and height.
+      "ABSOLUTE" => "ABSOLUTE",
+      # Fit the image in the box specified by the given width and height,
+      # preserving the aspect ratio.
+      "FIX_ASPECT_RATIO" => "FIX_ASPECT_RATIO"
+    }.freeze
+
+     attr_reader :type, :width, :height, :displayed_width, :displayed_height, :sizing_mode, :border
+     attr_writer :displayed_width, :displayed_height, :sizing_mode, :border
+
+     # Attempts to extract the type, width, and height of an image using
+     # FastImage.
+     #
+     # @param [String] source the file path to the source image.
+     # @return [Array<Object>] a 3-tuple containing the type, width, and height
+     #   of the image, respectively (type is a symbol, dimensions in pixels).
+     def self.inspect(source)
+       type, width, height = nil
+
+       type = TYPE_DICTIONARY[FastImage.type(source)]
+       width, height = FastImage.size(source) unless type.nil?
+
+       [type, width, height]
+     end # inspect()
+
+     def self.parse_border_array(border)
+       case border
+       when nil
+         []
+       when BorderStyle
+         [border]
+       when Hash
+         [BorderStyle.new(border)]
+       when Array
+         border.collect{ |b| parse_border_array(b) }.flatten.compact
+       else
+         RTFError.fire("Invalid border #{b}.")
+       end
+     end
+
+     # This is the constructor for the ImageNode class.
+     #
+     # @param parent [Node] a reference to the node that owns the new image node.
+     # @param source [String, File] a reference to the image source; this must be a String or a File.
+     # @param id [Integer] a unique 32-bit identifier for the image.
+     # @param options [Hash] a hash of options.
+     # @option options [String] "width" (nil) the display width of the image in twips (can be a string, see {Utilities.value2twips}).
+     # @option options [String] "height" (nil) the display height of the image in twips (can be a string, see {Utilities.value2twips}).
+     # @option options [String] "sizing_mode" ("ABSOLUTE") the method used to size the image (see {SIZING_MODE_DICTIONARY}).
+     # @raise [RTFError] whenever the image specified is not recognised as
+     #   a supported image type, something other than a String or
+     #   File or IO is passed as the source parameter or if the
+     #   specified source does not exist or cannot be accessed.
+     def initialize(parent, source, id, options = {})
+        super(parent)
+        @source = nil
+        @id     = id
+
+        # load default options
+        options = {
+          "width" => nil,
+          "height" => nil,
+          "sizing_mode" => "ABSOLUTE",
+          "border" => nil
+        }.merge(options)
+
+        # extract options
+        @displayed_width    = Utilities.value2twips(options.delete("width"))
+        @displayed_height   = Utilities.value2twips(options.delete("height"))
+        @sizing_mode        = SIZING_MODE_DICTIONARY[options.delete("sizing_mode")]
+        @border             = self.class.parse_border_array(options.delete("border"))
+
+        # store border colours in colour table
+        @border.each do |b|
+          b.push_colours(root.colours)
+        end
+
+        # Store path to image.
+        @source = source if source.instance_of?(String) || source.instance_of?(Tempfile)
+        @source = source.path if source.instance_of?(File)
+
+        # Check the file's existence and accessibility.
+        if !File.exist?(@source)
+           RTFError.fire("Unable to find the #{File.basename(@source)} file.")
+        end
+        if !File.readable?(@source)
+           RTFError.fire("Access to the #{File.basename(@source)} file denied.")
+        end
+        # Attempt to determine image type and dimensions.
+        @type, @width, @height = self.class.inspect(@source)
+        if @type.nil?
+           RTFError.fire("The #{File.basename(@source)} file contains an unknown or unsupported image type.")
+        elsif @width.nil? || @height.nil?
+          RTFError.fire("Could not determine the dimensions of #{File.basename(@source)}.")
+        end # if
+
+        @displayed_width, @displayed_height = size_image
+     end # initialize()
+
+     # This method generates the RTF for an ImageNode object.
+     def to_rtf
+       text  = StringIO.new
+       count = 0
+
+       text << '{\pict'
+       @border.each{ |b| text << " #{b.prefix(self.root)}" }
+       text << "\\picwgoal#{@displayed_width}" if @displayed_width != nil
+       text << "\\pichgoal#{@displayed_height}" if @displayed_height != nil
+       text << "\\picw#{@width}\\pich#{@height}\\bliptag#{@id}"
+       text << "\\#{@type}\n"
+
+       open_file do |file|
+         file.each_byte do |byte|
+           hex_str = byte.to_s(16)
+           hex_str.insert(0,'0') if hex_str.length == 1
+           text << hex_str
+           count += 1
+           if count == 40
+             text << "\n"
+             count = 0
+           end # if
+         end # each_byte
+       end # open_file
+       text << "\n}"
+
+       text.string
+     end # to_rtf()
+
+     private
+
+     def size_image
+       case @sizing_mode
+       when 'ABSOLUTE'
+         [@displayed_width, @displayed_height]
+       when 'FIX_ASPECT_RATIO'
+         width_ratio = @displayed_width ? (@displayed_width.to_f / @width.to_f) : nil
+         height_ratio = @displayed_height ? (@displayed_height.to_f / @height.to_f) : nil
+         scale_factor = [width_ratio, height_ratio].compact.min
+
+         if scale_factor.nil?
+           [@displayed_width, @displayed_height]
+         else
+           [(@width*scale_factor).to_i, (@height*scale_factor).to_i]
+         end
+       end # case
+     end
+
+     def open_file(&block)
+       if block
+         File.open(@source, 'rb', &block)
+       else
+         File.open(@source, 'rb')
+       end # if
+     end # open_file()
+  end # End of the ImageNode class.
+end # module RRTF

data/lib/rrtf/node/link_node.rb

@@ -0,0 +1,10 @@
+module RRTF
+  class LinkNode < CommandNode
+    def initialize(parent, url)
+      prefix = "\\field{\\*\\fldinst HYPERLINK \"#{url}\"}{\\fldrslt "
+      suffix = "}"
+
+      super(parent, prefix, suffix, false)
+    end
+  end
+end

data/lib/rrtf/node/list_level_node.rb

@@ -0,0 +1,44 @@
+module RRTF
+  # This class represents a list level, and carries out indenting information
+  # and the bullet or number that is prepended to each +ListTextNode+.
+  #
+  # The class overrides the +list+ method to implement nesting, and provides
+  # the +item+ method to add a new list item, the +ListTextNode+.
+  class ListLevelNode < CommandNode
+    def initialize(parent, template, kind, level=1)
+      @template = template
+      @kind     = kind
+      @level    = template.level_for(level, kind)
+
+      prefix  = '\pard'
+      prefix << @level.tabs.map {|tw| "\\tx#{tw}"}.join
+      prefix << "\\li#{@level.indent}\\fi-#{@level.indent}"
+      prefix << "\\ql\\qlnatural\\pardirnatural\n"
+      prefix << "\\ls#{@template.id}\\ilvl#{@level.level-1}\\cf0"
+
+      super(parent, prefix, nil, true, false)
+    end
+
+    # Returns the kind of this level, either :bullets or :decimal
+    attr_reader :kind
+
+    # Returns the indenting level of this list, from 1 to 9
+    def level
+      @level.level
+    end
+
+    # Creates a new +ListTextNode+ and yields it to the calling block
+    def item
+      node = ListTextNode.new(self, @level)
+      yield node
+      self.store(node)
+    end
+
+    # Creates a new +ListLevelNode+ to implement nested lists
+    def list(kind=@kind)
+      node = ListLevelNode.new(self, @template, kind, @level.level+1)
+      yield node
+      self.store(node)
+    end
+  end
+end

data/lib/rrtf/node/list_node.rb

@@ -0,0 +1,30 @@
+module RRTF
+  # This class represents an ordered/unordered list within an RTF document.
+  #
+  # Currently list nodes can contain any type of node, but this behaviour
+  # will change in future releases. The class overrides the +list+ method
+  # to return a +ListLevelNode+.
+  #
+  class ListNode < CommandNode
+    def initialize(parent)
+      prefix  = "\\"
+
+      suffix  = '\pard'
+      suffix << ListLevel::ResetTabs.map {|tw| "\\tx#{tw}"}.join
+      suffix << '\ql\qlnatural\pardirnatural\cf0 \\'
+
+      super(parent, prefix, suffix, true, false)
+
+      @template = root.lists.new_template
+    end
+
+    # This method creates a new +ListLevelNode+ of the given kind and
+    # stores it in the document tree.
+    #
+    # ==== Parameters
+    # kind::  The kind of this list level, may be either :bullets or :decimal
+    def list(kind)
+      self.store ListLevelNode.new(self, @template, kind)
+    end
+  end
+end

data/lib/rrtf/node/list_text_node.rb

@@ -0,0 +1,22 @@
+module RRTF
+  # This class represents a list item, that can contain text or
+  # other nodes. Currently any type of node is accepted, but after
+  # more extensive testing this behaviour may change.
+  class ListTextNode < CommandNode
+    def initialize(parent, level)
+      @level  = level
+      @parent = parent
+
+      number = siblings_count + 1 if parent.kind == :decimal
+      prefix = "{\\listtext#{@level.marker.text_format(number)}}"
+      suffix = '\\'
+
+      super(parent, prefix, suffix, false, false)
+    end
+
+    private
+      def siblings_count
+        parent.children.select {|n| n.kind_of?(self.class)}.size
+      end
+  end
+end