taskjuggler 0.0.2

data/lib/reports/ReportTableLegend.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ReportTableLegend.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+class TaskJuggler
+
+  # The ReportTableLegend models an output format independent legend for the
+  # ReportTable. It lists the graphical symbols used in the table together with
+  # a short textual description.
+  class ReportTableLegend
+
+    attr_accessor :showGanttItems
+
+    # Create a new ReportTableLegend object.
+    def initialize
+      @showGanttItems = false
+      @ganttItems = []
+      @calendarItems = []
+    end
+
+    # Add another Gantt item to the legend. Make sure we don't have any
+    # duplicates.
+    def addGanttItem(text, color)
+      @ganttItems << [ text, color ] unless @ganttItems.include?([ text, color ])
+    end
+
+    # Add another chart item to the legend. Make sure we don't have any
+    # duplicates.
+    def addCalendarItem(text, color)
+      unless @calendarItems.include?([ text, color ])
+        @calendarItems << [ text, color ]
+      end
+    end
+
+    # Convert the abstract description into HTML elements.
+    def to_html
+      return nil if !@showGanttItems && @ganttItems.empty? &&
+                    @calendarItems.empty?
+
+      table = XMLElement.new('table', 'class' => 'legendback',
+                             'style' => 'width:100%', 'border' => '0',
+                             'cellspacing' => '1', 'align' => 'center')
+      table << (tbody = XMLElement.new('tbody'))
+      tbody << (tr = XMLElement.new('tr'))
+
+      # Empty line to create a bit of a vertical gap.
+      tr << XMLElement.new('td', 'colspan' => '8', 'style' => 'height:5px')
+
+      tbody << headlineToHTML('Gantt Chart Symbols:')
+      # Generate the Gantt chart symbols
+      if @showGanttItems
+        tbody << (tr = XMLElement.new('tr'))
+
+        tr << ganttItemToHTML(GanttContainer.new(nil, 0, 15, 10, 35, 0),
+                              'Container Task', 40)
+        tr << spacerToHTML(8)
+        tr << ganttItemToHTML(GanttTaskBar.new(nil, 0, 15, 5, 35, 0),
+                              'Normal Task', 40)
+        tr << spacerToHTML
+        tr << ganttItemToHTML(GanttMilestone.new(nil, 15, 10, 0),
+                              'Milestone', 20)
+      end
+
+      tbody << itemsToHTML(@ganttItems)
+
+      tbody << headlineToHTML('Calendar Symbols:')
+      tbody << itemsToHTML(@calendarItems)
+
+      # Empty line to create a bit of a vertical gap.
+      tbody << (tr = XMLElement.new('tr'))
+      tr << XMLElement.new('td', 'colspan' => '8', 'style' => 'height:5px')
+
+      table
+    end
+
+  private
+
+    # In case we have both the calendar and the Gantt chart in the report
+    # element, we have to add description lines before the symbols. The two
+    # charts use the same colors for different meanings. This function generates
+    # the HTML version of the headlines.
+    def headlineToHTML(text)
+      tbody = []
+      unless @calendarItems.empty? || @ganttItems.empty?
+        tbody << (tr = XMLElement.new('tr'))
+        tr << (td = XMLElement.new('td', 'colspan' => '8',
+                                   'style' => 'font-weight:bold; ' +
+                                              'padding-left:10px'))
+        td << XMLText.new(text)
+      else
+        nil
+      end
+      tbody
+    end
+
+    # Turn the Gantt symbold descriptions into HTML elements.
+    def ganttItemToHTML(item, name, width)
+      tr = []
+      tr << (td = XMLElement.new('td', 'style' => 'width:19%; ' +
+                                 'padding-left:10px; '))
+      td << XMLText.new(name)
+      tr << (td = XMLElement.new('td', 'style' => 'width:8%'))
+      td << (div = XMLElement.new('div',
+          'style' => "position:relative; width:#{width}px; height:15px;"))
+      div << item.to_html
+      tr
+    end
+
+    # Turn the color items into HTML elements.
+    def itemsToHTML(items)
+      tbody = []
+
+      gridCells = ((items.length / 3) + (items.length % 3 != 0 ? 1 : 0)) * 3
+      tr = nil
+      gridCells.times do |i|
+        # We show no more than 3 items in a row.
+        tbody << (tr = XMLElement.new('tr')) if i % 3 == 0
+
+        # If we run out of items before the line is filled, we just insert
+        # spacers to fill the line.
+        if i < items.length
+          tr << itemToHTML(items[i])
+        else
+          tr << spacerToHTML(19)
+          tr << spacerToHTML(8)
+        end
+        tr << spacerToHTML() if i % 3 != 2
+      end
+
+      tbody
+    end
+
+    # Turn a single color item into HTML elements.
+    def itemToHTML(item)
+      tr = []
+      tr << (td = XMLElement.new('td', 'style' => 'width:19%; ' +
+                                 'padding-left:10px; '))
+      td << XMLText.new(item[0])
+      tr << (td = XMLElement.new('td', 'style' => 'width:8%'))
+      td << (div = XMLElement.new('div', 'style' => 'position:relative; ' +
+                                                    'width:20px; height:15px')
+      div << XMLElement.new('div', 'class' => 'loadstackframe',
+                            'style' => 'position:absolute; ' +
+                            'left:5px; width:16px; height:15px;')
+      div << XMLElement.new('div', 'class' => "#{item[1]}",
+          'style' => 'position:absolute; left:1px; top:1px; ' +
+                     'width:14px; height:13px;'))
+      tr
+    end
+
+    # Generate an empty HTML cell. _width_ is the requested width in pixels.
+    def spacerToHTML(width = 9)
+      XMLElement.new('td', 'style' => "width:#{width}%")
+    end
+
+  end
+
+end
+

