Class: RTF::CommandNode

Inherits:
ContainerNode show all
Defined in:
lib/rtf/node.rb

Overview

This class represents a RTF command element within a document. This class is concrete enough to be used on its own but will also be used as the base class for some specific command node types.

Instance Attribute Summary collapse

Attributes inherited from ContainerNode

#children

Attributes inherited from Node

#parent

Instance Method Summary collapse

Methods inherited from ContainerNode

#[], #each, #first, #last, #size, #store

Methods inherited from Node

#is_root?, #next_node, #previous_node, #root

Constructor Details

#initialize(parent, prefix, suffix = nil, split = true, wrap = true) ⇒ CommandNode

This is the constructor for the CommandNode class.

Parameters

parent

A reference to the node that owns the new node.

prefix

A String containing the prefix text for the command.

suffix

A String containing the suffix text for the command. Defaults to nil.

split

A boolean to indicate whether the prefix and suffix should be written to separate lines whether the node is converted to RTF. Defaults to true.

wrap

A boolean to indicate whether the prefix and suffix should be wrapped in curly braces. Defaults to true.



240
241
242
243
244
245
246
 
# File 'lib/rtf/node.rb', line 240

def initialize(parent, prefix, suffix=nil, split=true, wrap=true)
   super(parent)
   @prefix = prefix
   @suffix = suffix
   @split  = split
   @wrap   = wrap
end

Instance Attribute Details

#prefix ⇒ Object

String containing the prefix text for the command



217
218
219
 
# File 'lib/rtf/node.rb', line 217

def prefix
  @prefix
end

#split ⇒ Object Also known as: split?

A boolean to indicate whether the prefix and suffix should be written to separate lines whether the node is converted to RTF. Defaults to true



223
224
225
 
# File 'lib/rtf/node.rb', line 223

def split
  @split
end

#suffix ⇒ Object

String containing the suffix text for the command



219
220
221
 
# File 'lib/rtf/node.rb', line 219

def suffix
  @suffix
end

#wrap ⇒ Object Also known as: wrap?

A boolean to indicate whether the prefix and suffix should be wrapped in curly braces. Defaults to true.



226
227
228
 
# File 'lib/rtf/node.rb', line 226

def wrap
  @wrap
end

Instance Method Details

#<<(text) ⇒ Object Also known as: write

This method adds text to a command node. If the last child node of the target node is a TextNode then the text is appended to that. Otherwise a new TextNode is created and append to the node.

Parameters

text

The String of text to be written to the node.



254
255
256
257
258
259
260
 
# File 'lib/rtf/node.rb', line 254

def <<(text)
   if last != nil and last.respond_to?(:text=)
      last.append(text)
   else
      self.store(TextNode.new(self, text))
   end
end

#apply(style) {|node| ... } ⇒ Object

This method provides a short cut means for applying multiple styles via single command node. The method accepts a block that will be passed a reference to the node created. Once the block is complete the new node will be append as the last child of the CommandNode the method is called on.

Parameters

style

A reference to a CharacterStyle object that contains the style settings to be applied.

Exceptions

RTFError

Generated whenever a non-character style is specified to the method.

Yields:

  • (node) 


377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
 
# File 'lib/rtf/node.rb', line 377

def apply(style)
   # Check the input style.
   if style.is_character_style? == false
      RTFError.fire("Non-character style specified to the "\
                    "CommandNode#apply() method.")
   end

   # Store fonts and colours.
   root.colours << style.foreground if style.foreground != nil
   root.colours << style.background if style.background != nil
   root.fonts << style.font if style.font != nil

   # Generate the command node.
   node = CommandNode.new(self, style.prefix(root.fonts, root.colours))
   yield node if block_given?
   self.store(node)
end

#background(colour) ⇒ Object

This method provides a short cut means of creating a background colour command node. The method accepts a block that will be passed a single parameter which will be a reference to the background colour node created. After the block is complete the background colour node is appended to the end of the child nodes on the object that the method is called against.

Parameters

colour

The background colour to be applied by the command.



537
538
539
540
541
542
543
544
545
546
 
# File 'lib/rtf/node.rb', line 537

def background(colour)
   style            = CharacterStyle.new
   style.background = colour
   root.colours << colour
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#bold ⇒ Object

