taskjuggler 0.0.2

data/lib/reports/GanttContainer.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = GanttContainer.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/HTMLGraphics'
+
+class TaskJuggler
+
+  # The GanttContainer represents a container task (task with sub-tasks).
+  class GanttContainer
+
+    include HTMLGraphics
+
+    # The size of the bars in pixels from center to top/bottom.
+    @@size = 5
+
+    # Create a GanttContainer object based on the following information: _line_
+    # is a reference to the GanttLine. _xStart_ is the left edge of the task in
+    # chart coordinates. _xEnd_ is the right edge. The container extends over
+    # the edges due to the shape of the jags.
+    def initialize(task, scenarioIdx, lineHeight, xStart, xEnd, y)
+      @task = task
+      @scenarioIdx = scenarioIdx
+      @lineHeight = lineHeight
+      @start = xStart
+      @end = xEnd
+      @y = y
+    end
+
+    # Return the point [ x, y ] where task start dependency lines should start
+    # from.
+    def startDepLineStart
+      [ @start, @y + @lineHeight / 2 ]
+    end
+
+    # Return the point [ x, y ] where task start dependency lines should end at.
+    def startDepLineEnd
+      [ @start - @@size, @y + @lineHeight / 2 ]
+    end
+
+    # Return the point [ x, y ] where task end dependency lines should start
+    # from.
+    def endDepLineStart
+      [ @end + @@size, @y + @lineHeight / 2 ]
+    end
+
+    # Return the point [ x, y ] where task end dependency lines should end at.
+    def endDepLineEnd
+      [ @end, @y + @lineHeight / 2 ]
+    end
+
+    def addBlockedZones(router)
+      height = (@lineHeight / 2) - @@size
+      # Horizontal block
+      router.addZone(@start - @@size, @y + (@lineHeight / 2) - @@size - 2,
+                     @end - @start + 1 + 2 * @@size, 2 * @@size + 5, true, false)
+      # Block for arrowhead.
+      router.addZone(@start - @@size - 9, @y + (@lineHeight / 2) - 7, 10, 15,
+                     true, true)
+      # Vertical block for end cap
+      router.addZone(@start - @@size - 2, @y, 2 * @@size + 5, @lineHeight,
+                     false, true)
+      router.addZone(@end - @@size - 2, @y, 2 * @@size + 5, @lineHeight,
+                     false, true)
+    end
+
+    # Convert the abstact representation of the GanttContainer into HTML
+    # elements.
+    def to_html
+      xStart = @start.to_i
+      yCenter = (@lineHeight / 2).to_i
+      width = @end.to_i - @start.to_i + 1
+
+      html = []
+
+      # If the container is too small we make it wider so it is recognizeable.
+      xStart -= (@@size + 1) - (width / 2) if width < 2
+
+      # The bar
+      html << rectToHTML(xStart - @@size, yCenter - @@size,
+                         width + 2 * @@size, @@size, 'containerbar')
+      # The left jag
+      (@@size + 1).times do |i|
+        html << rectToHTML(xStart - @@size + i, yCenter + i,
+                           1 + (@@size - i) * 2, 1, 'containerbar')
+      end
+      # The right jag
+      (@@size + 1).times do |i|
+        html << rectToHTML(xStart + width - 1 - @@size + i, yCenter + i,
+                           1 + (@@size - i) * 2, 1, 'containerbar')
+      end
+
+      html
+    end
+
+  end
+
+end
+