data/lib/reports/ReportTableLine.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ReportTableLine.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'reports/ReportTableCell'
+
+class TaskJuggler
+
+  class ReportTableLine
+
+    attr_reader :table, :property, :scopeLine
+    attr_accessor :height, :indentation, :fontSize, :no, :lineNo, :subLineNo
+
+    # Create a ReportTableCell object and initialize the variables with default
+    # values. _table_ is a reference to the ReportTable object this line belongs
+    # to. _property_ is a reference to the Task or Resource that is displayed in
+    # this line. _scopeLine_ is the line that sets the scope for this line. The
+    # value is nil if this is a primary line.
+    def initialize(table, property, scopeLine)
+      @table = table
+      @property = property
+      @scopeLine = scopeLine
+
+      # Register the new line with the table it belongs to.
+      @table.addLine(self)
+      # The cells of this line. Should be references to ReportTableCell objects.
+      @cells = []
+      # Heigh of the line in screen pixels
+      @height = 21
+      # Indentation for hierachiecal columns in screen pixels.
+      @indentation = 0
+      # The factor used to enlarge or shrink the font size for this line.
+      @fontSize = 12
+      # Counter that counts primary and nested lines separately. It restarts
+      # with 0 for each new nested line set. Scenario lines don't count.
+      @no = nil
+      # Counter that counts the primary lines. Scenario lines don't count.
+      @lineNo = nil
+      # Counter that counts all lines.
+      @subLineNo = nil
+    end
+
+    # Return the last non-hidden cell of the line. Start to look for the cell at
+    # the first cell after _count_ cells.
+    def last(count = 0)
+      (1 + count).upto(@cells.length) do |i|
+        return @cells[-i] unless @cells[-i].hidden
+      end
+      nil
+    end
+
+    # Add the new cell to the line. _cell_ must reference a ReportTableCell
+    # object.
+    def addCell(cell)
+      @cells << cell
+    end
+
+    # Return this line as a set of XMLElement that represent the line in HTML.
+    def to_html
+      style = ""
+      style += "height:#{@height}px; " if @table.equiLines
+      style += "font-size:#{@fontSize}px; " if @fontSize
+      tr = XMLElement.new('tr', 'class' => 'tabline', 'style' => style)
+      @cells.each { |cell| tr << cell.to_html }
+      tr
+    end
+
+    # Convert the intermediate format into an Array of values. One entry for
+    # every column cell of this line.
+    def to_csv(csv)
+      @cells.each do |cell|
+        cell.to_csv(csv)
+      end
+    end
+
+  end
+
+end
+

