taskjuggler 3.0.0 → 3.1.0

data/lib/taskjuggler/ProjectFileParser.rb

@@ -3,7 +3,7 @@
 #
 # = ProjectFileParser.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -237,20 +237,37 @@ class TaskJuggler
     # type. +sourceFileInfo+ is a SourceFileInfo of the report definition. The
     # method returns the newly created Report.
     def newReport(id, name, type, sourceFileInfo)
+      # If there is no parent property and the report prefix is not empty, the
+      # reportprefix defines the parent property.
+      if @property.nil? && !@reportprefix.empty?
+        @property = @project.report(@reportprefix)
+      end
+
+      # Report IDs must be unique. If an ID was provided, check if it exists
+      # already.
+      if id
+        # If we have a scope property, we need to prepend the ID of the scope
+        # property to the provided ID.
+        id = (@property ? @property.fullId + '.' : '') + @val[1]
+
+        if @project.report(id)
+          error('report_exists', "report #{id} has already been defined.",
+                sourceFileInfo, @property)
+        end
+      end
+
       @reportCounter += 1
-      if name != '.'
+      if name != '.' && name != ''
         if @project.reportByName(name)
           error('report_redefinition',
                 "A report with the name #{name} has already been defined.")
         end
       end
       @property = Report.new(@project, id || "report#{@reportCounter}",
-                             name, nil)
+                             name, @property)
       @property.typeSpec = type
       @property.sourceFileInfo = sourceFileInfo
-      @property.set('formats', [ :tjp ])
       @property.inheritAttributes
-      @property
     end
 
     # If the @limitResources list is not empty, we have to create a Limits
@@ -394,6 +411,11 @@ class TaskJuggler
       @cr.setLastSyntaxToken(idx)
     end
 
+    # Specify the support level for the current pattern.
+    def level(level)
+      @cr.setSupportLevel(level)
+    end
+
     # Add a reference to another pattern. This information is only used to
     # generate the documentation for the patterns of this rule.
     def also(seeAlso)
@@ -454,6 +476,18 @@ class TaskJuggler
       @property = nil
     end
 
+    # This method most be used instead of the += operator for all list
+    # attributes. += will always return an Array object. This will cause
+    # trouble with the list attributes that are not plain Arrays.
+    def appendScListAttribute(attrId, list)
+      list.each do |v|
+        @property[attrId, @scenarioIdx] << v
+      end
+      # The << operator does not set the 'provided' flag. Just do a self
+      # assignment to trigget the flag to get set.
+      @property[attrId, @scenarioIdx] = @property[attrId, @scenarioIdx]
+    end
+
   end
 
 end

data/lib/taskjuggler/ProjectFileScanner.rb

@@ -3,7 +3,7 @@
 #
 # = ProjectFileScanner.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify

data/lib/taskjuggler/PropertyList.rb

@@ -3,7 +3,7 @@
 #
 # = PropertyList.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -11,6 +11,8 @@
 # published by the Free Software Foundation.
 #
 
+require 'taskjuggler/PTNProxy'
+
 class TaskJuggler
 
   # The PropertyList is a utility class that can be used to hold a list of
@@ -60,6 +62,16 @@ class TaskJuggler
       @items.method(func).call(*args, &block)
     end
 
+    def includeAdopted
+      adopted = []
+      @items.each do |p|
+        p.adoptees.each do |ap|
+          adopted += includeAdoptedR(ap, p)
+        end
+      end
+      append(adopted)
+    end
+
     def to_ary
       @items.dup
     end
@@ -165,6 +177,18 @@ class TaskJuggler
 
     private
 
+    def includeAdoptedR(property, parent)
+      # Create a proxy for the current PropertyTreeNode and add it to a list.
+      adopted = [ parentProxy = PTNProxy.new(property, parent) ]
+
+      # Add proxies for all children (adopted or not) and their children.
+      property.kids.each do |p|
+        adopted += includeAdoptedR(p, parentProxy)
+      end
+
+      adopted
+    end
+
     # Append a new sorting level to the existing levels.
     def addSortingCriteria(criteria, up, scIdx)
       unless @propertySet.knownAttribute?(criteria) ||
