rrtf 0.1.1

data/lib/rrtf/paper.rb

@@ -0,0 +1,53 @@
+module RRTF
+   # This class represents a definition for a paper size and provides a set
+   # of class constants for common paper sizes. An instance of the Paper class
+   # is considered immutable after creation.
+   class Paper
+      # Attribute accessor.
+      attr_reader :name, :width, :height
+
+
+      # This is the constructor for the Paper class. All dimension parameters
+      # to this method are in twips.
+      #
+      # ==== Parameters
+      # name::    The name for the paper object.
+      # width::   The width of the paper in portrait mode.
+      # height::  The height of the paper in portrait mode.
+      def initialize(name, width, height)
+         @name   = name
+         @width  = width
+         @height = height
+      end
+
+      # Definition of an international paper constant.
+      A0                     = Paper.new('A0', 47685, 67416)
+
+      # Definition of an international paper constant.
+      A1                     = Paper.new('A1', 33680, 47685)
+
+      # Definition of an international paper constant.
+      A2                     = Paper.new('A2', 23814, 33680)
+
+      # Definition of an international paper constant.
+      A3                     = Paper.new('A3', 16840, 23814)
+
+      # Definition of an international paper constant.
+      A4                     = Paper.new('A4', 11907, 16840)
+
+      # Definition of an international paper constant.
+      A5                     = Paper.new('A5', 8392, 11907)
+
+      # Definition of a US paper constant.
+      LETTER                 = Paper.new('Letter', 12247, 15819)
+
+      # Definition of a US paper constant.
+      LEGAL                  = Paper.new('Legal', 12247, 20185)
+
+      # Definition of a US paper constant.
+      EXECUTIVE              = Paper.new('Executive', 10773, 14402)
+
+      # Definition of a US paper constant.
+      LEDGER_TABLOID         = Paper.new('Ledger/Tabloid', 15819, 24494)
+   end # End of the Paper class.
+end # End of the RTF module.

data/lib/rrtf/style/character_style.rb

@@ -0,0 +1,68 @@
+require 'stringio'
+
+module RRTF
+  # This class represents a character style for an RTF document.
+  class CharacterStyle < Style
+    include CharacterFormatting
+
+     # This is the constructor for the CharacterStyle class.
+     #
+     # ==== Exceptions
+     # RTFError::  Generate if the parent style specified is not an instance
+     #             of the CharacterStyle class.
+     def initialize(options = {})
+        super(options)
+        initialize_character_formatting(options)
+     end
+
+     # This method overrides the is_character_style? method inherited from the
+     # Style class to always return true.
+     def is_character_style?
+        true
+     end
+
+     # Converts the stylesheet character style into its RTF representation
+     # (for stylesheet)
+     def to_rtf(document, options = {})
+       # load default options
+       options = {
+         "uglify" => false,
+         "base_indent" => 0
+       }.merge(options)
+       # build formatting helpers
+       base_prefix = options["uglify"] ? '' : ' '*options["base_indent"]
+       name_prefix = options["uglify"] ? ' ' : ''
+       suffix = options["uglify"] ? '' : ' '
+
+       rtf = StringIO.new
+
+       rtf << base_prefix
+       rtf << "{\\*\\cs#{handle}#{suffix}"
+       rtf << "#{rtf_formatting(document)}#{suffix}"
+       rtf << "\\additive#{suffix}" if @additive
+       rtf << "\\sbasedon#{@based_on_style_handle}#{suffix}" unless @based_on_style_handle.nil?
+       rtf << "\\sautoupd#{suffix}" if @auto_update
+       rtf << "\\snext#{@next_style_handle}#{suffix}" unless @next_style_handle.nil?
+       rtf << "\\sqformat#{suffix}" if @primary
+       rtf << "\\spriority#{@priority}#{suffix}" unless @priority.nil?
+       rtf << "#{name_prefix}#{name};}"
+
+       rtf.string
+     end
+
+     # This method generates a string containing the prefix associated with a
+     # style object.
+     def prefix(document)
+       text = StringIO.new
+
+       text << "\\cs#{handle} " unless handle.nil?
+       text << rtf_formatting(document)
+
+       text.string
+     end
+
+     def rtf_formatting(document)
+       character_formatting_to_rtf(document)
+     end
+  end # End of the CharacterStyle class.
+end # module RRTF

