taskjuggler 0.0.2

data/lib/reports/ReportTableCell.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ReportTableCell.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
+
+  # This class models the output format independent version of a cell in a
+  # ReportTableElement. It belongs to a certain ReportTableLine and
+  # ReportTableColumn. Normally a cell contains text on a colored background.
+  # By help of the @special variable it can alternatively contain any object the
+  # provides the necessary output methods such as to_html.
+  class ReportTableCell
+
+    attr_reader :line
+    attr_accessor :data, :text, :url, :category, :hidden, :alignment,
+                  :padding, :indent, :fontSize, :fontColor, :bold, :width,
+                  :rows, :columns, :special
+
+    # Create the ReportTableCell object and initialize the attributes to some
+    # default values. _line_ is the ReportTableLine this cell belongs to. _text_
+    # is the text that should appear in the cell. _headerCell_ is a flag that
+    # must be true only for table header cells.
+    def initialize(line, text = '', headerCell = false)
+      @line = line
+      @line.addCell(self) if line
+
+      @headerCell = headerCell
+      # The printable form of the cell content
+      @text = text
+      # A URL that is associated with the content of the cell.
+      @url = nil
+      # The original data of the cell content (optional, nil if not provided)
+      @data = nil
+      @category = nil
+      @hidden = false
+      # How to horizontally align the cell
+      @alignment = :center
+      # Horizontal padding between frame and cell content
+      @padding = 3
+      # Whether or not to indent the cell. If not nil, it is a Fixnum
+      # indicating the indentation level.
+      @indent = nil
+      @fontSize = nil
+      @fontColor = 0x000000
+      @bold = false
+      @width = nil
+      @rows = 1
+      @columns = 1
+      # Ignore everything and use this reference to generate the output.
+      @special = nil
+    end
+
+    # Return true if two cells are similar enough so that they can be merged in
+    # the report to a single, wider cell. _c_ is the cell to compare this cell
+    # with.
+    def ==(c)
+      @text == c.text &&
+      @alignment == c.alignment &&
+      @padding == c.padding &&
+      @indent == c.indent &&
+      @category == c.category
+    end
+
+    # Turn the abstract cell representation into an HTML element tree.
+    def to_html
+      return nil if @hidden
+      return @special.to_html if @special
+
+      # Determine cell attributes
+      attribs = { }
+      attribs['rowspan'] = "#{@rows}" if @rows > 1
+      attribs['colspan'] = "#{@columns}" if @columns > 1
+      attribs['class'] = @category ? @category : 'tabcell'
+      cell = XMLElement.new('td', attribs)
+
+      # Determine cell style
+      alignSymbols = [ :left, :center, :right ]
+      aligns = %w( left center right)
+      style = "text-align:#{aligns[alignSymbols.index(@alignment)]}; "
+      if @indent && @alignment != :center
+        if @alignment == :left
+          style += "padding-left:#{@padding + @indent * 8}px; "
+          style += "padding-right:#{@padding}px; " unless @padding == 3
+        elsif @alignment == :right
+          style += "padding-left:#{@padding}px; " unless @padding == 3
+          style += "padding-right:#{@padding +
+                                    (@line.table.maxIndent - @indent) * 8}px; "
+        end
+      elsif @padding != 3
+        style += "padding-left:#{@padding}px; padding-right:#{@padding}px; "
+      end
+      unless @text.is_a?(TaskJuggler::RichText)
+        style += 'font-weight:bold; ' if @bold
+        style += "font-size: #{@fontSize}px; " if fontSize
+      end
+      unless @fontColor == 0
+        style += "color:#{'#%06X' % @fontColor}; "
+      end
+      style += "width: #{@width}px; " if @width
+      if @text.is_a?(TaskJuggler::RichText) && @line && @line.table.equiLines
+        style += "height:#{@line.height - 3}px; "
+      end
+      cell << (div = XMLElement.new('div',
+        'class' => @category ? 'celldiv' : 'headercelldiv', 'style' => style))
+
+      if url
+        div << (a = XMLElement.new('a', 'href' => @url))
+        a << XMLText.new(@text.is_a?(TaskJuggler::RichText) ?  @text.to_s : text)
+      else
+        div << (@text.is_a?(TaskJuggler::RichText) ?
+                @text.to_html : XMLText.new(@text))
+      end
+
+      cell
+    end
+
+    # Add the text content of the cell to an Array of Arrays form of the table.
+    def to_csv(csv)
+      # We only support left indentation in CSV files as the spaces for right
+      # indentation will be disregarded by most applications.
+      indent = @indent && @alignment == :left ? '  ' * @indent : ''
+      if @special
+        csv[-1] << @special.to_csv
+      elsif @data && @data.is_a?(String)
+        csv[-1] << indent + @data
+      elsif @text
+        csv[-1] << indent + @text
+      end
+    end
+
+  end
+
+end
+