data/lib/reports/GanttHeader.rb

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = GanttHeader.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/GanttHeaderScaleItem'
+
+class TaskJuggler
+
+  # This class stores output format independent information to describe a
+  # GanttChart header. A Gantt chart header consists of 2 lines. The top line
+  # holds the large scale (e. g. the year or month and year) and the lower line
+  # holds the small scale (e. g. week or day).
+  class GanttHeader
+
+    attr_reader :gridLines, :nowLineX, :cellStartDates
+    attr_accessor :height
+
+    # Create a GanttHeader object and generate the scales for the header.
+    def initialize(chart)
+      @chart = chart
+
+      @largeScale = []
+      @smallScale = []
+
+      # Positions where chart should be marked with vertical lines that match
+      # the large scale.
+      @gridLines = []
+
+      # X coordinate of the "now" line. nil if "now" is off-chart.
+      @nowLineX = nil
+
+      # The x coordinates and width of the cells created by the small scale. The
+      # values are stored as [ x, w ].
+      @cellStartDates = []
+      # The height of the header in pixels.
+      @height = 39
+
+      generate
+    end
+
+    # Convert the header into an HTML format.
+    def to_html
+      div = XMLElement.new('div', 'class' => 'tabback',
+                           'style' => "margin:0px; padding:0px; " +
+                           "position:relative; overflow:hidden; " +
+                           "width:#{@chart.width.to_i}px; " +
+                           "height:#{@height.to_i}px; " +
+                           "font-size:#{(@height / 4).to_i}px; ")
+      @largeScale.each { |s| div << s.to_html }
+      @smallScale.each { |s| div << s.to_html }
+      div
+    end
+
+  private
+
+    # Call genHeaderScale with the right set of parameters (depending on the
+    # selected scale) for the lower and upper header line.
+    def generate
+      # The 2 header lines are separated by a 1 pixel boundary.
+      h = ((@height - 1) / 2).to_i
+      case @chart.scale['name']
+      when 'hour'
+        genHeaderScale(@largeScale, 0, h, :midnight, :sameTimeNextDay,
+                       :weekdayAndDate)
+        genHeaderScale(@smallScale, h + 1, h, :beginOfHour, :sameTimeNextHour,
+                       :hour)
+      when 'day'
+        genHeaderScale(@largeScale, 0, h, :beginOfMonth, :sameTimeNextMonth,
+                       :shortMonthName)
+        genHeaderScale(@smallScale, h + 1, h, :midnight, :sameTimeNextDay, :day)
+      when 'week'
+        genHeaderScale(@largeScale, 0, h, :beginOfMonth, :sameTimeNextMonth,
+                       :monthAndYear)
+        genHeaderScale(@smallScale, h + 1, h, :beginOfWeek, :sameTimeNextWeek,
+                       :week)
+      when 'month'
+        genHeaderScale(@largeScale, 0, h, :beginOfYear, :sameTimeNextYear, :year)
+        genHeaderScale(@smallScale, h + 1, h, :beginOfMonth, :sameTimeNextMonth,
+                       :shortMonthName)
+      when 'quarter'
+        genHeaderScale(@largeScale, 0, h, :beginOfYear, :sameTimeNextYear, :year)
+        genHeaderScale(@smallScale, h + 1, h, :beginOfQuarter,
+                       :sameTimeNextQuarter, :quarterName)
+      when 'year'
+        genHeaderScale(@smallScale, h + 1, h, :beginOfYear, :sameTimeNextYear,
+                       :year)
+      else
+        raise "Unknown scale: #{@chart.scale['name']}"
+      end
+
+      nlx = @chart.dateToX(@chart.now)
+      @nowLineX = nlx if nlx
+    end
+
+    # Generate the actual scale cells.
+    def genHeaderScale(scale, y, h, beginOfFunc, sameTimeNextFunc, nameFunc)
+      # The beginOfWeek function needs a parameter, so we have to handle it as a
+      # special case.
+      if beginOfFunc == :beginOfWeek
+        t = @chart.start.send(beginOfFunc, @chart.weekStartsMonday)
+      else
+        t = @chart.start.send(beginOfFunc)
+      end
+
+      # Now we iterate of the report period in steps defined by
+      # sameTimeNextFunc. For each time slot we generate GanttHeaderScaleItem
+      # object and append it to the scale.
+      while t < @chart.end
+        nextT = t.send(sameTimeNextFunc)
+        # Determine the end of the cell. We keep 1 pixel for the boundary.
+        w = (xR = @chart.dateToX(nextT).to_i - 1) - (x = @chart.dateToX(t).to_i)
+        # We collect the positions of the large grid scale marks for later use
+        # in the chart.
+        if scale == @largeScale
+          @gridLines << xR
+        else
+          @cellStartDates << t
+        end
+        # Again, nameFunc needs special handling for the week case due to the
+        # extra parameter.
+        name = nameFunc == :week ? t.send(nameFunc, @chart.weekStartsMonday) :
+                                   t.send(nameFunc)
+        scale << GanttHeaderScaleItem.new(name, x, y, w, h)
+        t = nextT
+      end
+      # Add the end date of the last cell when generating the small scale.
+      @cellStartDates << t if scale == @smallScale
+    end
+
+  end
+
+end
+