data/lib/rrtf/style/document_style.rb

@@ -0,0 +1,116 @@
+module RRTF
+  # This class represents styling attributes that are to be applied at the
+  # document level.
+  class DocumentStyle < Style
+     # Definition for a document orientation setting.
+     PORTRAIT                                   = :portrait
+
+     # Definition for a document orientation setting.
+     LANDSCAPE                                  = :landscape
+
+     # Definition for a default margin setting.
+     DEFAULT_LEFT_MARGIN                        = 1800
+
+     # Definition for a default margin setting.
+     DEFAULT_RIGHT_MARGIN                       = 1800
+
+     # Definition for a default margin setting.
+     DEFAULT_TOP_MARGIN                         = 1440
+
+     # Definition for a default margin setting.
+     DEFAULT_BOTTOM_MARGIN                      = 1440
+
+     # stylesheet sorting codes
+     STYLESHEET_SORT_NAME       = 0 # stylesheet styles sorted by name
+     STYLESHEET_SORT_DEFAULT    = 1 # stylesheet styles sorted by system default
+     STYLESHEET_SORT_FONT       = 2 # stylesheet styles sorted by font
+     STYLESHEET_SORT_BASEDON    = 3 # stylesheet styles sorted by based-on fonts
+     STYLESHEET_SORT_TYPE       = 4 # stylesheet styles sorted by type
+
+     # Attribute accessor.
+     attr_reader :paper, :left_margin, :right_margin, :top_margin,
+                 :bottom_margin, :gutter, :orientation, :stylesheet_sort
+
+     # Attribute mutator.
+     attr_writer :paper, :left_margin, :right_margin, :top_margin,
+                 :bottom_margin, :gutter, :orientation, :stylesheet_sort
+
+     # This is a constructor for the DocumentStyle class. This creates a
+     # document style with a default paper setting of LETTER and portrait
+     # orientation (all other attributes are nil).
+     def initialize(options = {})
+       # load default options
+       options = {
+         "paper_size" => Paper::LETTER,
+         "left_margin" => DEFAULT_LEFT_MARGIN,
+         "right_margin" => DEFAULT_RIGHT_MARGIN,
+         "top_margin" => DEFAULT_TOP_MARGIN,
+         "bottom_margin" => DEFAULT_BOTTOM_MARGIN,
+         "gutter" => nil,
+         "orientation" => PORTRAIT,
+         "stylesheet_sort" => STYLESHEET_SORT_DEFAULT
+       }.merge(options)
+
+        @paper           = options.delete("paper_size")
+        @left_margin     = options.delete("left_margin")
+        @right_margin    = options.delete("right_margin")
+        @top_margin      = options.delete("top_margin")
+        @bottom_margin   = options.delete("bottom_margin")
+        @gutter          = options.delete("gutter")
+        @orientation     = options.delete("orientation")
+        @stylesheet_sort = options.delete("stylesheet_sort")
+     end
+
+     # This method overrides the is_document_style? method inherited from the
+     # Style class to always return true.
+     def is_document_style?
+        true
+     end
+
+     # This method generates a string containing the prefix associated with a
+     # style object.
+     #
+     # ==== Parameters
+     # document::  A reference to the document using the style.
+     def prefix(fonts=nil, colours=nil)
+        text = StringIO.new
+
+        text << "\\stylesortmethod#{@stylesheet_sort}" unless @stylesheet_sort.nil?
+        if orientation == LANDSCAPE
+           text << "\\paperw#{@paper.height}"  unless @paper.nil?
+           text << "\\paperh#{@paper.width}"   unless @paper.nil?
+        else
+           text << "\\paperw#{@paper.width}"   unless @paper.nil?
+           text << "\\paperh#{@paper.height}"  unless @paper.nil?
+        end
+        text << "\\margl#{@left_margin}"       unless @left_margin.nil?
+        text << "\\margr#{@right_margin}"      unless @right_margin.nil?
+        text << "\\margt#{@top_margin}"        unless @top_margin.nil?
+        text << "\\margb#{@bottom_margin}"     unless @bottom_margin.nil?
+        text << "\\gutter#{@gutter}"           unless @gutter.nil?
+        text << '\sectd\lndscpsxn' if @orientation == LANDSCAPE
+
+        text.string
+     end
+
+     # This method fetches the width of the available work area space for a
+     # DocumentStyle object.
+     def body_width
+        if orientation == PORTRAIT
+           @paper.width - (@left_margin + @right_margin)
+        else
+           @paper.height - (@left_margin + @right_margin)
+        end
+     end
+
+     # This method fetches the height of the available work area space for a
+     # DocumentStyle object.
+     def body_height
+        if orientation == PORTRAIT
+           @paper.height - (@top_margin + @bottom_margin)
+        else
+           @paper.width - (@top_margin + @bottom_margin)
+        end
+     end
+  end # End of the DocumentStyle class.
+end # module RRTF