data/lib/reports/ReportTableColumn.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ReportTableColumn.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 ReportTableColumn class models the output format independend column of a
+  # ReportTable. It usually just contains the table header description. The
+  # table header comprises of one or two lines per column. So each column header
+  # consists of 2 cells. @cell1 is the top cell and must be present. @cell2 is
+  # the optional bottom cell. If @cell2 is hidden, @cell1 takes all the vertical
+  # space.
+  #
+  # For some columns, the table does not contain the usual grid lines but
+  # another abstract object that responds to the usual generator methods such as
+  # to_html(). In such a case, @cell1 references the embedded object via its
+  # special variable. The embedded object then replaced the complete column
+  # content.
+  class ReportTableColumn
+
+    attr_reader :definition, :cell1, :cell2
+    attr_accessor :scrollbar
+
+    # Create a new column. _table_ is a reference to the ReportTable this column
+    # belongs to. _definition_ is the TableColumnDefinition of the column from
+    # the project definition. _title_ is the text that is used for the column
+    # header.
+    def initialize(table, definition, title)
+      @table = table
+      # Register this new column with the ReportTable.
+      @table.addColumn(self)
+      @definition = definition
+      # Register this new column with the TableColumnDefinition.
+      definition.column = self if definition
+
+      # Create the 2 cells of the header.
+      @cell1 = ReportTableCell.new(nil, title, true)
+      @cell1.padding = 5
+      @cell2 = ReportTableCell.new(nil, '', true)
+      # Header text is always bold.
+      @cell1.bold = @cell2.bold = true
+      # This variable is set to true if the column requires a scrollbar later
+      # on.
+      @scrollbar = false
+    end
+
+    # Return the mininum required width for the column.
+    def minWidth
+      width = @cell1.width
+      width = @cell2.width if width.nil? || @cell2.width > width
+      width
+    end
+
+    # Convert the abstract representation into HTML elements.
+    def to_html(row)
+      if row == 1
+        @cell1.to_html
+      else
+        @cell2.to_html
+      end
+    end
+
+    # Put the abstract representation into an Array. _csv_ is an Array of Arrays
+    # of Strings. We have an Array with Strings for every cell. The outer Array
+    # holds the Arrays representing the lines.
+    def to_csv(csv)
+      # For CSV reports we can only include the first header line.
+      @cell1.to_csv(csv)
+    end
+
+  end
+
+end
+

data/lib/reports/ReportTableElement.rb