@@ -214,7 +238,7 @@ class TaskJuggler
       @items.sort! do |a, b|
         res = 0
         @sortingLevels.times do |i|
-          if @query
+          if @query && @sortingCriteria[i] != 'tree'
             # In case we have a Query reference, we get the two values with this
             # query.
             @query.scenarioIdx = @scenarioIdx[i] < 0 ? nil : @scenarioIdx[i]

data/lib/taskjuggler/PropertySet.rb

@@ -3,7 +3,7 @@
 #
 # = PropertySet.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -193,6 +193,12 @@ class TaskJuggler
         property = prop
       end
 
+      # Iterate over all properties and eliminate references to this the
+      # PropertyTreeNode to be removed.
+      @properties.each do |p|
+        p.removeReferences(p)
+      end
+
       # Recursively remove all sub-nodes. The children list is modified during
       # the call, so we can't use an iterator here.
       until property.children.empty? do
@@ -205,6 +211,7 @@ class TaskJuggler
       # Remove this node from the child list of the parent node.
       property.parent.children.delete(property) if property.parent
 
+
       property
     end
 

data/lib/taskjuggler/PropertyTreeNode.rb

@@ -3,7 +3,7 @@
 #
 # = PropertyTreeNode.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -135,34 +135,30 @@ class TaskJuggler
       self
     end
 
+    # We often use PTNProxy objects to represent PropertyTreeNode objects. The
+    # proxy usually does a good job acting like a PropertyTreeNode. But in
+    # some situations, we want to make sure to operate on the PropertyTreeNode
+    # and not the PTNProxy. Both classes provide a ptn() method that always
+    # return the PropertyTreeNode.
+    def ptn
+      self
+    end
+
     # Adopt _property_ as a step child. Also register the new relationship
     # with the child.
     def adopt(property)
-      return if @adoptees.include?(property)
-
-      # The adopted node and the adopting node must not have any common
-      # ancestors.
-      if root == property.root
-        error('adopt_common_root',
-              "The adoptee #{property.fullId} and the parent #{fullId} " +
-              "may not share common ancestors.")
+      # A property cannot adopt itself.
+      if self == property
+        error('adopt_self', 'A property cannot adopt itself')
       end
 
-      # The adopted trees for this node must not overlap.
-      @adoptees.each do |adoptee|
-        # Check if the to be adopted node is an ancestor of an already adopted
-        # node.
-        if adoptee.ancestors.include?(property)
+      # A top level task must never contain the same leaf task more then once!
+      allOfRoot = root.all
+      property.allLeaves.each do |adoptee|
+        if allOfRoot.include?(adoptee)
           error('adopt_duplicate_child',
-                "The child #{adoptee.fullId} of #{property.fullId} " +
-                "has already been adopted by #{fullId}.")
-        end
-        # Check if the already adopted nodes are an ancestor of the to be
-        # adopted node.
-        if property.ancestors.include?(adoptee)
-          error('adopt_duplicate_parent',
-                "The parent #{adoptee.fullId} of #{property.fullId} " +
-                "has already been adopted by #{fullId}.")
+                "The task '#{adoptee.fullId}' has already been adopted by " +
+                "property '#{root.fullId}' or any of its sub-properties.")
         end
       end
 
@@ -177,7 +173,6 @@ class TaskJuggler
       return if @stepParents.include?(property)
 
       @stepParents << property
-      property.adopt(self)
     end
 
     # Return a list of all children including adopted kids.
@@ -202,6 +197,13 @@ class TaskJuggler
       @attributes, @scenarioAttributes = backup
     end
 
+    # Remove any references in the stored data that references the _property_.
+    def removeReferences(property)
+      @children.delete(property)
+      @adoptees.delete(property)
+      @stepParents.delete(property)
+    end
+
     # Return the index of the child _node_.
     def levelSeqNo(node)
       @children.index(node) + 1