This method provides a short cut means of creating a bold command node. The method accepts a block that will be passed a single parameter which will be a reference to the bold node created. After the block is complete the bold node is appended to the end of the child nodes on the object that the method is call against.



400
401
402
403
404
405
406
407
408
 
# File 'lib/rtf/node.rb', line 400

def bold
   style      = CharacterStyle.new
   style.bold = true
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#colour(fore, back) ⇒ Object Also known as: color

This method provides a short cut menas of creating a colour node that deals with foreground and background colours. The method accepts a block that will be passed a single parameter which will be a reference to the colour node created. After the block is complete the colour node is append to the end of the child nodes on the object that the method is called against.

Parameters

fore

The foreground colour to be applied by the command.

back

The background colour to be applied by the command.



558
559
560
561
562
563
564
565
566
567
568
569
 
# File 'lib/rtf/node.rb', line 558

def colour(fore, back)
   style            = CharacterStyle.new
   style.foreground = fore
   style.background = back
   root.colours << fore
   root.colours << back
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#font(font, size = nil) ⇒ Object

This method provides a short cut means of creating a font command node. The method accepts a block that will be passed a single parameter which will be a reference to the font node created. After the block is complete the font node is appended to the end of the child nodes on the object that the method is called against.

Parameters

font

A reference to font object that represents the font to be used within the node.

size

An integer size setting for the font. Defaults to nil to indicate that the current font size should be used.



496
497
498
499
500
501
502
503
504
505
506
 
# File 'lib/rtf/node.rb', line 496

def font(font, size=nil)
   style           = CharacterStyle.new
   style.font      = font
   style.font_size = size
   root.fonts << font
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#footnote(text) ⇒ Object

This method inserts a footnote at the current position in a node.

Parameters

text

A string containing the text for the footnote.



341
342
343
344
345
346
347
348
349
 
# File 'lib/rtf/node.rb', line 341

def footnote(text)
   if text != nil && text != ''
      mark = CommandNode.new(self, '\fs16\up6\chftn', nil, false)
      note = CommandNode.new(self, '\footnote {\fs16\up6\chftn}', nil, false)
      note.paragraph << text
      self.store(mark)
      self.store(note)
   end
end

#foreground(colour) ⇒ Object

This method provides a short cut means of creating a foreground colour command node. The method accepts a block that will be passed a single parameter which will be a reference to the foreground colour node created. After the block is complete the foreground colour node is appended to the end of the child nodes on the object that the method is called against.

Parameters

colour

The foreground colour to be applied by the command.



517
518
519
520
521
522
523
524
525
526
 
# File 'lib/rtf/node.rb', line 517

def foreground(colour)
   style            = CharacterStyle.new
   style.foreground = colour
   root.colours << colour
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#image(source) ⇒ Object

This method inserts a new image at the current position in a node.

Parameters

source

Either a string containing the path and name of a file or a File object for the image file to be inserted.

Exceptions

RTFError

Generated whenever an invalid or inaccessible file is specified or the image file type is not supported.



360
361
362
 
# File 'lib/rtf/node.rb', line 360

def image(source)
   self.store(ImageNode.new(self, source, root.get_id))
end

#italic ⇒ Object

This method provides a short cut means of creating an italic command node. The method accepts a block that will be passed a single parameter which will be a reference to the italic node created. After the block is complete the italic node is appended to the end of the child nodes on the object that the method is call against.



415
416
417
418
419
420
421
422
423
 
# File 'lib/rtf/node.rb', line 415

def italic
   style        = CharacterStyle.new
   style.italic = true
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#line_break ⇒ Object

This method provides a short cut means of creating a line break command node. This command node does not take a block and may possess no other content.



332
333
334
335
 
# File 'lib/rtf/node.rb', line 332

def line_break
   self.store(CommandNode.new(self, '\line', nil, false))
   nil
end

#link(url, text = nil) {|node| ... } ⇒ Object

Yields:

  • (node) 


322
323
324
325
326
327
 
# File 'lib/rtf/node.rb', line 322

def link(url, text=nil)
  node = LinkNode.new(self, url)
  node << text if text
  yield node   if block_given?
  self.store(node)
end