data/lib/rrtf/style/formatting.rb

@@ -0,0 +1,276 @@
+require 'stringio'
+
+# Encapsulates all character formatting methods shared between style types
+module RRTF::CharacterFormatting
+  CHARACTER_ATTRIBUTES = {
+    # toggable attributes
+    "bold" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\b' : '\b0') unless value.nil? }
+    },
+    "italic" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\i' : '\i0') unless value.nil? }
+    },
+    "underline" => {
+      "default" => nil,
+      "dictionary" => {
+        "SINGLE" => "",
+        "DOUBLE" => "db",
+        "THICK" => "th",
+        "DASH" => "dash",
+        "LONG_DASH" => "ldash",
+        "DOT" => "d",
+        "DASH_DOT" => "dashd",
+        "DASH_DOT_DOT" => "dashdd",
+        "WAVE" => 'wave',
+        "THICK_DASH" => "thdash",
+        "THICK_LONG_DASH" => "thldash",
+        "THICK_DOT" => "thd",
+        "THICK_DASH_DOT" => "thdashd",
+        "THICK_DASH_DOT_DOT" => "thdashdd",
+        "THICK_WAVE" => 'hwave',
+        "DOUBLE_WAVE" => 'uldbwave'
+      },
+      "to_rtf" => lambda do |value, document|
+        return if value.nil?
+        case value
+        when TrueClass
+          '\ul'
+        when FalseClass
+          '\ulnone'
+        when String
+          "\\ul#{value}"
+        end # case
+      end
+    },
+    "uppercase" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\caps' : '\caps0') unless value.nil? }
+    },
+    "superscript" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\super' : '\super0') unless value.nil? }
+    },
+    "subscript" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\sub' : '\sub0') unless value.nil? }
+    },
+    "strike" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\strike' : '\strike0') unless value.nil? }
+    },
+    "emboss" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\embo' : '\embo0') unless value.nil? }
+    },
+    "imprint" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\impr' : '\impr0') unless value.nil? }
+    },
+    "outline" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\outl' : '\outl0') unless value.nil? }
+    },
+    "hidden" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? '\v' : '\v0') unless value.nil? }
+    },
+    "kerning" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value.is_a?(Integer) ? "\\kerning#{value}" : '\kerning0') unless value.nil? }
+    },
+    # non-toggable attributes
+    "character_spacing_offset" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| "\\expnd#{value}" unless value.nil? }
+    },
+    "foreground_color" => {
+      "default" => nil,
+      "from_user" => lambda{ |value| RRTF::Colour.from_string(value) },
+      "to_rtf" => lambda{ |value, document| "\\cf#{document.colours.index(value)}" unless value.nil? }
+    },
+    "background_color" => {
+      "default" => nil,
+      "from_user" => lambda{ |value| RRTF::Colour.from_string(value) },
+      "to_rtf" => lambda{ |value, document| "\\cb#{document.colours.index(value)}" unless value.nil? }
+    },
+    "underline_color" => {
+      "default" => nil,
+      "from_user" => lambda{ |value| RRTF::Colour.from_string(value) },
+      "to_rtf" => lambda{ |value, document| "\\ulc#{document.colours.index(value)}" unless value.nil? }
+    },
+    "font" => {
+      "default" => nil,
+      "from_user" => lambda{ |value| RRTF::Font.from_string(value) },
+      "to_rtf" => lambda{ |value, document| "\\f#{document.fonts.index(value)}" unless value.nil? }
+    },
+    "font_size" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| "\\fs#{value}" unless value.nil? }
+    }
+  }
+
+  def self.included(base)
+    # define accessors in base for paragraph attributes
+    base.class_eval do
+      CHARACTER_ATTRIBUTES.each do |key, options|
+        attr_accessor :"#{key}"
+      end # each
+    end # class_eval
+  end
+
+  def initialize_character_formatting(options = {})
+    # load default attribute values
+    CHARACTER_ATTRIBUTES.each do |key, options|
+      send("#{key}=", options["default"])
+    end # each
+    # overwrite default attribute values with given values
+    set_character_formatting_from_hashmap(options)
+  end
+
+  def set_character_formatting_from_hashmap(hash)
+    hash.each do |attribute, value|
+      # skip unreconized attributes
+      next unless(CHARACTER_ATTRIBUTES.keys.include?(attribute))
+      # preprocess value if nessesary
+      if CHARACTER_ATTRIBUTES[attribute].has_key?("from_user")
+        value = CHARACTER_ATTRIBUTES[attribute]["from_user"].call(value)
+      elsif CHARACTER_ATTRIBUTES[attribute].has_key?("dictionary") && value.is_a?(String)
+        value = CHARACTER_ATTRIBUTES[attribute]["dictionary"][value]
+      end # if
+      # set attribute value
+      send("#{attribute}=", value)
+    end # each
+  end
+
+  def push_colours(colours)
+    colours << foreground_color unless foreground_color.nil?
+    colours << background_color unless background_color.nil?
+    colours << underline_color unless underline_color.nil?
+  end
+
+  def push_fonts(fonts)
+    fonts << font unless font.nil?
+  end
+
+  def character_formatting_to_rtf(document)
+     text = StringIO.new
+
+     # accumulate RTF representations of attributes
+     CHARACTER_ATTRIBUTES.each do |key, options|
+       text << options["to_rtf"].call(send(key), document) if options.has_key?("to_rtf")
+     end # each
+
+     text.string
+  end
+end # module CharacterFormatting
+
+# Encapsulates all paragraph formatting methods shared between style types
+module RRTF::ParagraphFormatting
+  PARAGRAPH_ATTRIBUTES = {
+    "justification" => {
+      "default" => "l",
+      "dictionary" => {
+        "LEFT" => "l",
+        "RIGHT" => "r",
+        "CENTER" => "c",
+        "CENTRE" => "c",
+        "FULL" => "j"
+      },
+      "to_rtf" => lambda{ |value, document| "\\q#{value}" }
+    },
+    "left_indent" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| "\\li#{value}" unless value.nil? }
+    },
+    "right_indent" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| "\\ri#{value}" unless value.nil? }
+    },
+    "first_line_indent" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| "\\fi#{value}" unless value.nil? }
+    },
+    "space_before" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| "\\sb#{value}" unless value.nil? }
+    },
+    "space_after" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| "\\sa#{value}" unless value.nil? }
+    },
+    "line_spacing" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| "\\sl#{value}" unless value.nil? }
+    },
+    "widow_orphan_ctl" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? "\\widctlpar" : "\\nowidctlpar") unless value.nil? }
+    },
+    "no_break" => {
+      "default" => false,
+      "to_rtf" => lambda{ |value, document| "\\keep" if value }
+    },
+    "no_break_with_next" => {
+      "default" => false,
+      "to_rtf" => lambda{ |value, document| "\\keepn" if value }
+    },
+    "hyphenate" => {
+      "default" => nil,
+      "to_rtf" => lambda{ |value, document| (value ? "\\hyphpar" : "\\hyphpar0") unless value.nil? }
+    },
+    "paragraph_flow" => {
+      "default" => 'ltr',
+      "dictionary" => {
+        "LEFT_TO_RIGHT" => 'ltr',
+        "RIGHT_TO_LEFT" => 'rtl'
+      },
+      "to_rtf" => lambda{ |value, document| "\\#{value}par" unless value.nil? }
+    }
+  }
+
+  def self.included(base)
+    # define accessors in base for paragraph attributes
+    base.class_eval do
+      PARAGRAPH_ATTRIBUTES.each do |key, options|
+        attr_accessor :"#{key}"
+      end # each
+    end # class_eval
+  end
+
+  def initialize_paragraph_formatting(options = {})
+    # load default attribute values
+    PARAGRAPH_ATTRIBUTES.each do |key, options|
+      send("#{key}=", options["default"])
+    end # each
+    # overwrite default attribute values with given values
+    set_paragraph_formatting_from_hashmap(options)
+  end
+
+  def set_paragraph_formatting_from_hashmap(hash)
+    hash.each do |attribute, value|
+      # skip unreconized attributes
+      next unless(PARAGRAPH_ATTRIBUTES.keys.include?(attribute))
+      # preprocess value if nessesary
+      if PARAGRAPH_ATTRIBUTES[attribute].has_key?("from_user")
+        value = PARAGRAPH_ATTRIBUTES[attribute]["from_user"].call(value)
+      elsif PARAGRAPH_ATTRIBUTES[attribute].has_key?("dictionary") && value.is_a?(String)
+        value = PARAGRAPH_ATTRIBUTES[attribute]["dictionary"][value]
+      end # if
+      # set attribute value
+      send("#{attribute}=", value)
+    end # each
+  end
+
+  def paragraph_formatting_to_rtf(document)
+    text = StringIO.new
+
+    # accumulate RTF representations of paragraph attributes
+    PARAGRAPH_ATTRIBUTES.each do |key, options|
+      text << options["to_rtf"].call(send(key), document) if options.has_key?("to_rtf")
+    end # each
+
+    text.string
+  end
+end # module ParagraphFormatting