@@ -258,7 +260,7 @@ class TaskJuggler
     # Returns a list of this node and all transient sub nodes.
     def all
       res = [ self ]
-      @children.each do |c|
+      kids.each do |c|
         res = res.concat(c.all)
       end
       res
@@ -266,11 +268,11 @@ class TaskJuggler
 
     # Return a list of all leaf nodes of this node.
     def allLeaves(withoutSelf = false)
+      res = []
       if leaf?
-        res = withoutSelf ? [] : [ self ]
+        res << self unless withoutSelf
       else
-        res = []
-        @children.each do |c|
+        kids.each do |c|
           res += c.allLeaves
         end
       end
@@ -553,8 +555,10 @@ class TaskJuggler
       journal = @project['journal']
       query.sortable = query.numerical = alert =
         journal.alertLevel(query.end, self, query.hideJournalEntry)
-      query.string = colorName = @project.alertLevelName(alert)
-      rText = "<fcol:#{colorName.downcase}>#{colorName}</fcol>"
+      alertLevel = @project['alertLevels'][alert]
+      query.string = alertLevel.name
+      rText = "<fcol:#{alertLevel.color}><nowiki>#{alertLevel.name}" +
+              "</nowiki></fcol>"
       unless (rti = RichText.new(rText, RTFHandlers.create(@project),
                                  @project.messageHandler).
                                  generateIntermediateFormat)
@@ -645,8 +649,8 @@ class TaskJuggler
     # provided by the class *Scenario classes. In case we can't find a function
     # called for the base class we try to find it in corresponding *Scenario
     # class.
-    def method_missing(func, scenarioIdx, *args)
-      @data[scenarioIdx].method(func).call(*args)
+    def method_missing(func, scenarioIdx, *args, &block)
+      @data[scenarioIdx].send(func, *args, &block)
     end
 
     def error(id, text)

data/lib/taskjuggler/Query.rb

@@ -3,7 +3,7 @@
 #
 # = Query.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify

data/lib/taskjuggler/RealFormat.rb

@@ -3,7 +3,7 @@
 #
 # = RealFormat.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -63,8 +63,10 @@ class TaskJuggler
         intNumber = '0' * (@fractionDigits - intNumber.length + 1) + intNumber
       end
       intPart = intNumber[0..-(@fractionDigits + 1)]
+      # Determinate the fractional part
       fracPart =
-        @fractionDigits > 0 ? '.' + intNumber[-(@fractionDigits)..-1] : ''
+        @fractionDigits > 0 ? @fractionSeparator +
+                              intNumber[-(@fractionDigits)..-1] : ''
 
       if @thousandsSeparator.empty?
         out = intPart

data/lib/taskjuggler/Resource.rb

@@ -3,7 +3,7 @@
 #
 # = Resource.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -37,8 +37,8 @@ class TaskJuggler
     # provided by the class ResourceScenario. In case we can't find a
     # function called for the Resource class we try to find it in
     # ResourceScenario.
-    def method_missing(func, scenarioIdx, *args)
-      @data[scenarioIdx].method(func).call(*args)
+    def method_missing(func, scenarioIdx, *args, &block)
+      @data[scenarioIdx].method(func).call(*args, &block)
     end
 
     def query_dashboard(query)

data/lib/taskjuggler/ResourceScenario.rb

@@ -3,7 +3,7 @@
 #
 # = ResourceScenario.rb -- The TaskJuggler III Project Management Software
 #
-# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011
+# Copyright (c) 2006, 2007, 2008, 2009, 2010, 2011, 2012
 #               by Chris Schlaeger <chris@linux.com>
 #
 # This program is free software; you can redistribute it and/or modify
@@ -24,13 +24,18 @@ class TaskJuggler
       # nil:        Value has not been determined yet.
       # Task:       A reference to a Task object
       # Bit 0:      Reserved