data/lib/reports/GanttHeaderScaleItem.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = GanttHeaderScaleItem.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 is a storate container for all data related to a scale step of a
+  # GanttChart header.
+  class GanttHeaderScaleItem
+
+    attr_reader :label, :pos, :width
+
+    def initialize(label, x, y, width, height)
+      @label = label
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+    end
+
+    def to_html
+      div = XMLElement.new('div', 'class' => 'tabhead',
+        'style' => "font-weight:bold; position:absolute; " +
+        "left:#{@x}px; top:#{@y}px; width:#{@width}px; height:#{@height}px; ")
+      div << (div1 = XMLElement.new('div', 'style' => 'padding:3px; '))
+      div1 << XMLText.new("#{label}")
+
+      div
+    end
+
+  end
+
+end
+

data/lib/reports/GanttLine.rb

@@ -0,0 +1,329 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = GanttLine.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/GanttTaskBar'
+require 'reports/GanttMilestone'
+require 'reports/GanttContainer'
+require 'reports/GanttLoadStack'
+require 'reports/HTMLGraphics'
+require 'XMLDocument'
+
+class TaskJuggler
+
+  # This class models the abstract (output independent) form of a line of a
+  # Gantt chart. Each line represents a property. Depending on the type of
+  # property and it's context (for nested properties) the content varies. Tasks
+  # (not nested) are represented as task bars or milestones. When nested into a
+  # resource they are represented as load stacks.
+  class GanttLine
+
+    include HTMLGraphics
+
+    attr_reader :y, :height, :property, :scenarioIdx
+
+    # Create a GanttLine object and generate the abstract representation.
+    def initialize(chart, property, scopeProperty, scenarioIdx, y, height)
+      # A reference to the chart that the line belongs to.
+      @chart = chart
+      # Register the line with the chart.
+      @chart.addLine(self)
+
+      # The category determines the background color of the line.
+      @category = nil
+      # The property that is displayed in this line.
+      @property = property
+      # In case this line lists the property in the scope of another property,
+      # this is a reference to the line of the enclosing property. Otherwise it
+      # is nil.
+      @scopeProperty = scopeProperty
+      # The scenario index.
+      @scenarioIdx = scenarioIdx
+      # The y coordinate of the topmost pixel of this line.
+      @y = y + chart.header.height + 1
+      # The height of the line in screen pixels.
+      @height = height
+      # The x coordinates of the time-off zones. It's an Array of [ startX, endX
+      # ] touples.
+      @timeOffZones = []
+
+      generate
+    end
+
+    # Convert the abstract representation of the GanttLine into HTML elements.
+    def to_html
+      # The whole line is put in a 'div' section. All coordinates relative to
+      # the top-left corner of this div. Elements that extend over the
+      # boundaries of this div are cut off.
+      div = XMLElement.new('div', 'class' => @category,
+                           'style' => "margin:0px; padding:0px; " +
+                           "position:absolute; overflow:hidden; " +
+                           "left:0px; top:#{@y}px; " +
+                           "width:#{@chart.width.to_i}px; " +
+                           "height:#{@height}px; " +
+                           "font-size:10px;")
+      # Render time-off zones.
+      @timeOffZones.each do |zone|
+        div << rectToHTML(zone[0], 0, zone[1], @height, 'offduty')
+      end
+
+      # Render grid lines. The grid lines are determined by the large scale.
+      @chart.header.gridLines.each do |line|
+        div << rectToHTML(line, 0, 1, @height, 'tabvline')
+      end
+
+      # Now render the content as HTML elements.
+      @content.each do |c|
+        div << c.to_html
+      end
+
+      # Render the 'now' line
+      if @chart.header.nowLineX
+        div << rectToHTML(@chart.header.nowLineX, 0, 1, @height, 'nowline')
+      end
+
+      div
+    end
+
+    # This function only works for primary task lines. It returns the generated
+    # intermediate object for that line.
+    def getTask
+      if @content.length == 1
+        @content[0]
+      else
+        nil
+      end
+    end
+
+    # Register the areas that dependency lines should not cross.
+    def addBlockedZones(router)
+      @content.each do |c|
+        c.addBlockedZones(router)
+      end
+    end
+
+  private
+
+    # Create the data objects that represent the abstract form of this
+    # perticular Gantt chart line.
+    def generate
+      # This Array holds the GanttLineObjects.
+      @content = []
+
+      generateTimeOffZones
+
+      if @property.is_a?(Task)
+        generateTask
+      else
+        generateResource
+      end
+    end
+
+    # Generate abstract form of a task line. The task can be a primary line or
+    # appear in the scope of a resource.
+    def generateTask
+      # Set the background color
+      @category = "taskcell#{(@property.get('index') + 1) % 2 + 1}"
+
+      project = @property.project
+      taskStart = @property['start', @scenarioIdx] || project['start']
+      taskEnd = @property['end', @scenarioIdx] || project['end']
+
+      if @scopeProperty
+        # The task is nested into a resource. We show the work the resource is
+        # doing for this task relative to the work the resource is doing for
+        # all tasks.
+        x = nil
+        startDate = endDate = nil
+        categories = [ 'busy', nil ]
+
+        @chart.header.cellStartDates.each do |date|
+          if x.nil?
+            x = @chart.dateToX(endDate = date).to_i
+          else
+            xNew = @chart.dateToX(date).to_i
+            w = xNew - x
+            startDate = endDate
+            endDate = date
+
+            # If we have a scope limiting task, we only want to generate load
+            # stacks that overlap with the task interval.
+            next if endDate <= taskStart || taskEnd <= startDate
+            if startDate < taskStart && endDate > taskStart
+              # Make sure the left edge of the first stack aligns with the
+              # start of the scope task.
+              startDate = taskStart
+              x = @chart.dateToX(startDate)
+              w = xNew - x + 1
+            elsif startDate < taskEnd && endDate > taskEnd
+              # Make sure the right edge of the last stack aligns with the end
+              # of the scope task.
+              endDate = taskEnd
+              w = @chart.dateToX(endDate) - x
+            end
+
+            overallWork = @scopeProperty.getEffectiveWork(@scenarioIdx,
+                                                          startDate, endDate) +
+                          @scopeProperty.getEffectiveFreeWork(@scenarioIdx,
+                                                              startDate,
+                                                              endDate)
+            workThisTask = @property.getEffectiveWork(@scenarioIdx,
+                                                      startDate, endDate,
+                                                      @scopeProperty)
+            # If all values are 0 we make sure we show an empty frame.
+            if overallWork == 0 && workThisTask == 0
+              values = [ 0, 1 ]
+            else
+              values = [ workThisTask, overallWork - workThisTask ]
+            end
+            @content << GanttLoadStack.new(self, x + 1, w - 2, values,
+                                           categories)
+
+            x = xNew
+          end
+        end
+        if @chart.table
+          @chart.table.legend.addGanttItem('Resource assigned to task(s)',
+                                           'busy')
+        end
+      else
+        # The task is not nested into a resource. We show the classical Gantt
+        # bars for the task.
+        xStart = @chart.dateToX(taskStart)
+        xEnd = @chart.dateToX(taskEnd)
+        @chart.addTask(@property, self)
+        if @property['milestone', @scenarioIdx]
+          @content << GanttMilestone.new(@property, @height, xStart, @y)
+        elsif @property.container?
+          @content << GanttContainer.new(@property, @scenarioIdx, @height,
+                                         xStart, xEnd, @y)
+        else
+          @content << GanttTaskBar.new(@property, @scenarioIdx, @height,
+                                       xStart, xEnd, @y)
+        end
+
+        # Make sure the legend includes the Gantt symbols.
+        @chart.table.legend.showGanttItems = true if @chart.table
+      end
+
+    end
+
+    # Generate abstract form of a resource line. The resource can be a primary
+    # line or appear in the scope of a task.
+    def generateResource
+      # Set the alternating background color
+      @category = "resourcecell#{(@property.get('index') + 1) % 2 + 1}"
+
+      # The cellStartDate Array contains the end of the final cell as last
+      # element. We need to use a shift mechanism to start and end
+      # dates/positions properly.
+      x = nil
+      startDate = endDate = nil
+
+      # For unnested resource lines we show the assigned work and the
+      # available work. For resources in a task scope we show the work
+      # allocated to this task, the work allocated to other tasks and the free
+      # work.
+      if @scopeProperty
+        categories = [ 'assigned', 'busy', 'free' ]
+
+        project = @property.project
+        taskStart = @scopeProperty['start', @scenarioIdx] || project['start']
+        taskEnd = @scopeProperty['end', @scenarioIdx] || project['end']
+
+        if @chart.table
+          @chart.table.legend.addGanttItem('Resource assigned to this task',
+                                            'assigned')
+          @chart.table.legend.addGanttItem('Resource assigned to task(s)',
+                                           'busy')
+          @chart.table.legend.addGanttItem('Resource available', 'free')
+          @chart.table.legend.addGanttItem('Resource off-duty', 'offduty')
+        end
+      else
+        categories = [ 'busy', 'free' ]
+        if @chart.table
+          @chart.table.legend.addGanttItem('Resource assigned to task(s)',
+                                           'busy')
+          @chart.table.legend.addGanttItem('Resource available', 'free')
+          @chart.table.legend.addGanttItem('Resource off-duty', 'offduty')
+        end
+      end
+
+      @chart.header.cellStartDates.each do |date|
+        if x.nil?
+          x = @chart.dateToX(endDate = date).to_i
+        else
+          xNew = @chart.dateToX(date).to_i
+          w = xNew - x
+          startDate = endDate
+          endDate = date
+          if @scopeProperty
+            # If we have a scope limiting task, we only want to generate load
+            # stacks that overlap with the task interval.
+            next if endDate <= taskStart || taskEnd <= startDate
+            if startDate < taskStart && endDate > taskStart
+              # Make sure the left edge of the first stack aligns with the
+              # start of the scope task.
+              startDate = taskStart
+              x = @chart.dateToX(startDate)
+              w = xNew - x + 1
+            elsif startDate < taskEnd && endDate > taskEnd
+              # Make sure the right edge of the last stack aligns with the end
+              # of the scope task.
+              endDate = taskEnd
+              w = @chart.dateToX(endDate) - x
+            end
+            taskWork = @property.getEffectiveWork(@scenarioIdx,
+                                                  startDate, endDate,
+                                                  @scopeProperty)
+            overallWork = @property.getEffectiveWork(@scenarioIdx,
+                                                     startDate, endDate)
+            freeWork = @property.getEffectiveFreeWork(@scenarioIdx,
+                                                     startDate, endDate)
+            values = [ taskWork, overallWork - taskWork, freeWork ]
+          else
+            values = []
+            values << @property.getEffectiveWork(@scenarioIdx,
+                                                 startDate, endDate)
+            values << @property.getEffectiveFreeWork(@scenarioIdx,
+                                                     startDate, endDate)
+          end
+          @content << GanttLoadStack.new(self, x + 1, w - 2, values, categories)
+
+          x = xNew
+        end
+      end
+
+    end
+
+    # Generate the data structures that mark the time-off periods of a task or
+    # resource int the chart. Depending on the resolution, the only periods with
+    # a duration above the threshold are shown.
+    def generateTimeOffZones
+      iv = Interval.new(@chart.start, @chart.end)
+      # Don't show any zones if the threshold for this scale is 0 or smaller.
+      return if (minTimeOff = @chart.scale['minTimeOff']) <= 0
+
+      # Get the time-off intervals.
+      @timeOffZones = @property.collectTimeOffIntervals(@scenarioIdx, iv,
+                                                        minTimeOff)
+      # Convert the start/end dates to X coordinates of the chart. When
+      # finished, the zones in @timeOffZones are [ startX, endX ] touples.
+      @timeOffZones.each do |zone|
+        zone[0] = @chart.dateToX(zone[0])
+        zone[1] = @chart.dateToX(zone[1]) - zone[0]
+      end
+    end
+
+  end
+
+end
+