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.

Direct Known Subclasses

Document, FooterNode, HeaderNode, TableCellNode

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) ⇒ 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.



227
228
229
230
231
232
 
# File 'lib/rtf/node.rb', line 227

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

Instance Attribute Details

#prefix ⇒ Object

Attribute accessor.



212
213
214
 
# File 'lib/rtf/node.rb', line 212

def prefix
  @prefix
end

#split ⇒ Object Also known as: split?

Attribute accessor.



212
213
214
 
# File 'lib/rtf/node.rb', line 212

def split
  @split
end

#suffix ⇒ Object

Attribute accessor.



212
213
214
 
# File 'lib/rtf/node.rb', line 212

def suffix
  @suffix
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.



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

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) 


335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
 
# File 'lib/rtf/node.rb', line 335

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.



465
466
467
468
469
470
471
472
473
474
 
# File 'lib/rtf/node.rb', line 465

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.



358
359
360
361
362
363
364
365
366
 
# File 'lib/rtf/node.rb', line 358

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.



486
487
488
489
490
491
492
493
494
495
496
497
 
# File 'lib/rtf/node.rb', line 486

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.



424
425
426
427
428
429
430
431
432
433
434
 
# File 'lib/rtf/node.rb', line 424

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.



299
300
301
302
303
304
305
306
307
 
# File 'lib/rtf/node.rb', line 299

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.



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

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.



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

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.



373
374
375
376
377
378
379
380
381
 
# File 'lib/rtf/node.rb', line 373

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.



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

def line_break
   self.store(CommandNode.new(self, '\line', nil, false))
   nil
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) 


276
277
278
279
280
281
282
283
284
285
 
# File 'lib/rtf/node.rb', line 276

def paragraph(style=nil)
   # Create the node prefix.
   text = StringIO.new
   text << '\pard'
   text << style.prefix(nil, nil) if style != nil

   node = CommandNode.new(self, text.string, '\par')
   yield node if block_given?
   self.store(node)
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.



403
404
405
406
407
408
409
410
411
 
# File 'lib/rtf/node.rb', line 403

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) 


508
509
510
511
512
513
 
# File 'lib/rtf/node.rb', line 508

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.



249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
 
# File 'lib/rtf/node.rb', line 249

def to_rtf
   text      = StringIO.new
   separator = split? ? "\n" : " "
   line      = (separator == " ")

   text << "{#{@prefix}"
   text << separator if self.size > 0
   self.each do |entry|
      text << "\n" if line
      line = true
      text << "#{entry.to_rtf}"
   end
   text << "\n" if split?
   text << "#{@suffix}}"
   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.



388
389
390
391
392
393
394
395
396
 
# File 'lib/rtf/node.rb', line 388

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