-      # Bit 1:      0: Work time
-      #             1: Off time
-      # Bit 2 - 5:  0: No vacation or leave time
-      #             1: Regular vacation
-      #             2 - 15: Reserved
-      # Bit 6:      Reserved
-      # Bit 7:      0: No global override
+      # Bit 1:      0: Work time (as defined by working hours)
+      #             1: No work time (as defined by working hours)
+      # Bit 2 - 5:  0: No holiday or leave time
+      #             1: Public holiday (holiday)
+      #             2: Annual leave
+      #             3: Special leave
+      #             4: Sick leave
+      #             5: unpaid leave
+      #             6: blocked for other projects
+      #             7 - 15: Reserved
+      # Bit 6 - 7:  Reserved
+      # Bit 8:      0: No global override
       #             1: Override global setting
       # The scoreboard is only created when needed to save memory for projects
       # which read-in the coporate employee database but only need a small
@@ -49,9 +54,9 @@ class TaskJuggler
       # Attributed are only really created when they are accessed the first
       # time. So make sure some needed attributes really exist so we don't
       # have to check for existance each time we access them.
-      %w( alloctdeffort criticalness directreports duties efficiency
+      %w( alloctdeffort chargeset criticalness directreports duties efficiency
           effort limits managers rate reports shifts
-          vacations workinghours ).each do |attr|
+          leaves leaveallowances workinghours ).each do |attr|
         @property[attr, @scenarioIdx]
       end
 
@@ -241,6 +246,26 @@ class TaskJuggler
       book(sbIdx, booking.task, true)
     end
 
+    # Compute the annual leave days within the period specified by the
+    # _query_. The result is in days.
+    def query_annualleave(query)
+      query.sortable = query.numerical = val =
+        getLeave(query.startIdx, query.endIdx, :annual)
+      query.string = query.scaleLoad(val)
+    end
+
+    def query_annualleavebalance(query)
+      if @property.leaf?
+        leave = getLeave(query.startIdx, query.endIdx, :annual)
+        allowanceSlots = @leaveallowances.balance(:annual, query.start,
+                                                  query.end)
+        allowance = @project.slotsToDays(allowanceSlots)
+        query.sortable = query.numerical = val = allowance - leave
+        query.string = query.scaleLoad(val)
+      end
+    end
+
+
     # Compute the cost generated by this Resource for a given Account during a
     # given interval.  If a Task is provided as scopeProperty only the turnover
     # directly assiciated with the Task is taken into account.
@@ -248,7 +273,7 @@ class TaskJuggler
       if query.costAccount
         query.sortable = query.numerical = cost =
           turnover(query.startIdx, query.endIdx, query.costAccount,
-                   query.scopeProperty)
+                   query.scopeProperty, true)
         query.string = query.currencyFormat.format(cost)
       else
         query.string = 'No \'balance\' defined!'
@@ -292,13 +317,31 @@ class TaskJuggler
         # probably don't need to compute this for every resource.
         globalWorkSlots = @project.getWorkSlots(query.startIdx, query.endIdx)
         workSlots = getWorkSlots(query.startIdx, query.endIdx)
-        fte = workSlots.to_f / globalWorkSlots if globalWorkSlots > 0
+        if globalWorkSlots > 0
+          fte = (workSlots.to_f / globalWorkSlots) * @efficiency
+        end
       end
 
       query.sortable = query.numerical = fte
       query.string = query.numberFormat.format(fte)
     end
 
+    # The headcount of the resource or group.
+    def query_headcount(query)
+      headcount = 0
+      if @property.container?
+        @property.kids.each do |resource|
+          resource.query_headcount(@scenarioIdx, query)
+          headcount += query.to_num
+        end
+      else
+        headcount += @efficiency.round
+      end
+
+      query.sortable = query.numerical = headcount
+      query.string = query.numberFormat.format(headcount)
+    end
+
     # Get the rate of the resource.
     def query_rate(query)
       query.sortable = query.numerical = r = rate
@@ -319,14 +362,77 @@ class TaskJuggler
       end
     end
 