data/lib/rrtf/style/paragraph_style.rb

@@ -0,0 +1,79 @@
+require 'stringio'
+
+module RRTF
+  # This class represents a styling for a paragraph within an RTF document.
+  # NOTE: Paragraphs can be styled with character commands in addition to
+  # paragraph commands, thus this class includes both paragraph & character
+  # formatting modules
+  class ParagraphStyle < Style
+    include ParagraphFormatting
+    include CharacterFormatting
+
+     def initialize(options = {})
+        super(options)
+        initialize_paragraph_formatting(options)
+        initialize_character_formatting(options)
+     end
+
+     # This method overrides the is_paragraph_style? method inherited from the
+     # Style class to always return true.
+     def is_paragraph_style?
+        true
+     end
+
+     # Converts the stylesheet paragraph style into its RTF representation
+     #
+     # ==== Parameters
+     # fonts::    A reference to a FontTable containing any fonts used by the
+     #            style (may be nil if no fonts used).
+     # colours::  A reference to a ColourTable containing any colours used by
+     #            the style (may be nil if no colours used).
+     def to_rtf(document, options = {})
+       # load default options
+       options = {
+         "uglify" => false,
+         "base_indent" => 0
+       }.merge(options)
+       # build formatting helpers
+       base_prefix = options["uglify"] ? '' : ' '*options["base_indent"]
+       name_prefix = options["uglify"] ? ' ' : ''
+       suffix = options["uglify"] ? '' : ' '
+
+       rtf = StringIO.new
+
+       rtf << base_prefix
+       rtf << "{\\s#{handle}#{suffix}"
+       rtf << "#{rtf_formatting(document)}#{suffix}"
+       rtf << "\\additive#{suffix}" if @additive
+       rtf << "\\sbasedon#{@based_on_style_handle}#{suffix}" unless @based_on_style_handle.nil?
+       rtf << "\\sautoupd#{suffix}" if @auto_update
+       rtf << "\\snext#{@next_style_handle}#{suffix}" unless @next_style_handle.nil?
+       rtf << "\\sqformat#{suffix}" if @primary
+       rtf << "\\spriority#{@priority}#{suffix}" unless @priority.nil?
+       rtf << "#{name_prefix}#{name};}"
+
+       rtf.string
+     end
+
+     # This method generates a string containing the prefix associated with a
+     # style object.
+     #
+     # ==== Parameters
+     # fonts::    A reference to a FontTable containing any fonts used by the
+     #            style (may be nil if no fonts used).
+     # colours::  A reference to a ColourTable containing any colours used by
+     #            the style (may be nil if no colours used).
+     def prefix(document)
+       text = StringIO.new
+
+       text << "\\s#{handle} " unless handle.nil?
+       text << rtf_formatting(document)
+
+       text.string
+     end
+
+     def rtf_formatting(document)
+       "#{paragraph_formatting_to_rtf(document)} #{character_formatting_to_rtf(document)}"
+     end
+  end # End of the ParagraphStyle class.
+end # module RRTF