data/lib/reports/ResourceListRE.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ResourceListRE.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'reports/ReportTableElement'
+require 'reports/ReportTable'
+require 'TableColumnDefinition'
+require 'LogicalExpression'
+
+class TaskJuggler
+
+  # This specialization of ReportTableElement implements a resource listing. It
+  # generates a list of resources that can optionally have the assigned tasks
+  # nested underneath each resource line.
+  class ResourceListRE < ReportTableElement
+
+    # Create a new object and set some default values.
+    def initialize(report)
+      super
+      # Set the default columns for this report.
+      %w( no name ).each do |col|
+        @columns << TableColumnDefinition.new(col, defaultColumnTitle(col))
+      end
+      # Show all resources, sorted by tree and id-up.
+      @hideResource = LogicalExpression.new(LogicalOperation.new(0))
+      @sortResources = [ [ 'tree', true, -1 ],
+                         [ 'id', true, -1 ] ]
+      # Hide all resources, but set sorting to tree, start-up, seqno-up.
+      @hideTask = LogicalExpression.new(LogicalOperation.new(1))
+      @sortTasks = [ [ 'tree', true, -1 ],
+                     [ 'start', true, 0 ],
+                     [ 'seqno', true, -1 ] ]
+
+      @table = ReportTable.new
+    end
+
+    # Generate the table in the intermediate format.
+    def generateIntermediateFormat
+      # Generate the table header.
+      @columns.each do |columnDescr|
+        generateHeaderCell(columnDescr)
+      end
+
+      # Prepare the resource list.
+      resourceList = PropertyList.new(@project.resources)
+      resourceList.setSorting(@sortResources)
+      resourceList = filterResourceList(resourceList, nil, @hideResource,
+                                        @rollupResource)
+      resourceList.sort!
+
+      # Prepare the task list.
+      taskList = PropertyList.new(@project.tasks)
+      taskList.setSorting(@sortTasks)
+      taskList = filterTaskList(taskList, nil, @hideTask, @rollupTask)
+      taskList.sort!
+
+      # Generate the list.
+      generateResourceList(resourceList, taskList, nil)
+    end
+
+  end
+
+end
+

data/lib/reports/TaskListRE.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = TaskListRE.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'reports/ReportTableElement'
+require 'reports/ReportTable'
+require 'TableColumnDefinition'
+require 'LogicalExpression'
+
+class TaskJuggler
+
+  # This specialization of ReportTableElement implements a task listing. It
+  # generates a list of tasks that can optionally have the allocated resources
+  # nested underneath each task line.
+  class TaskListRE < ReportTableElement
+
+    # Create a new object and set some default values.
+    def initialize(report)
+      super
+      # Set the default columns for this report.
+      %w( wbs name start end effort chart ).each do |col|
+        @columns << TableColumnDefinition.new(col, defaultColumnTitle(col))
+      end
+      # Show all tasks, sorted by tree, start-up, seqno-up.
+      @hideTask = LogicalExpression.new(LogicalOperation.new(0))
+      @sortTasks = [ [ 'tree', true, -1 ],
+                     [ 'start', true, 0 ],
+                     [ 'seqno', true, -1 ] ]
+      # Show no resources, but set sorting to id-up.
+      @hideResource = LogicalExpression.new(LogicalOperation.new(1))
+      @sortResources = [ [ 'id', true, -1 ] ]
+
+      @table = ReportTable.new
+    end
+
+    # Generate the table in the intermediate format.
+    def generateIntermediateFormat
+      # Prepare the task list.
+      taskList = PropertyList.new(@project.tasks)
+      taskList.setSorting(@sortTasks)
+      taskList = filterTaskList(taskList, nil, @hideTask, @rollupTask)
+      taskList.sort!
+
+      adjustReportPeriod(taskList, @scenarios) unless @userDefinedPeriod
+
+      # Prepare the resource list.
+      resourceList = PropertyList.new(@project.resources)
+      resourceList.setSorting(@sortResources)
+      resourceList = filterResourceList(resourceList, nil, @hideResource,
+          @rollupResource)
+      resourceList.sort!
+
+      # Generate the table header.
+      @columns.each do |columnDescr|
+        generateHeaderCell(columnDescr)
+      end
+
+      # Generate the list.
+      generateTaskList(taskList, resourceList, nil)
+    end
+
+  end
+
+end
+