-    # The work time of the Resource that was blocked by a vacation during the
+    # Compute the sick leave days within the period specified by the
+    # _query_. The result is in days.
+    def query_sickleave(query)
+      query.sortable = query.numerical = val =
+        getLeave(query.startIdx, query.endIdx, :sick)
+      query.string = query.scaleLoad(val)
+    end
+
+    # Compute the special leave days within the period specified by the
+    # _query_. The result is in days.
+    def query_specialleave(query)
+      query.sortable = query.numerical = val =
+        getLeave(query.startIdx, query.endIdx, :special)
+      query.string = query.scaleLoad(val)
+    end
+
+    # The work time of the Resource that was blocked by leaves during the
     # specified TimeInterval. The result is in working days (effort).
-    def query_vacationdays(query)
+    def query_timeoffdays(query)
       query.sortable = query.numerical = time =
-        getVacationDays(query.startIdx, query.endIdx)
+        getTimeOffDays(query.startIdx, query.endIdx)
       query.string = query.scaleLoad(time)
     end
 
+    # Compute the unpaid leave days within the period specified by the
+    # _query_. The result is in days.
+    def query_unpaidleave(query)
+      query.sortable = query.numerical = val =
+        getLeave(query.startIdx, query.endIdx, :unpaid)
+      query.string = query.scaleLoad(val)
+    end
+
+    # A generic tree iterator that recursively accumulates the result of the
+    # block for each leaf object.
+    def treeSum(startIdx, endIdx, *args, &block)
+      cacheTag = "#{self.class}.#{caller[0][/`.*'/][1..-2]}"
+      treeSumR(cacheTag, startIdx, endIdx, *args, &block)
+    end
+
+    # Recursing method for treeSum.
+    def treeSumR(cacheTag, startIdx, endIdx, *args, &block)
+      # Check if the value to be computed is already in the data cache. If so,
+      # return it. Otherwise we have to compute it first and then store it in
+      # the cache. We use the signature of the method that called treeSum()
+      # and its arguments together with 'self' as index to the cache.
+      @dCache.cached(self, cacheTag, startIdx, endIdx, *args) do
+        if @property.container?
+          sum = 0.0
+          # Iterate over all the kids and accumulate the result of the
+          # recursively called method.
+          @property.kids.each do |resource|
+            sum += resource.treeSumR(@scenarioIdx, cacheTag, startIdx, endIdx,
+                                     *args, &block)
+          end
+          sum
+        else
+          instance_eval(&block)
+        end
+      end
+    end
+
+    # Returns the number of leave days for the period described by _startIdx_
+    # and _endIdx_ for the given _type_ of leave.
+    def getLeave(startIdx, endIdx, type)
+      treeSum(startIdx, endIdx, type) do
+        @project.convertToDailyLoad(@project['scheduleGranularity'] *
+            getLeaveSlots(startIdx, endIdx, type))
+      end
+    end
+
+
     # Returns the work of the resource (and its children) weighted by their
     # efficiency.
     def getEffectiveWork(startIdx, endIdx, task = nil)
@@ -337,10 +443,6 @@ class TaskJuggler
       # The unique key we use to address the result in the cache.
       @dCache.cached(self, :ResourceScenarioEffectiveWork, startIdx, endIdx,
                      task) do
-        # Convert the interval dates to indexes if needed.
-        startIdx = @project.dateToIdx(startIdx) if startIdx.is_a?(TjTime)
-        endIdx = @project.dateToIdx(endIdx) if endIdx.is_a?(TjTime)
-
         work = 0.0
         if @property.container?
           @property.kids.each do |resource|
@@ -360,96 +462,66 @@ class TaskJuggler
 
     # Returns the allocated accumulated time of this resource and its children.
     def getAllocatedTime(startIdx, endIdx, task = nil)
-      # Convert the interval dates to indexes if needed.
-      startIdx = @project.dateToIdx(startIdx) if startIdx.is_a?(TjTime)
-      endIdx = @project.dateToIdx(endIdx) if endIdx.is_a?(TjTime)
-
-      time = 0
-      if @property.container?
-        @property.kids.each do |resource|
-          time += resource.getAllocatedTime(@scenarioIdx, startIdx, endIdx, task)
-        end
-      else
+      treeSum(startIdx, endIdx, task) do
         return 0 if @scoreboard.nil?
 