data/lib/rrtf/style/style.rb

@@ -0,0 +1,101 @@
+# This is a parent class that all style classes will derive from.
+class RRTF::Style
+   attr_accessor :handle, :name, :priority, :primary, :additive,
+                 :next_style_handle, :auto_update, :based_on_style_handle
+
+   # Constructor for the style class.
+   #
+   # ===== Parameters
+   # options:: A hashmap of options for the style. Used only in stylesheet.
+   #   name::        Human-readable name for the style DEFAULT nil
+   #   id::          ID for the style (for use in code) DEFAULT nil
+   #   handle::      A 16-bit integer that identifies the style in a document
+   #                 DEFAULT nil
+   #   flow::        The character flow (Style::LEFT_TO_RIGHT or Style::RIGHT_TO_LEFT)
+   #                 DEFAULT LEFT_TO_RIGHT
+   #   primary::     A Boolean indicating whether or not this style is a
+   #                 primary or "quick" style
+   #   additive::    A Boolean indicating whether or not this style is
+   #                 additive DEFAULT false
+   def initialize(options = {})
+     # load default options
+     options = {
+       "name" => nil,
+       "handle" => nil,
+       "priority" => nil,
+       "flow" => 'LEFT_TO_RIGHT',
+       "primary" => false,
+       "additive" => false,
+       "next_style_handle" => nil,
+       "auto_update" => false,
+       "based_on_style_handle" => nil
+     }.merge(options)
+
+     @handle = options.delete("handle")
+     @name = options.delete("name")
+     @priority = options.delete("priority")
+     @flow = options.delete("flow")
+     @primary = options.delete("primary")
+     @additive = options.delete("additive")
+     @next_style_handle = options.delete("next_style_handle")
+     @auto_update = options.delete("auto_update")
+   end
+
+   # Constructs an RTF identifier for the style.
+   # (override in derived classes as needed)
+   def styledef
+     nil
+   end
+
+   def stylename
+     name
+   end
+
+   # Constructs the RTF formatting representing the style.
+   # (override in derived classes as needed)
+   def to_rtf(document)
+     nil
+   end
+
+   # This method retrieves the command prefix text associated with a Style
+   # object. This method always returns nil and should be overridden by
+   # derived classes as needed.
+   def prefix(document)
+      nil
+   end
+
+   def rtf_formatting
+     nil
+   end
+
+   # This method retrieves the command suffix text associated with a Style
+   # object. This method always returns nil and should be overridden by
+   # derived classes as needed.
+   def suffix(document)
+      nil
+   end
+
+   # Used to determine if the style applies to characters. This method always
+   # returns false and should be overridden by derived classes as needed.
+   def is_character_style?
+      false
+   end
+
+   # Used to determine if the style applies to paragraphs. This method always
+   # returns false and should be overridden by derived classes as needed.
+   def is_paragraph_style?
+      false
+   end
+
+   # Used to determine if the style applies to documents. This method always
+   # returns false and should be overridden by derived classes as needed.
+   def is_document_style?
+      false
+   end
+
+   # Used to determine if the style applies to tables. This method always
+   # returns false and should be overridden by derived classes as needed.
+   def is_table_style?
+      false
+   end
+end # End of the style class.