#list(kind = :bullets) {|node.list(kind)| ... } ⇒ Object

This method provides a short cut means of creating a new ordered or unordered list. The method requires a block that will be passed a single parameter that’ll be a reference to the first level of the list. See the ListLevelNode doc for more information.

Example usage:

rtf.list do |level1|
  level1.item do |li|
    li << 'some text'
    li.apply(some_style) {|x| x << 'some styled text'}
  end

  level1.list(:decimal) do |level2|
    level2.item {|li| li << 'some other text in a decimal list'}
    level2.item {|li| li << 'and here we go'}
  end
end

Yields:



316
317
318
319
320
 
# File 'lib/rtf/node.rb', line 316

def list(kind=:bullets)
  node = ListNode.new(self)
  yield node.list(kind)
  self.store(node)
end

#paragraph(style = nil) {|node| ... } ⇒ Object

This method provides a short cut means of creating a paragraph command node. The method accepts a block that will be passed a single parameter which will be a reference to the paragraph node created. After the block is complete the paragraph node is appended to the end of the child nodes on the object that the method is called against.

Parameters

style

A reference to a ParagraphStyle object that defines the style for the new paragraph. Defaults to nil to indicate that the currently applied paragraph styling should be used.

Yields:

  • (node) 


291
292
293
294
295
 
# File 'lib/rtf/node.rb', line 291

def paragraph(style=nil)
   node = ParagraphNode.new(self, style)
   yield node if block_given?
   self.store(node)
end

#strike ⇒ Object

This method provides a short cut means of creating a strike command node. The method accepts a block that will be passed a single parameter which will be a reference to the strike node created. After the block is complete the strike node is appended to the end of the child nodes on the object that the method is call against.



475
476
477
478
479
480
481
482
483
 
# File 'lib/rtf/node.rb', line 475

def strike
   style        = CharacterStyle.new
   style.strike = true
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#subscript ⇒ Object

This method provides a short cut means of creating a subscript command node. The method accepts a block that will be passed a single parameter which will be a reference to the subscript node created. After the block is complete the subscript node is appended to the end of the child nodes on the object that the method is call against.



445
446
447
448
449
450
451
452
453
 
# File 'lib/rtf/node.rb', line 445

def subscript
   style           = CharacterStyle.new
   style.subscript = true
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#superscript ⇒ Object

This method provides a short cut means of creating a superscript command node. The method accepts a block that will be passed a single parameter which will be a reference to the superscript node created. After the block is complete the superscript node is appended to the end of the child nodes on the object that the method is call against.



460
461
462
463
464
465
466
467
468
 
# File 'lib/rtf/node.rb', line 460

def superscript
   style             = CharacterStyle.new
   style.superscript = true
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end

#table(rows, columns, *widths) {|node| ... } ⇒ Object

This method creates a new table node and returns it. The method accepts a block that will be passed the table as a parameter. The node is added to the node the method is called upon after the block is complete.

Parameters

rows

The number of rows that the table contains.

columns

The number of columns that the table contains.

*widths

One or more integers representing the widths for the table columns.

Yields:

  • (node) 


580
581
582
583
584
585
 
# File 'lib/rtf/node.rb', line 580

def table(rows, columns, *widths)
   node = TableNode.new(self, rows, columns, *widths)
   yield node if block_given?
   store(node)
   node
end

#to_rtf ⇒ Object

This method generates the RTF text for a CommandNode object.



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'lib/rtf/node.rb', line 263

def to_rtf
   text = StringIO.new

   text << '{'       if wrap?
   text << @prefix   if @prefix

   self.each do |entry|
      text << "\n" if split?
      text << entry.to_rtf
   end

   text << "\n"    if split?
   text << @suffix if @suffix
   text << '}'     if wrap?

   text.string
end

#underline ⇒ Object

This method provides a short cut means of creating an underline command node. The method accepts a block that will be passed a single parameter which will be a reference to the underline node created. After the block is complete the underline node is appended to the end of the child nodes on the object that the method is call against.



430
431
432
433
434
435
436
437
438
 
# File 'lib/rtf/node.rb', line 430

def underline
   style           = CharacterStyle.new
   style.underline = true
   if block_given?
      apply(style) {|node| yield node}
   else
      apply(style)
   end
end