-        time = @project.convertToDailyLoad(@project['scheduleGranularity'] *
+        @project.convertToDailyLoad(@project['scheduleGranularity'] *
             getAllocatedSlots(startIdx, endIdx, task))
       end
-      time
     end
 
     # Return the unallocated work time (in seconds) of the resource and its
     # children.
     def getEffectiveFreeTime(startIdx, endIdx)
-      # Convert the interval dates to indexes if needed.
-      startIdx = @project.dateToIdx(startIdx) if startIdx.is_a?(TjTime)
-      endIdx = @project.dateToIdx(endIdx) if endIdx.is_a?(TjTime)
-
-      freeTime = 0
-      if @property.container?
-        @property.kids.each do |resource|
-          freeTime += resource.getEffectiveFreeTime(@scenarioIdx, startIdx,
-                                                    endIdx)
-        end
-      else
-        freeTime = getFreeSlots(startIdx, endIdx) *
-          @project['scheduleGranularity']
+      treeSum(startIdx, endIdx) do
+        getFreeSlots(startIdx, endIdx) * @project['scheduleGranularity']
       end
-      freeTime
     end
 
     # Return the unallocated work of the resource and its children weighted by
     # their efficiency.
     def getEffectiveFreeWork(startIdx, endIdx)
-      # Convert the interval dates to indexes if needed.
-      startIdx = @project.dateToIdx(startIdx) if startIdx.is_a?(TjTime)
-      endIdx = @project.dateToIdx(endIdx) if endIdx.is_a?(TjTime)
-
-      work = 0.0
-      if @property.container?
-        @property.kids.each do |resource|
-          work += resource.getEffectiveFreeWork(@scenarioIdx, startIdx, endIdx)
-        end
-      else
-        work = @project.convertToDailyLoad(
-                 getFreeSlots(startIdx, endIdx) *
-                 @project['scheduleGranularity']) * @efficiency
+      treeSum(startIdx, endIdx) do
+        @project.convertToDailyLoad(getFreeSlots(startIdx, endIdx) *
+                                    @project['scheduleGranularity']) *
+                                    @efficiency
       end
-      work
     end
 
-    # Return the number of working days that are blocked by vacations.
-    def getVacationDays(startIdx, endIdx)
-      # Convert the interval dates to indexes if needed.
-      startIdx = @project.dateToIdx(startIdx) if startIdx.is_a?(TjTime)
-      endIdx = @project.dateToIdx(endIdx) if endIdx.is_a?(TjTime)
-
-      vacationDays = 0.0
-      if @property.container?
-        @property.kids.each do |resource|
-          vacationDays += resource.getVacationDays(@scenarioIdx,
-                                                   startIdx, endIdx)
-        end
-      else
-        initScoreboard if @scoreboard.nil?
-
-        vacationDays = @project.convertToDailyLoad(
-          getVacationSlots(startIdx, endIdx) *
-          @project['scheduleGranularity']) * @efficiency
+    # Return the number of working days that are blocked by leaves.
+    def getTimeOffDays(startIdx, endIdx)
+      treeSum(startIdx, endIdx) do
+        @project.convertToDailyLoad(getTimeOffSlots(startIdx, endIdx) *
+                                    @project['scheduleGranularity']) *
+                                    @efficiency
       end
-      vacationDays
     end
 
-    def turnover(startIdx, endIdx, account, task = nil)
+    def turnover(startIdx, endIdx, account, task = nil, includeKids = false)
       amount = 0.0
-      if @property.container?
+      if @property.container? && includeKids
         @property.kids.each do |child|
-          amount += child.turnover(@scenarioIdx, startIdx, endIdx, account, task)
+          amount += child.turnover(@scenarioIdx, startIdx, endIdx, account,
+                                   task)
         end
       else
-        @duties.each do |duty|
-          amount += duty.turnover(@scenarioIdx, startIdx, endIdx, account,
+        if task
+          # If we have a know task, we only include the amount that is
+          # specific to this resource, this task and the chargeset of the
+          # task.
+          amount += task.turnover(@scenarioIdx, startIdx, endIdx, account,
                                   @property)
+        elsif !@chargeset.empty?
+          # If no tasks was provided, we include the amount of this resource,
+          # weighted by the charset of this resource.
+          totalResourceCost = cost(startIdx, endIdx)
+          @chargeset.each do |set|
+            set.each do |accnt, share|
+              if share > 0.0 && (accnt == account || accnt.isChildOf?(account))
+                amount += totalResourceCost * share
+              end
+            end
+          end
         end
       end
 
@@ -545,7 +617,7 @@ class TaskJuggler
     end
 
     # Return a list of scoreboard intervals that are at least _minDuration_ long
-    # and contain only off-duty and vacation slots. The result is an Array of
+    # and contain only off-duty and leave slots. The result is an Array of
     # [ start, end ] TjTime values.
     def collectTimeOffIntervals(iv, minDuration)
       # Time-off intervals are only useful for leaf resources. Group resources
@@ -581,107 +653,114 @@ class TaskJuggler
     # Count the number of slots betweend the _startIdx_ and _endIdx_ that can
     # be used for work
     def getWorkSlots(startIdx, endIdx)
-      return 0 if startIdx >= endIdx
-
-      initScoreboard unless @scoreboard
-
-      workSlots = 0
-      startIdx.upto(endIdx - 1) do |idx|
-        slot = @scoreboard[idx]
+      countSlots(startIdx, endIdx) do |val|
         # We count free slots and assigned slots.
-        workSlots += 1 if slot.nil? || slot.is_a?(Task)
+        val.nil? || val.is_a?(Task)
       end
+    end
 
-      workSlots
+    # Count the number of slots that are work time slots but marked as annual
+    # leave.
+    def getLeaveSlots(startIdx, endIdx, type)
+      countSlots(startIdx, endIdx) do |val|
+        val.is_a?(Fixnum) && (val & 0x3E) == (Leave::Types[type] << 2)
+      end
     end
 
     # Count the free slots between the start and end index.
     def getFreeSlots(startIdx, endIdx)
-      return 0 if startIdx >= endIdx
-
-      initScoreboard unless @scoreboard
-
-      freeSlots = 0
-      startIdx.upto(endIdx - 1) do |idx|
-        freeSlots += 1 if @scoreboard[idx].nil?
+      countSlots(startIdx, endIdx) do |val|
+        val.nil?
       end
-
-      freeSlots
     end
 
     # Count the regular work time slots between the start and end index that
-    # have been blocked by a vacation.
-    def getVacationSlots(startIdx, endIdx)
-      return 0 if startIdx >= endIdx
-
-      initScoreboard unless @scoreboard
-
-      vacationSlots = 0
-      startIdx.upto(endIdx - 1) do |idx|
-        val = @scoreboard[idx]
-        # Bit 1 needs to be unset and the vacation bits must not be 0.
-        vacationSlots += 1 if val.is_a?(Fixnum) && (val & 0x2) == 0 &&
-                                                   (val & 0x3C) != 0
+    # have been blocked by leaves.
+    def getTimeOffSlots(startIdx, endIdx)
+      countSlots(startIdx, endIdx) do |val|
+        # Bit 1 needs to be unset and the leave bits must not be 0.
+        val.is_a?(Fixnum) && (val & 0x2) == 0 && (val & 0x3C) != 0
       end
-      vacationSlots
     end
 
   private
 
     def initScoreboard
-      # Create scoreboard and mark all slots as unavailable
+      # Create scoreboard and mark all slots as non-working-time.
       @scoreboard = Scoreboard.new(@project['start'], @project['end'],
                                    @project['scheduleGranularity'], 2)
 
-      # We'll need this frequently and can savely cache it here.
-      @shifts = @shifts
-      @workinghours = @workinghours
-
       # Change all work time slots to nil (available) again.
       @project.scoreboardSize.times do |i|
         @scoreboard[i] = nil if onShift?(i)
       end
 
-      # Mark all resource specific vacation slots as such
-      @vacations.each do |vacation|
-        startIdx = @scoreboard.dateToIdx(vacation.start)
-        endIdx = @scoreboard.dateToIdx(vacation.end)
+      # Mark all global leave slots as such
+      @project['leaves'].each do |leave|
+        startIdx = @scoreboard.dateToIdx(leave.interval.start)
+        endIdx = @scoreboard.dateToIdx(leave.interval.end)
         startIdx.upto(endIdx - 1) do |i|
-          # If the slot is nil, we don't set the time-off bit.
-          @scoreboard[i] = (@scoreboard[i].nil? ? 0 : 2) | (1 << 2)
+          sb = @scoreboard[i]
+          # We preseve the work-time bit (#1).
+          @scoreboard[i] = (sb.nil? ? 0 : 2) | (leave.typeIdx << 2)
         end
       end
 
-      # Mark all global vacation slots as such
-      @project['vacations'].each do |vacation|
-        startIdx = @scoreboard.dateToIdx(vacation.start)
-        endIdx = @scoreboard.dateToIdx(vacation.end)
+      # Mark all resource specific leave slots as such
+      @leaves.each do |leave|
+        startIdx = @scoreboard.dateToIdx(leave.interval.start)
+        endIdx = @scoreboard.dateToIdx(leave.interval.end)
         startIdx.upto(endIdx - 1) do |i|
-          # If the slot is nil or set to 4 then don't set the time-off bit.
-          sb = @scoreboard[i]
-          @scoreboard[i] = ((sb.nil? || sb == 4) ? 0 : 2) | (1 << 2)
+          if (sb = @scoreboard[i])
+            # The slot is already marked as non-working slot. We override the
+            # leave type if the new type is larger than the old one.
+            leaveIdx = (sb & 0x3C) >> 2
+            if leave.typeIdx > leaveIdx
+              # The work-time bit (#1) is preserved.
+              @scoreboard[i] = (sb & 0x2) | (leave.typeIdx << 2)
+            end
+          else
+            # This marks a working time slot as a leave slot. Since bit 1 is
+            # not set, we still know that this could be a working slot.
+            @scoreboard[i] = leave.typeIdx << 2
+          end
         end
       end
 
       unless @shifts.nil?
-        # Mark the vacations from all the shifts the resource is assigned to.
+        # Mark the leaves from all the shifts the resource is assigned to.
         @project.scoreboardSize.times do |i|
           v = @shifts.getSbSlot(i)
-          # Check if the vacation replacement bit is set. In that case we copy
-          # the whole interval over to the resource scoreboard overriding any
-          # global vacations.
+          # Make sure a shift is actually assigned.
+          next unless v
+
           if (v & (1 << 8)) != 0
+            # Check if the leave replacement bit (#8) is set. In that case we
+            # copy the whole interval over to the resource scoreboard
+            # overriding any global leaves.
             @scoreboard[i] = (v & 0x3E == 0) ? nil : (v & 0x3D)
-          elsif ((sbV = @scoreboard[i]).nil? || (sbV & 0x3C) == 0) &&
+          elsif ((sb = @scoreboard[i]).nil? || ((sb & 0x3C) < (v & 0x3C))) &&
                 (v & 0x3C) != 0
-            # We only add the shift vacations but don't turn global vacation
-            # slots into working slots again.
+            # In merge mode, we only add the shift leaves with higher type
+            # index or unassigned slots.
             @scoreboard[i] = v & 0x3E
           end
         end
       end
     end
 
+    def countSlots(startIdx, endIdx)
+      return 0 if startIdx >= endIdx
+
+      initScoreboard unless @scoreboard
+
+      slots = 0
+      startIdx.upto(endIdx - 1) do |idx|
+        slots += 1 if yield(@scoreboard[idx])
+      end
+      slots
+    end
+
     # Limit the _startIdx_ and _endIdx_ to the actually assigned interval.
     # If _task_ is provided, fit it for the bookings of this particular task.
     def fitIndicies(startIdx, endIdx, task = nil)