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.



231
232
233
234
235
236
237
 
# File 'lib/rtf/node.rb', line 231

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



208
209
210
 
# File 'lib/rtf/node.rb', line 208

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



214
215
216
 
# File 'lib/rtf/node.rb', line 214

def split
  @split
end

#suffix ⇒ Object

String containing the suffix text for the command



210
211
212
 
# File 'lib/rtf/node.rb', line 210

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.



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

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.



245
246
247
248
249
250
251
 
# File 'lib/rtf/node.rb', line 245

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) 


368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
 
# File 'lib/rtf/node.rb', line 368

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.



528
529
530
531
532
533
534
535
536
537
 
# File 'lib/rtf/node.rb', line 528

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.



391
392
393
394
395
396
397
398
399
 
# File 'lib/rtf/node.rb', line 391

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.



549
550
551
552
553
554
555
556
557
558
559
560
 
# File 'lib/rtf/node.rb', line 549

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.



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

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.



332
333
334
335
336
337
338
339
340
 
# File 'lib/rtf/node.rb', line 332

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.



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

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.



351
352
353
 
# File 'lib/rtf/node.rb', line 351

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.



406
407
408
409
410
411
412
413
414
 
# File 'lib/rtf/node.rb', line 406

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.



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

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

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

Yields:

  • (node) 


313
314
315
316
317
318
 
# File 'lib/rtf/node.rb', line 313

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:



307
308
309
310
311
 
# File 'lib/rtf/node.rb', line 307

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) 


282
283
284
285
286
 
# File 'lib/rtf/node.rb', line 282

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.



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

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.



436
437
438
439
440
441
442
443
444
 
# File 'lib/rtf/node.rb', line 436

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.



451
452
453
454
455
456
457
458
459
 
# File 'lib/rtf/node.rb', line 451

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) 


571
572
573
574
575
576
 
# File 'lib/rtf/node.rb', line 571

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.



254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'lib/rtf/node.rb', line 254

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.



421
422
423
424
425
426
427
428
429
 
# File 'lib/rtf/node.rb', line 421

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