@@ -0,0 +1,852 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ReportTableElement.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/GanttChart'
+require 'reports/ReportTableLegend'
+require 'reports/ColumnTable'
+require 'Query'
+
+class TaskJuggler
+
+  # This is base class for all types of tabular report elements. All tabular
+  # report elements are converted to an abstract (output independent)
+  # intermediate form first, before the are turned into the requested output
+  # format.
+  class ReportTableElement < ReportElement
+
+    attr_reader :legend
+
+    # Generate a new ReportTableElement object.
+    def initialize(report)
+      super
+
+      # Reference to the intermediate representation.
+      @table = nil
+
+      @legend = ReportTableLegend.new
+    end
+
+    # This is an abstract member that all sub classes must re-implement. It may
+    # or may not do something though.
+    def generateIntermediateFormat
+      raise 'This function must be overriden by derived classes.'
+    end
+
+    # Turn the ReportTableElement into an equivalent HTML element tree.
+    def to_html
+      html = []
+
+      # Make sure we have some margins around the report.
+      html << (frame = XMLElement.new('div',
+                                      'style' => 'margin: 35px 5% 25px 5%; '))
+
+      if @prolog
+        @prolog.sectionNumbers = false
+        frame << @prolog.to_html
+      end
+
+      frame << (table = XMLElement.new('table', 'summary' => 'Report Table',
+                                     'cellspacing' => '2', 'border' => '0',
+                                     'cellpadding' => '0', 'align' => 'center',
+                                     'class' => 'tabback'))
+
+      # The headline is put in a sub-table to appear bigger.
+      if @headline
+        table << (thead = XMLElement.new('thead'))
+        thead << (tr = XMLElement.new('tr'))
+        tr << (td = XMLElement.new('td'))
+        td << (table1 = XMLElement.new('table', 'summary' => 'headline',
+                                       'cellspacing' => '1', 'border' => '0',
+                                       'cellpadding' => '5',
+                                       'align' => 'center', 'width' => '100%'))
+        table1 << (tr1 = XMLElement.new('tr'))
+        tr1 << (td1 = XMLElement.new('td', 'align' => 'center',
+                                     'style' => 'font-size:16px; ' +
+                                                'font-weight:bold',
+                                     'class' => 'tabfront'))
+        td1 << XMLNamedText.new(@headline, 'p')
+      end
+
+      # Now generate the actual table with the data.
+      table << (tbody = XMLElement.new('tbody'))
+      tbody << (tr = XMLElement.new('tr'))
+      tr << (td = XMLElement.new('td'))
+      td << @table.to_html
+
+      # Embedd the caption as RichText into the table footer.
+      if @caption
+        tbody << (tr = XMLElement.new('tr'))
+        tr << (td = XMLElement.new('td', 'class' => 'tabback'))
+        td << (div = XMLElement.new('div', 'class' => 'caption',
+                                    'style' => 'margin:1px'))
+        @caption.sectionNumbers = false
+        div << @caption.to_html
+      end
+
+      # A sub-table with the legend.
+      tbody << (tr = XMLElement.new('tr', 'style' => 'font-size:10px;'))
+      tr << (td = XMLElement.new('td', 'style' =>
+                                 'padding-left:1px; padding-right:1px;'))
+      td << @legend.to_html
+
+      # The footer with some administrative information.
+      tbody << (tr = XMLElement.new('tr', 'style' => 'font-size:9px'))
+      tr << (td = XMLElement.new('td', 'class' => 'tabfooter'))
+      td << XMLText.new(@project['copyright'] + " - ") if @project['copyright']
+      td << XMLText.new("Project: #{@project['name']} " +
+                        "Version: #{@project['version']} - " +
+                        "Created on #{TjTime.now.to_s("%Y-%m-%d %H:%M:%S")} " +
+                        "with ")
+      td << XMLNamedText.new("#{AppConfig.packageName}", 'a',
+                             'href' => "#{AppConfig.contact}")
+      td << XMLText.new(" v#{AppConfig.version}")
+
+      if @epilog
+        @epilog.sectionNumbers = false
+        frame << @epilog.to_html
+      end
+
+      html
+    end
+
+    # Convert the ReportElement into an Array of Arrays. It has one Array for
+    # each line. The nested Arrays have one String for each column.
+    def to_csv
+      @table.to_csv
+    end
+
+  protected
+
+    # Generates cells for the table header. _columnDef_ is the
+    # TableColumnDefinition object that describes the column. Based on the id of
+    # the column different actions need to be taken to generate the header text.
+    def generateHeaderCell(columnDef)
+      case columnDef.id
+      when 'chart'
+        # For the 'chart' column we generate a GanttChart object. The sizes are
+        # set so that the lines of the Gantt chart line up with the lines of the
+        # table.
+        gantt = GanttChart.new(@now, @weekStartsMonday, self)
+        gantt.generateByScale(@start, @end, columnDef.scale)
+        # The header consists of 2 lines separated by a 1 pixel boundary.
+        gantt.header.height = @table.headerLineHeight * 2 + 1
+        # The maximum width of the chart. In case it needs more space, a
+        # scrollbar is shown or the chart gets truncated depending on the output
+        # format.
+        gantt.viewWidth = columnDef.width
+        column = ReportTableColumn.new(@table, columnDef, '')
+        column.cell1.special = gantt
+        column.cell2.hidden = true
+        column.scrollbar = gantt.hasScrollbar?
+        @table.equiLines = true
+      when 'hourly'
+        genCalChartHeader(columnDef, @start.midnight, :sameTimeNextHour,
+                          :weekdayAndDate, :hour)
+      when 'daily'
+        genCalChartHeader(columnDef, @start.midnight, :sameTimeNextDay,
+                          :shortMonthName, :day)
+      when 'weekly'
+        genCalChartHeader(columnDef, @start.beginOfWeek(@weekStartsMonday),
+                          :sameTimeNextWeek, :shortMonthName, :day)
+      when 'monthly'
+        genCalChartHeader(columnDef, @start.beginOfMonth, :sameTimeNextMonth,
+                          :year, :shortMonthName)
+      when 'quarterly'
+        genCalChartHeader(columnDef, @start.beginOfQuarter,
+                          :sameTimeNextQuarter, :year, :quarterName)
+      when 'yearly'
+        genCalChartHeader(columnDef, @start.beginOfYear, :sameTimeNextYear,
+                          nil, :year)
+      else
+        # This is the most common case. It does not need any special treatment.
+        # We just set the pre-defined or user-defined column title in the first
+        # row of the header. The 2nd row is not visible.
+        column = ReportTableColumn.new(@table, columnDef, columnDef.title)
+        column.cell1.rows = 2
+        column.cell2.hidden = true
+      end
+    end
+
+    # Generate a ReportTableLine for each of the tasks in _taskList_. In case
+    # _resourceList_ is not nil, it also generates the nested resource lines for
+    # each resource that is assigned to the particular task. If _scopeLine_
+    # is defined, the generated task lines will be within the scope this resource
+    # line.
+    def generateTaskList(taskList, resourceList, scopeLine)
+      queryAttrs = { 'scopeProperty' => scopeLine ? scopeLine.property : nil,
+                     'loadUnit' => @loadUnit,
+                     'numberFormat' => @numberFormat,
+                     'currencyFormat' => @currencyFormat,
+                     'start' => @start, 'end' => @end,
+                     'costAccount' => @costAccount,
+                     'revenueAccount' => @revenueAccount }
+      taskList.query = Query.new(queryAttrs)
+      taskList.sort!
+
+      # The primary line counter. Is not used for enclosed lines.
+      no = 0
+      # The scope line counter. It's reset for each new scope.
+      lineNo = scopeLine ? scopeLine.lineNo : 0
+      # Init the variable to get a larger scope
+      line = nil
+      taskList.each do |task|
+        no += 1
+        Log.activity if lineNo % 10 == 0
+        lineNo += 1
+        @scenarios.each do |scenarioIdx|
+          # Generate line for each task.
+          line = ReportTableLine.new(@table, task, scopeLine)
+
+          line.no = no unless scopeLine
+          line.lineNo = lineNo
+          line.subLineNo = @table.lines
+          setIndent(line, @taskRoot, taskList.treeMode?)
+
+          # Generate a cell for each column in this line.
+          @columns.each do |columnDef|
+            next unless generateTableCell(line, task, columnDef, scenarioIdx)
+          end
+        end
+
+        if resourceList
+          # If we have a resourceList we generate nested lines for each of the
+          # resources that are assigned to this task and pass the user-defined
+          # filter.
+          resourceList.setSorting(@sortResources)
+          assignedResourceList = filterResourceList(resourceList, task,
+              @hideResource, @rollupResource)
+          assignedResourceList.sort!
+          lineNo = generateResourceList(assignedResourceList, nil, line)
+        end
+      end
+      lineNo
+    end
+
+    # Generate a ReportTableLine for each of the resources in _resourceList_. In
+    # case _taskList_ is not nil, it also generates the nested task lines for
+    # each task that the resource is assigned to. If _scopeLine_ is defined, the
+    # generated resource lines will be within the scope this task line.
+    def generateResourceList(resourceList, taskList, scopeLine)
+      queryAttrs = { 'scopeProperty' => scopeLine ? scopeLine.property : nil,
+                     'loadUnit' => @loadUnit,
+                     'numberFormat' => @numberFormat,
+                     'currencyFormat' => @currencyFormat,
+                     'start' => @start, 'end' => @end,
+                     'costAccount' => @costAccount,
+                     'revenueAccount' => @revenueAccount }
+      resourceList.query = Query.new(queryAttrs)
+      resourceList.sort!
+
+      # The primary line counter. Is not used for enclosed lines.
+      no = 0
+      # The scope line counter. It's reset for each new scope.
+      lineNo = scopeLine ? scopeLine.lineNo : 0
+      # Init the variable to get a larger scope
+      line = nil
+      resourceList.each do |resource|
+        no += 1
+        Log.activity if lineNo % 10 == 0
+        lineNo += 1
+        @scenarios.each do |scenarioIdx|
+          # Generate line for each resource.
+          line = ReportTableLine.new(@table, resource, scopeLine)
+
+          line.no = no unless scopeLine
+          line.lineNo = lineNo
+          line.subLineNo = @table.lines
+          setIndent(line, @resourceRoot, resourceList.treeMode?)
+
+          # Generate a cell for each column in this line.
+          @columns.each do |column|
+            next unless generateTableCell(line, resource, column, scenarioIdx)
+          end
+        end
+
+        if taskList
+          # If we have a taskList we generate nested lines for each of the
+          # tasks that the resource is assigned to and pass the user-defined
+          # filter.
+          taskList.setSorting(@sortTasks)
+          assignedTaskList = filterTaskList(taskList, resource,
+              @hideTask, @rollupTask)
+          assignedTaskList.sort!
+          lineNo = generateTaskList(assignedTaskList, nil, line)
+        end
+      end
+      lineNo
+    end
+
+  private
+
+    # Generate the header data for calendar tables. They consists of columns for
+    # each hour, day, week, etc. _columnDef_ is the definition of the columns.
+    # _t_ is the start time for the calendar. _sameTimeNextFunc_ is a function
+    # that is called to advance _t_ to the next table column interval.
+    # _name1Func_ and _name2Func_ are functions that return the upper and lower
+    # title of the particular column.
+    def genCalChartHeader(columnDef, t, sameTimeNextFunc, name1Func, name2Func)
+      tableColumn = ReportTableColumn.new(@table, columnDef, '')
+
+      # Calendar chars only work when all lines have same height.
+      @table.equiLines = true
+
+      # Embedded tables have unpredictable width. So we always need to make room
+      # for a potential scrollbar.
+      tableColumn.scrollbar = true
+
+      # Create the table that is embedded in this column.
+      tableColumn.cell1.special = table = ColumnTable.new
+      table.equiLines = true
+      tableColumn.cell2.hidden = true
+      table.maxWidth = columnDef.width
+
+      # Iterate over the report interval until we hit the end date. The
+      # iteration is done with 2 nested loops. The outer loops generates the
+      # intervals for the upper (larger) scale. The inner loop generates the
+      # lower (smaller) scale.
+      while t < @end
+        cellsInInterval = 0
+        # Label for upper scale. The yearly calendar only has a lower scale.
+        currentInterval = t.send(name1Func) if name1Func
+        firstColumn = nil
+        # The innter loops terminates when the label for the upper scale has
+        # changed to the next scale cell.
+        while t < @end && (name1Func.nil? || t.send(name1Func) == currentInterval)
+          # call TjTime::sameTimeNext... function to get the end of the column.
+          nextT = t.send(sameTimeNextFunc)
+          iv = Interval.new(t, nextT)
+          # Create the new column object.
+          column = ReportTableColumn.new(table, nil, '')
+          # Store the date of the column in the original form.
+          column.cell1.data = t.to_s(@timeFormat)
+          # The upper scale cells will be merged into one large cell that spans
+          # all lower scale cells that belong to this upper cell.
+          if firstColumn.nil?
+            firstColumn = column
+            column.cell1.text = currentInterval.to_s
+          else
+            column.cell1.hidden = true
+          end
+          column.cell2.text = t.send(name2Func).to_s
+          # TODO: The width should be taken from some data structure.
+          column.cell2.width = 20
+          # Off-duty cells will have a different color than working time cells.
+          unless @project.isWorkingTime(iv)
+            column.cell2.category = 'tabhead_offduty'
+          end
+          cellsInInterval += 1
+
+          t = nextT
+        end
+        # The the first upper scale cell how many trailing hidden cells are
+        # following.
+        firstColumn.cell1.columns = cellsInInterval
+      end
+    end
+
+    # Generate a cell of the table. _line_ is the ReportTableLine that this cell
+    # should belong to. _property_ is the PropertyTreeNode that is reported in
+    # this _line_. _columnDef_ is the TableColumnDefinition of the column this
+    # cell should belong to. _scenarioIdx_ is the index of the scenario that is
+    # reported in this _line_.
+    #
+    # There are 4 kinds of cells. The most simple one is the standard cell. It
+    # literally reports the value of a property attribute. Calculated cells are
+    # more flexible. They contain computed values. The values are computed at
+    # cell generation time. The calendar columns consist of multiple sub
+    # columns. In such a case many cells are generated with a single call of
+    # this method. The last kind of cell is actually not a cell. It just
+    # generates the chart objects that belong to the property in this line.
+    def generateTableCell(line, property, columnDef, scenarioIdx)
+      case columnDef.id
+      when 'chart'
+        # Generate a hidden cell. The real meat is in the actual chart object,
+        # not in this cell.
+        cell = ReportTableCell.new(line)
+        cell.hidden = true
+        cell.text = nil
+        # The GanttChart can be reached via the special variable of the column
+        # header.
+        chart = columnDef.column.cell1.special
+        GanttLine.new(chart, property,
+                      line.scopeLine ? line.scopeLine.property : nil,
+                      scenarioIdx, (line.subLineNo - 1) * (line.height + 1),
+                      line.height)
+        return true
+      # The calendar cells can be all generated by the same function. But we
+      # need to use different parameters.
+      when 'hourly'
+        start = @start.midnight
+        sameTimeNextFunc = :sameTimeNextHour
+      when 'daily'
+        start = @start.midnight
+        sameTimeNextFunc = :sameTimeNextDay
+      when 'weekly'
+        start = @start.beginOfWeek(@weekStartsMonday)
+        sameTimeNextFunc = :sameTimeNextWeek
+      when 'monthly'
+        start = @start.beginOfMonth
+        sameTimeNextFunc = :sameTimeNextMonth
+      when 'quarterly'
+        start = @start.beginOfQuarter
+        sameTimeNextFunc = :sameTimeNextQuarter
+      when 'yearly'
+        start = @start.beginOfYear
+        sameTimeNextFunc = :sameTimeNextYear
+      else
+        if calculated?(columnDef.id)
+          genCalculatedCell(scenarioIdx, line, columnDef, property)
+          return true
+        else
+          return genStandardCell(scenarioIdx, line, columnDef)
+        end
+      end
+
+      # The calendar cells don't live in this ReportTable but in an embedded
+      # ReportTable that can be reached via the column header special variable.
+      # For embedded column tables we need to create a new line.
+      tcLine = ReportTableLine.new(columnDef.column.cell1.special,
+                                   line.property, line.scopeLine)
+
+      # Depending on the property type we use different generator functions.
+      if property.is_a?(Task)
+        genCalChartTaskCell(scenarioIdx, tcLine, columnDef, start,
+                            sameTimeNextFunc)
+      elsif property.is_a?(Resource)
+        genCalChartResourceCell(scenarioIdx, tcLine, columnDef, start,
+                                sameTimeNextFunc)
+      else
+        raise "Unknown property type #{property.class}"
+      end
+      true
+    end
+
+    # Generate a ReportTableCell filled the value of an attribute of the
+    # property that line is for. It returns true if the cell exists, false for a
+    # hidden cell.
+    def genStandardCell(scenarioIdx, line, columnDef)
+      property = line.property
+      # Create a new cell
+      cell = newCell(line, cellText(property, scenarioIdx, columnDef.id))
+
+      if property.is_a?(Task)
+        properties = @project.tasks
+      elsif property.is_a?(Resource)
+        properties = @project.resources
+      else
+        raise "Unknown property type #{property.class}"
+      end
+
+      # Check if we are dealing with multiple scenarios.
+      if @scenarios.length > 1
+        # Check if the attribute is not scenario specific
+        unless properties.scenarioSpecific?(columnDef.id)
+          if scenarioIdx == @scenarios.first
+            #  Use a somewhat bigger font.
+            cell.fontSize = 15
+          else
+            # And hide the cells for all but the first scenario.
+            cell.hidden = true
+            return false
+          end
+          cell.rows = @scenarios.length
+        end
+      end
+
+      setStandardCellAttributes(cell, columnDef,
+                                properties.attributeType(columnDef.id), line)
+
+      scopeProperty = line.scopeLine ? line.scopeLine.property : nil
+      query = Query.new('property' => property,
+                        'scopeProperty' => scopeProperty,
+                        'attributeId' => columnDef.id,
+                        'scenarioIdx' => scenarioIdx, 'loadUnit' => @loadUnit,
+                        'numberFormat' => @numberFormat,
+                        'currencyFormat' => @currencyFormat,
+                        'start' => @start, 'end' => @end,
+                        'costAccount' => @costAccount,
+                        'revenueAccount' => @revenueAccount)
+      if cell.text
+        if columnDef.cellText
+          cell.text = expandMacros(columnDef.cellText, cell.text, query)
+        end
+      else
+        cell.text = '<Error>'
+        cell.fontColor = 0xFF0000
+      end
+
+      setCellURL(cell, columnDef, query)
+      true
+    end
+
+    # Generate a ReportTableCell filled with a calculted value from the property
+    # or other sources of information. It returns true if the cell exists, false
+    # for a hidden cell. _scenarioIdx_ is the index of the reported scenario.
+    # _line_ is the ReportTableLine of the cell. _columnDef_ is the
+    # TableColumnDefinition of the column. _property_ is the PropertyTreeNode
+    # that is reported in this cell.
+    def genCalculatedCell(scenarioIdx, line, columnDef, property)
+      # Create a new cell
+      cell = newCell(line)
+
+      unless scenarioSpecific?(columnDef.id)
+        if scenarioIdx != @scenarios.first
+          cell.hidden = true
+          return false
+        end
+        cell.rows = @scenarios.length
+      end
+
+      setStandardCellAttributes(cell, columnDef, nil, line)
+
+      return if columnDef.hideCellText &&
+                endcolumnDef.hideCellText.eval(property, scopeProperty)
+
+      scopeProperty = line.scopeLine ? line.scopeLine.property : nil
+      query = Query.new('property' => property,
+                        'scopeProperty' => scopeProperty,
+                        'attributeId' => columnDef.id,
+                        'scenarioIdx' => scenarioIdx, 'loadUnit' => @loadUnit,
+                        'numberFormat' => @numberFormat,
+                        'currencyFormat' => @currencyFormat,
+                        'start' => @start, 'end' => @end,
+                        'costAccount' => @costAccount,
+                        'revenueAccount' => @revenueAccount)
+      query.process
+      cell.text = query.result
+
+      # Some columns need some extra care.
+      case columnDef.id
+      when 'line'
+        cell.text = line.lineNo.to_s
+      when 'no'
+        cell.text = line.no.to_s
+      when 'wbs'
+        cell.indent = 2 if line.scopeLine
+      end
+
+      if columnDef.cellText
+        cell.text = expandMacros(columnDef.cellText, cell.text, query)
+      end
+      setCellURL(cell, columnDef, query)
+    end
+
+    # Generate the cells for the task lines of a calendar column. These lines do
+    # not directly belong to the @table object but to an embedded ColumnTable
+    # object. Therefor a single @table column usually has many cells on each
+    # single line. _scenarioIdx_ is the index of the scenario that is reported
+    # in this line. _line_ is the @table line. _t_ is the start date for the
+    # calendar. _sameTimeNextFunc_ is the function that will move the date to
+    # the next cell.
+    def genCalChartTaskCell(scenarioIdx, line, columnDef, t, sameTimeNextFunc)
+      task = line.property
+      # Find out if we have an enclosing resource scope.
+      if line.scopeLine && line.scopeLine.property.is_a?(Resource)
+        resource = line.scopeLine.property
+      else
+        resource = nil
+      end
+
+      # Get the interval of the task. In case a date is invalid due to a
+      # scheduling problem, we use the full project interval.
+      taskIv = Interval.new(task['start', scenarioIdx].nil? ?
+                            @project['start'] : task['start', scenarioIdx],
+                            task['end', scenarioIdx].nil? ?
+                            @project['end'] : task['end', scenarioIdx])
+
+      query = Query.new('property' => task, 'scopeProperty' => resource,
+                        'scenarioIdx' => scenarioIdx, 'loadUnit' => @loadUnit,
+                        'numberFormat' => @numberFormat,
+                        'currencyFormat' => @currencyFormat,
+                        'costAccount' => @costAccount,
+                        'revenueAccount' => @revenueAccount)
+
+      firstCell = nil
+      while t < @end
+        # Create a new cell
+        cell = newCell(line)
+
+        # call TjTime::sameTimeNext... function
+        nextT = t.send(sameTimeNextFunc)
+        cellIv = Interval.new(t, nextT)
+        case columnDef.content
+        when 'empty'
+          # We only generate cells will different background colors.
+        when 'load'
+          query.attributeId = 'effort'
+          query.startIdx = t
+          query.endIdx = nextT
+          query.process
+          # To increase readability, we don't show 0.0 values.
+          cell.text = query.result if query.numericalResult > 0.0
+        else
+          raise "Unknown column content #{column.content}"
+        end
+
+        # Determine cell category (mostly the background color)
+        if cellIv.overlaps?(taskIv)
+          cell.category = task.container? ? 'calconttask' : 'caltask'
+        elsif !@project.isWorkingTime(cellIv)
+          cell.category = 'offduty'
+        else
+          cell.category = 'taskcell'
+        end
+        cell.category += line.property.get('index') % 2  == 1 ? '1' : '2'
+
+        tryCellMerging(cell, line, firstCell)
+
+        t = nextT
+        firstCell = cell unless firstCell
+      end
+
+      legend.addCalendarItem('Container Task', 'calconttask1')
+      legend.addCalendarItem('Task', 'caltask1')
+      legend.addCalendarItem('Off duty time', 'offduty')
+    end
+
+    # Generate the cells for the resource lines of a calendar column. These
+    # lines do not directly belong to the @table object but to an embedded
+    # ColumnTable object. Therefor a single @table column usually has many cells
+    # on each single line. _scenarioIdx_ is the index of the scenario that is
+    # reported in this line. _line_ is the @table line. _t_ is the start date
+    # for the calendar. _sameTimeNextFunc_ is the function that will move the
+    # date to the next cell.
+    def genCalChartResourceCell(scenarioIdx, line, columnDef, t,
+                                sameTimeNextFunc)
+      resource = line.property
+      # Find out if we have an enclosing task scope.
+      if line.scopeLine && line.scopeLine.property.is_a?(Task)
+        task = line.scopeLine.property
+        # Get the interval of the task. In case a date is invalid due to a
+        # scheduling problem, we use the full project interval.
+        taskIv = Interval.new(task['start', scenarioIdx].nil? ?
+                              @project['start'] : task['start', scenarioIdx],
+                              task['end', scenarioIdx].nil? ?
+                              @project['end'] : task['end', scenarioIdx])
+      else
+        task = nil
+      end
+
+      query = Query.new('property' => resource,
+                        'scenarioIdx' => scenarioIdx, 'loadUnit' => @loadUnit,
+                        'numberFormat' => @numberFormat,
+                        'currencyFormat' => @currencyFormat,
+                        'costAccount' => @costAccount,
+                        'revenueAccount' => @revenueAccount)
+
+      firstCell = nil
+      while t < @end
+        # Create a new cell
+        cell = newCell(line)
+
+        # call TjTime::sameTimeNext... function
+        nextT = t.send(sameTimeNextFunc)
+        cellIv = Interval.new(t, nextT)
+        # Get work load for all tasks.
+        query.scopeProperty = nil
+        query.attributeId = 'effort'
+        query.startIdx = @project.dateToIdx(t, true)
+        query.endIdx = @project.dateToIdx(nextT, true) - 1
+        query.process
+        workLoad = query.numericalResult
+        scaledWorkLoad = query.result
+        if task
+          # Get work load for the particular task.
+          query.scopeProperty = task
+          query.process
+          workLoadTask = query.numericalResult
+          scaledWorkLoad = query.result
+        else
+          workLoadTask = 0.0
+        end
+        # Get unassigned work load.
+        query.attributeId = 'freework'
+        query.process
+        freeLoad = query.numericalResult
+        case columnDef.content
+        when 'empty'
+          # We only generate cells will different background colors.
+        when 'load'
+          # Report the workload of the resource in this time interval.
+          # To increase readability, we don't show 0.0 values.
+          wLoad = task ? workLoadTask : workLoad
+          if wLoad > 0.0
+            cell.text = scaledWorkLoad
+          end
+        else
+          raise "Unknown column content #{column.content}"
+        end
+
+        # Determine cell category (mostly the background color)
+        cell.category = if task
+                          if cellIv.overlaps?(taskIv)
+                            if workLoadTask > 0.0 && freeLoad == 0.0
+                              'busy'
+                            elsif workLoad == 0.0 && freeLoad == 0.0
+                              'offduty'
+                            else
+                              'loaded'
+                            end
+                          else
+                            if freeLoad > 0.0
+                              'free'
+                            elsif workLoad == 0.0 && freeLoad == 0.0
+                              'offduty'
+                            else
+                              'resourcecell'
+                            end
+                          end
+                        else
+                          if workLoad > 0.0 && freeLoad == 0.0
+                            'busy'
+                          elsif workLoad > 0.0 && freeLoad > 0.0
+                            'loaded'
+                          elsif workLoad == 0.0 && freeLoad > 0.0
+                            'free'
+                          else
+                            'offduty'
+                          end
+                        end
+        cell.category += line.property.get('index') % 2 == 1 ? '1' : '2'
+
+        tryCellMerging(cell, line, firstCell)
+
+        t = nextT
+        firstCell = cell unless firstCell
+      end
+
+      legend.addCalendarItem('Resource is fully loaded', 'busy1')
+      legend.addCalendarItem('Resource is partially loaded', 'loaded1')
+      legend.addCalendarItem('Resource is available', 'free')
+      legend.addCalendarItem('Off duty time', 'offduty')
+    end
+
+    def setStandardCellAttributes(cell, columnDef, attributeType, line)
+      # Determine whether it should be indented
+      if indent(columnDef.id, attributeType)
+        cell.indent = line.indentation
+      end
+
+      # Determine the cell alignment
+      cell.alignment = alignment(columnDef.id, attributeType)
+
+      # Set background color
+      if line.property.is_a?(Task)
+        cell.category = line.property.get('index') % 2 == 1 ?
+          'taskcell1' : 'taskcell2'
+      else
+        cell.category = line.property.get('index') % 2 == 1 ?
+          'resourcecell1' : 'resourcecell2'
+      end
+    end
+
+    # Create a new ReportTableCell object and initialize some common values.
+    def newCell(line, text = '')
+      property = line.property
+      cell = ReportTableCell.new(line, text)
+
+      # Cells for containers should be using bold font face.
+      cell.bold = true if property.container?
+
+      cell
+    end
+
+    # Determine the indentation for this line.
+    def setIndent(line, propertyRoot, treeMode)
+      property = line.property
+      scopeLine = line.scopeLine
+      level = property.level - (propertyRoot ? propertyRoot.level : 0)
+      # We indent at least as much as the scopeline + 1, if we have a scope.
+      line.indentation = scopeLine.indentation + 1 if scopeLine
+      # In tree mode we indent according to the level.
+      line.indentation += level if treeMode
+    end
+
+    # Set the URL associated with the cell text. _cell_ is the ReportTableCell.
+    # _columnDef_ is the user specified definition for the cell content and
+    # look. _query_ is the query used to resolve dynamic macros in the cellURL.
+    def setCellURL(cell, columnDef, query)
+      return unless columnDef.cellURL
+
+      url = expandMacros(columnDef.cellURL, cell.text, query)
+      cell.url = url unless url.empty?
+    end
+
+    # Try to merge equal cells without text to multi-column cells.
+    def tryCellMerging(cell, line, firstCell)
+      if cell.text == '' && firstCell && (c = line.last(1)) && c == cell
+        cell.hidden = true
+        c.columns += 1
+      end
+    end
+
+    # Expand the run-time macros in _pattern_. ${0} is a special case and will
+    # be replaced with the _originalText_. For all other macros the _query_ will
+    # be used with the macro name used for the attributeId of the query. The
+    # method returns the expanded pattern.
+    def expandMacros(pattern, originalText, query)
+      return pattern unless pattern.include?('${')
+
+      out = ''
+      # Scan the pattern for macros ${...}
+      i = 0
+      while i < pattern.length
+        c = pattern[i]
+        if c == ?$
+          # This could be a macro
+          if pattern[i + 1] != ?{
+            # It's not. Just append the '$'
+            out << c
+          else
+            # It is a macro.
+            i += 2
+            macro = ''
+            # Scan for the end '}' and get the macro name.
+            while i < pattern.length && pattern[i] != ?}
+              macro << pattern[i]
+              i += 1
+            end
+            if macro == '0'
+              # This turns RichText into plain ASCII!
+              out += originalText
+            else
+              # resolve by query
+              # If the macro is prefixed by a '?' it may be undefined.
+              if macro[0] == ??
+                macro = macro[1..-1]
+                ignoreErrors = true
+              else
+                ignoreErrors = false
+              end
+              query.attributeId = macro
+              query.process
+              unless query.ok || ignoreErrors
+                raise TjException.new, query.errorMessage
+              end
+              # This turns RichText into plain ASCII!
+              out += query.result
+            end
+          end
+        else
+          # Just append the character to the output.
+          out << c
+        end
+        i += 1
+      end
+
+      out
+    end
+
+  end
+
+end
+