data/lib/reports/TjpExportRE.rb

@@ -0,0 +1,394 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = TjpExportRE.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'reports/ReportElement'
+
+class TaskJuggler
+
+  # This specialization of ReportTableElement implements an export of the
+  # project data in the TJP syntax format.
+  class TjpExportRE < ReportElement
+
+    attr_writer :resourceAttrs, :taskAttrs
+    attr_reader :mainFile
+
+    # Create a new object and set some default values.
+    def initialize(report, mainFile)
+      super(report)
+
+      # Indicates whether this is a full .tjp file or just an .tji include file.
+      @mainFile = mainFile
+
+      @supportedTaskAttrs = %w( booking complete depends flags maxend
+                                maxstart minend minstart note priority
+                                responsible )
+      @supportedResourceAttrs = %w( vacation workinghours )
+      @taskAttrs = %w( all )
+      @resourceAttrs = %w( all )
+      @scenarios = [ 0 ]
+
+      # Show all tasks, sorted by seqno-up.
+      @hideTask =
+        LogicalExpression.new(LogicalOperation.new(0))
+      @sortTasks = [ [ 'seqno', true, -1 ] ]
+      # Show all resources, sorted by seqno-up.
+      @hideResource =
+        LogicalExpression.new(LogicalOperation.new(0))
+      @sortResources = [ [ 'seqno', true, -1 ] ]
+    end
+
+    # There is nothing to do here.
+    def generateIntermediateFormat
+    end
+
+    # Return the project data in TJP syntax format.
+    def to_tjp
+      # Prepare the resource list.
+      @resourceList = PropertyList.new(@project.resources)
+      @resourceList.setSorting(@sortResources)
+      @resourceList = filterResourceList(@resourceList, nil, @hideResource,
+          @rollupResource)
+      @resourceList.sort!
+
+      # Prepare the task list.
+      @taskList = PropertyList.new(@project.tasks)
+      @taskList.setSorting(@sortTasks)
+      @taskList = filterTaskList(@taskList, nil, @hideTask, @rollupTask)
+      @taskList.sort!
+
+      getBookings
+
+      @file = ''
+
+      if @mainFile
+        generateProjectProperty
+        generateFlagDeclaration
+        generateResourceList
+        generateTaskList
+      end
+      generateTaskAttributes unless @taskAttrs.empty?
+      generateResourceAttributes unless @resourceAttrs.empty?
+
+      @file
+    end
+
+  private
+
+    def generateProjectProperty
+      @file << "project #{@project['projectid']} \"#{@project['name']}\" " +
+               "\"#{@project['version']}\" #{@project['start']} - " +
+               "#{@project['end']} {\n"
+      generateCustomAttributeDeclarations('resource', @project.resources,
+                                          @resourceAttrs)
+      generateCustomAttributeDeclarations('task', @project.tasks, @taskAttrs)
+      @file << "}\n\n"
+    end
+
+    def generateCustomAttributeDeclarations(tag, propertySet, attributes)
+      # First we search the attribute definitions for any user defined
+      # attributes and count them.
+      customAttributes = 0
+      propertySet.eachAttributeDefinition do |ad|
+        customAttributes += 1 if ad.userDefined
+      end
+      # Return if there are no user defined attributes.
+      return if customAttributes == 0
+
+      # Generate definitions for each user defined attribute that is in the
+      # taskAttributes list.
+      @file << '  extend ' + tag + "{\n"
+        propertySet.eachAttributeDefinition do |ad|
+          next unless ad.userDefined &&
+                      (attributes.include?(ad.id) || attributes.include?('all'))
+
+          @file << "    #{ad.objClass.tjpId} #{ad.id} \"#{ad.name}\"\n"
+        end
+      @file << "  }\n"
+    end
+
+    def generateFlagDeclaration
+      flags = []
+
+      properties = @resourceList + @taskList
+
+      properties.each do |property|
+        @scenarios.each do |scenarioIdx|
+          property['flags', scenarioIdx].each do |flag|
+            flags << flag unless flags.include?(flag)
+          end
+        end
+      end
+      flags.sort
+      unless flags.empty?
+        @file << "flags #{flags.join(', ')}\n\n"
+      end
+    end
+
+    def generateResourceList
+      # The resource definitions are generated recursively. So we only need to
+      # start it for the top-level resources.
+      @resourceList.each do |resource|
+        if resource.parent.nil?
+          generateResource(resource, 0)
+        end
+      end
+      @file << "\n"
+    end
+
+    def generateResource(resource, indent)
+      Log.activity if resource.sequenceNo % 100 == 0
+
+      @file << ' ' * indent + "resource #{resource.id} \"#{resource.name}\""
+      @file << ' {' unless resource.children.empty?
+      @file << "\n"
+
+      # Call this function recursively for all children that are included in the
+      # resource list as well.
+      resource.children.each do |subresource|
+        if @resourceList.include?(subresource)
+          generateResource(subresource, indent + 2)
+        end
+      end
+
+      @file << ' ' * indent + "}\n" unless resource.children.empty?
+    end
+
+    def generateTaskList
+      # The task definitions are generated recursively. So we only need to start
+      # it for the top-level tasks.
+      @taskList.each do |task|
+        if task.parent.nil?
+          generateTask(task, 0)
+        end
+      end
+    end
+
+    # Generate a task definition. It only contains a very small set of
+    # attributes that have to be passed on the the nested tasks at creation
+    # time. All other attributes are declared in subsequent supplement
+    # statements.
+    def generateTask(task, indent)
+      Log.activity if task.sequenceNo % 100 == 0
+
+      @file << ' ' * indent + "task #{task.id} \"#{task.name}\" {\n"
+
+      if @taskAttrs.include?('depends') || @taskAttrs.include?('all')
+        @scenarios.each do |scenarioIdx|
+          generateTaskDependency(scenarioIdx, task, 'depends', indent + 2)
+          generateTaskDependency(scenarioIdx, task, 'precedes', indent + 2)
+        end
+      end
+
+      # Call this function recursively for all children that are included in the
+      # task list as well.
+      task.children.each do |subtask|
+        if @taskList.include?(subtask)
+          generateTask(subtask, indent + 2)
+        end
+      end
+
+      # Determine whether this task has subtasks that are included in the
+      # report or whether this is a leaf task for the report.
+      isLeafTask = true
+      task.children.each do |subtask|
+        if @taskList.include?(subtask)
+          isLeafTask = false
+          break
+        end
+      end
+
+      # For leaf tasks we put some attributes right here.
+      if isLeafTask
+        @scenarios.each do |scenarioIdx|
+          generateAttribute(task, 'start', indent + 2, scenarioIdx)
+          unless task['milestone', scenarioIdx]
+            generateAttribute(task, 'end', indent + 2, scenarioIdx)
+          end
+          if task['scheduled', scenarioIdx]
+            generateAttributeText('scheduled', indent + 2, scenarioIdx)
+          end
+          generateAttributeText('scheduling ' +
+                                (task['forward', scenarioIdx] ?
+                                 'asap' : 'alap'),
+                                indent + 2, scenarioIdx)
+          if task['milestone', scenarioIdx]
+            generateAttributeText('milestone', indent + 2, scenarioIdx)
+          end
+        end
+      end
+
+      @file << ' ' * indent + "}\n"
+    end
+
+    # Generate 'depends' or 'precedes' attributes for a task.
+    def generateTaskDependency(scenarioIdx, task, tag, indent)
+      return unless @taskAttrs.include?('depends') || !@taskAttrs.include?('all')
+
+      taskDeps = task[tag, scenarioIdx]
+      unless taskDeps.empty?
+        @file << ' ' * indent + tag + ' '
+        first = true
+        taskDeps.each do |dep|
+          if first
+            first = false
+          else
+            @file << ', '
+          end
+          @file << dep.task.fullId
+        end
+        @file << "\n"
+      end
+    end
+
+    # Generate a list of resource supplement statements that include the rest of
+    # the attributes.
+    def generateResourceAttributes
+      @resourceList.each do |resource|
+        Log.activity if resource.sequenceNo % 100 == 0
+
+        @file << "supplement resource #{resource.fullId} {\n"
+        @project.resources.eachAttributeDefinition do |attrDef|
+          id = attrDef.id
+          attr = resource.getAttr(id)
+          next if (!@supportedResourceAttrs.include?(id) &&
+                   ! attrDef.userDefined) ||
+                  (!@resourceAttrs.include?('all') &&
+                   !@resourceAttrs.include?(id))
+
+          if attrDef.scenarioSpecific
+            @scenarios.each do |scenarioIdx|
+              generateAttribute(resource, id, 2, scenarioIdx)
+            end
+          else
+            generateAttribute(resource, id, 2)
+          end
+        end
+
+        @file << "}\n"
+      end
+    end
+
+    # Generate a list of task supplement statements that include the rest of the
+    # attributes.
+    def generateTaskAttributes
+      @taskList.each do |task|
+        Log.activity if task.sequenceNo % 100 == 0
+
+        @file << "supplement task #{task.fullId} {\n"
+        @project.tasks.eachAttributeDefinition do |attrDef|
+          id = attrDef.id
+          attr = task.getAttr(id)
+          next if (!@supportedTaskAttrs.include?(id) &&
+                   ! attrDef.userDefined) ||
+                  (!@taskAttrs.include?('all') && !@taskAttrs.include?(id))
+
+          if attrDef.scenarioSpecific
+            @scenarios.each do |scenarioIdx|
+              # Some attributes need special treatment.
+              case id
+              when 'depends'
+                next     # already taken care of
+              when 'booking'
+                generateBooking(task, 2, scenarioIdx)
+              else
+                generateAttribute(task, id, 2, scenarioIdx)
+              end
+            end
+          else
+            generateAttribute(task, id, 2)
+          end
+        end
+
+        @file << "}\n"
+      end
+    end
+
+    def generateAttribute(property, attrId, indent, scenarioIdx = nil)
+      if scenarioIdx.nil?
+        return if property.getAttr(attrId).nil?
+      else
+        return if property[attrId, scenarioIdx].nil?
+      end
+
+      generateAttributeText(property.getAttr(attrId, scenarioIdx).to_tjp,
+                            indent, scenarioIdx)
+    end
+
+    def generateAttributeText(text, indent, scenarioIdx)
+      @file << ' ' * indent
+      tag = ''
+      unless scenarioIdx.nil?
+        tag = @project.scenario(scenarioIdx).id
+        @file << "#{tag}:"
+      end
+      @file << "#{indentBlock(text, indent + tag.length + 2)}\n"
+    end
+
+    # Get the booking data for all resources that should be included in the
+    # report.
+    def getBookings
+      @bookings = {}
+      if @taskAttrs.include?('booking') ||
+         @taskAttrs.include?('all')
+        @scenarios.each do |scenarioIdx|
+          @bookings[scenarioIdx] = {}
+          @resourceList.each do |resource|
+            # Get the bookings for this resource hashed by task.
+            bookings = resource.getBookings(scenarioIdx)
+            next if bookings.nil?
+
+            # Now convert/add them to a tripple-stage hash by scenarioIdx, task
+            # and then resource.
+            bookings.each do |task, booking|
+              if !@bookings[scenarioIdx].include?(task)
+                @bookings[scenarioIdx][task] = {}
+              end
+              @bookings[scenarioIdx][task][resource] = booking
+            end
+          end
+        end
+      end
+    end
+
+    def generateBooking(task, indent, scenarioIdx)
+      return unless @bookings[scenarioIdx].include?(task)
+
+      @bookings[scenarioIdx][task].each_value do |booking|
+        generateAttributeText('booking ' + booking.to_tjp, indent, scenarioIdx)
+      end
+    end
+
+    # This utility function is used to indent multi-line attributes. All
+    # attributes should be filtered through this function. Attributes that
+    # contain line breaks will be indented properly. In addition to the
+    # indentation specified by _indent_ all but the first line will be indented
+    # after the first word of the first line. The text may not end with a line
+    # break.
+    def indentBlock(text, indent)
+      out = ''
+      firstSpace = 0
+      text.length.times do |i|
+        if firstSpace == 0 && text[i] == ?\ # There must be a space after ?
+          firstSpace = i
+        end
+        out << text[i]
+        if text[i] == ?\n
+          out += ' ' * (indent + firstSpace)
+        end
+      end
+      out
+    end
+
+  end
+
+end
+