kptnode.h

/* This file is part of the KDE project
   Copyright (C) 2001 Thomas Zander zander@kde.org
   Copyright (C) 2004, 2005 Dag Andersen <danders@get2net.dk>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
 
#ifndef KPTNODE_H
#define KPTNODE_H
 
#include "kptrelation.h"
#include "kptduration.h"
#include "kptdatetime.h"
#include "kptschedule.h"
 
#include <tqintdict.h>
#include <tqrect.h>
#include <tqptrlist.h>
#include <tqstring.h>
#include <tqcanvas.h>
 
#include <vector>
 
class TQDomElement;
 
namespace KPlato
{
 
class Account;
class Project;
class Appointment;
class ResourceGroup;
class Resource;
class ResourceGroupRequest;
class Effort;
class WBSDefinition;
class EffortCostMap;
 
class Node {
 
public:
    enum ConstraintType { ASAP, ALAP, MustStartOn, MustFinishOn, StartNotEarlier, FinishNotLater, FixedInterval };
 
    Node(Node *parent = 0);
    Node(Node &node, Node *parent = 0);
 
 
    // Declare the class abstract
    virtual ~Node() = 0;
 
    bool setId(TQString id);
    TQString id() const { return m_id; } // unique identity
    
    enum NodeTypes {
      Type_Node = 0,
      Type_Project = 1,
      Type_Subproject = 2,
      Type_Task = 3,
      Type_Milestone = 4,
      Type_Periodic = 5,
      Type_Summarytask = 6
    };
 
    virtual int type() const = 0;
 
    virtual Node *projectNode();
    
    // The load and save methods
    virtual bool load(TQDomElement &) { return true; }
    virtual bool load(TQDomElement &, Project &) { return true; }
    virtual void save(TQDomElement &element) const  = 0;
    virtual void saveRelations(TQDomElement &element) const;
 
    // simple child node management
    // Child nodes are things like subtasks, basically a task can exists of
    // several sub-tasks. Creating a table has 4 subtasks, 1) measuring
    // 2) cutting 3) building 4) painting.
    Node *getParent() const { return m_parent; }
    void setParent( Node* newParent ) { m_parent = newParent;}
    const TQPtrList<Node> &childNodeIterator() const { return m_nodes; }
    int numChildren() const { return m_nodes.count(); }
    virtual void addChildNode(Node *node, Node *after=0);
    virtual void insertChildNode(unsigned int index, Node *node);
    void delChildNode(Node *node, bool remove=true);
    void delChildNode(int number, bool remove=true);
    Node* getChildNode(int number) { return m_nodes.at(number); }
    const Node* getChildNode(int number) const;
    int findChildNode( Node* node );
 
    // Time-dependent child-node-management.
    // list all nodes that are dependent upon this one.
    // Building a house requires the table to be finished, therefore the
    // house-building is time dependent on the table-building. So a child
    // of the table-building node is the house-building node.
 
    int numDependChildNodes() const { return m_dependChildNodes.count(); }
    virtual void addDependChildNode( Node *node, Relation::Type p=Relation::FinishStart);
    virtual void addDependChildNode( Node *node, Relation::Type p, Duration lag);
    virtual bool addDependChildNode( Relation *relation);
    virtual void insertDependChildNode( unsigned int index, Node *node, Relation::Type p=Relation::FinishStart);
    void delDependChildNode( Node *node, bool remove=false);
    void delDependChildNode( Relation *rel, bool remove=false);
    void delDependChildNode( int number, bool remove=false);
    Relation *getDependChildNode( int number) {
    return m_dependChildNodes.at(number);
    }
    TQPtrList<Relation> &dependChildNodes() { return m_dependChildNodes; }
 
    void takeDependChildNode(Relation *rel);
    
    int numDependParentNodes() const { return m_dependParentNodes.count(); }
    virtual void addDependParentNode(Node *node, Relation::Type p=Relation::FinishStart);
    virtual void addDependParentNode( Node *node, Relation::Type p, Duration lag);
    virtual bool addDependParentNode( Relation *relation);
    virtual void insertDependParentNode( unsigned int index, Node *node, Relation::Type p=Relation::FinishStart);
    void delDependParentNode( Node *node, bool remove=false);
    void delDependParentNode( Relation *rel, bool remove=false);
    void delDependParentNode( int number, bool remove=false);
    Relation *getDependParentNode( int number) {
    return m_dependParentNodes.at(number);
    }
    TQPtrList<Relation> &dependParentNodes() { return m_dependParentNodes; }
    
    void takeDependParentNode(Relation *rel);
 
    bool isParentOf(Node *node);
    bool isDependChildOf(Node *node);
 
    Relation *findParentRelation(Node *node);
    Relation *findChildRelation(Node *node);
    Relation *findRelation(Node *node);
 
    void setStartTime(DateTime startTime);
    virtual DateTime startTime() const
        { return m_currentSchedule ? m_currentSchedule->startTime : DateTime(); }
    const TQDate &startDate() const { return m_dateOnlyStartDate; }
    void setEndTime(DateTime endTime);
    virtual DateTime endTime() const
        { return m_currentSchedule ? m_currentSchedule->endTime : DateTime(); }
    const TQDate &endDate() const { return m_dateOnlyEndDate; }
 
    void setEffort(Effort* e) { m_effort = e; }
    Effort* effort() const { return m_effort; }
 
    virtual Duration *getExpectedDuration() = 0;
 
    virtual Duration *getRandomDuration() = 0;
 
    Duration *getDelay();
 
    DateTime getEarliestStart() const
        { return m_currentSchedule ? m_currentSchedule->earliestStart : DateTime(); }
    void setEarliestStart(const DateTime &dt) 
        { if (m_currentSchedule) m_currentSchedule->earliestStart = dt; }
    DateTime getLatestFinish() const 
        { return m_currentSchedule ? m_currentSchedule->latestFinish : DateTime(); }
    void setLatestFinish(const DateTime &dt) 
        { if (m_currentSchedule) m_currentSchedule->latestFinish = dt; }
 
    TQString &name() { return m_name; }
    TQString &leader() { return m_leader; }
    TQString &description() { return m_description; }
    const TQString &name() const { return m_name; }
    const TQString &leader() const { return m_leader; }
    const TQString &description() const { return m_description; }
    void setName(const TQString &n) { m_name = n; }
    void setLeader(const TQString &l) { m_leader = l; }
    void setDescription(const TQString &d) { m_description = d; }
 
    virtual void setConstraint(Node::ConstraintType type) { m_constraint = type; }
    void setConstraint(TQString &type);
    int constraint() const { return m_constraint; }
    TQString constraintToString() const;
 
    virtual void setConstraintStartTime(TQDateTime time) { m_constraintStartTime = time; }
    virtual void setConstraintEndTime(TQDateTime time) { m_constraintEndTime = time; }
 
    virtual DateTime constraintStartTime() const { return m_constraintStartTime; }
    virtual DateTime constraintEndTime() const { return m_constraintEndTime; }
    virtual DateTime startNotEarlier() const { return m_constraintStartTime; }
    virtual DateTime finishNotLater() const { return m_constraintEndTime; }
    virtual DateTime mustStartOn() const { return m_constraintStartTime; }
    virtual DateTime mustFinishOn() const { return m_constraintEndTime; }
 
    virtual ResourceGroupRequest *resourceRequest(ResourceGroup */*group*/) const { return 0; }
    virtual void makeAppointments();
 
    bool resourceError() const 
        { return m_currentSchedule ? m_currentSchedule->resourceError : false; }
    virtual bool resourceOverbooked() const
        { return m_currentSchedule ? m_currentSchedule->resourceOverbooked : false; }
    virtual TQStringList overbookedResources() const;
    virtual void calcResourceOverbooked();
    bool resourceNotAvailable() const
        { return m_currentSchedule ? m_currentSchedule->resourceNotAvailable : false; }
    virtual bool schedulingError() const
        { return m_currentSchedule ? m_currentSchedule->schedulingError : false; }
    bool notScheduled() const
        { return m_currentSchedule == 0 || m_currentSchedule->isDeleted() || m_currentSchedule->notScheduled; }
    
    virtual EffortCostMap plannedEffortCostPrDay(const TQDate &start, const TQDate &end) const=0;
        
    virtual Duration plannedEffort() { return Duration::zeroDuration; }
    virtual Duration plannedEffort(const TQDate &) { return Duration::zeroDuration; }
    virtual Duration plannedEffortTo(const TQDate &) { return Duration::zeroDuration; }
    
    virtual Duration actualEffort() { return Duration::zeroDuration; }
    virtual Duration actualEffort(const TQDate &/*date*/) { return Duration::zeroDuration; }
    virtual Duration actualEffortTo(const TQDate &/*date*/) { return Duration::zeroDuration; }
    
    virtual double plannedCost() { return 0; }
    
    virtual double plannedCost(const TQDate &/*date*/) { return 0; }
    virtual double plannedCostTo(const TQDate &/*date*/) { return 0; }
    virtual double actualCost() { return 0; }
    virtual double actualCost(const TQDate &/*date*/) { return 0; }
    virtual double actualCostTo(const TQDate &/*date*/) { return 0; }
    
    double effortPerformanceIndex(const TQDate &/*date*/, bool */*error=0*/) { return 0.0; }
    double costPerformanceIndex(const TQDate &/*date*/, bool */*error=0*/) { return 0.0; }
    
    virtual void initiateCalculationLists(TQPtrList<Node> &startnodes, TQPtrList<Node> &endnodes, TQPtrList<Node> &summarytasks) = 0;
    virtual DateTime calculateForward(int /*use*/) = 0;
    virtual DateTime calculateBackward(int /*use*/) = 0;
    virtual DateTime scheduleForward(const DateTime &, int /*use*/) = 0;
    virtual DateTime scheduleBackward(const DateTime &, int /*use*/) = 0;
    virtual void adjustSummarytask() = 0;
 
    virtual void initiateCalculation(Schedule &sch);
    virtual void resetVisited();
    void propagateEarliestStart(DateTime &time);
    void propagateLatestFinish(DateTime &time);
    void moveEarliestStart(DateTime &time);
    void moveLatestFinish(DateTime &time);
    // Reimplement this
    virtual Duration summarytaskDurationForward(const DateTime &/*time*/) 
        { return Duration::zeroDuration; }
    // Reimplement this
    virtual DateTime summarytaskEarliestStart() 
        { return DateTime(); }
    // Reimplement this
    virtual Duration summarytaskDurationBackward(const DateTime &/*time*/) 
        { return Duration::zeroDuration; }
    // Reimplement this
    virtual DateTime summarytaskLatestFinish() 
        { return DateTime(); }
    // Returns the (previously) calculated duration
    const Duration &duration()
        { return m_currentSchedule ? m_currentSchedule->duration : Duration::zeroDuration; }
    Duration duration(const DateTime &time, int use, bool backward);
    // Reimplement this
    virtual Duration calcDuration(const DateTime &/*time*/, const Duration &/*effort*/, bool /*backward*/) { return Duration::zeroDuration;}
 
    Node *siblingBefore();
    Node *childBefore(Node *node);
    Node *siblingAfter();
    Node *childAfter(Node *node);
    bool moveChildUp(Node *node);
    bool moveChildDown(Node *node);
    
    bool legalToLink(Node *node);
    virtual bool legalToLink(Node *, Node *) { return false; }
    virtual bool isEndNode() const;
    virtual bool isStartNode() const;
    virtual void clearProxyRelations() {}
    virtual void addParentProxyRelations(TQPtrList<Relation> &) {}
    virtual void addChildProxyRelations(TQPtrList<Relation> &) {}
    virtual void addParentProxyRelation(Node *, const Relation *) {}
    virtual void addChildProxyRelation(Node *, const Relation *) {}
 
    virtual void saveAppointments(TQDomElement &element, long id) const;
    TQPtrList<Appointment> appointments();
//    Appointment *findAppointment(Resource *resource);
    virtual bool addAppointment(Appointment *appointment);
    virtual bool addAppointment(Appointment *appointment, Schedule &main);
    virtual void addAppointment(ResourceSchedule *resource, DateTime &start, DateTime &end, double load=100);
    
    virtual Node *findNode() const { return findNode(m_id); }
    virtual Node *findNode(const TQString &id) const
        { return (m_parent ? m_parent->findNode(id) : 0); }
    virtual bool removeId()  { return removeId(m_id); }
    virtual bool removeId(const TQString &id)
        { return (m_parent ? m_parent->removeId(id) : false); }
    virtual void insertId(const TQString &id) { insertId(id, this); }
    virtual void insertId(const TQString &id, const Node *node)
        { if (m_parent) m_parent->insertId(id, node); }
    
    virtual DateTime workStartTime() const
        { return m_currentSchedule ? m_currentSchedule->workStartTime : DateTime(); }
    void setWorkStartTime(const DateTime &dt) 
        { if (m_currentSchedule) m_currentSchedule->workStartTime = dt; }
    
    virtual DateTime workEndTime() const 
        { return m_currentSchedule ? m_currentSchedule->workEndTime : DateTime(); }
    void setWorkEndTime(const DateTime &dt) 
        { if (m_currentSchedule) m_currentSchedule->workEndTime = dt; }
    
    virtual bool isCritical() const { return false; }
    virtual bool inCriticalPath() const
        { return m_currentSchedule ? m_currentSchedule->inCriticalPath : false; }
    virtual bool calcCriticalPath(bool fromEnd);
    
    virtual int level();
    virtual void generateWBS(int count, WBSDefinition &def, TQString wbs=TQString());
    TQString wbs() const { return m_wbs; }
    
    double startupCost() const { return m_startupCost; }
    void setStartupCost(double cost) { m_startupCost = cost; }
    
    Account *startupAccount() const { return m_startupAccount; }
    void setStartupAccount(Account *acc) { m_startupAccount = acc; }
    
    double shutdownCost() const { return m_shutdownCost; }
    void  setShutdownCost(double cost) { m_shutdownCost = cost; }
    
    Account *shutdownAccount() const { return m_shutdownAccount; }
    void setShutdownAccount(Account *acc) { m_shutdownAccount = acc; }
    
    Account *runningAccount() const { return m_runningAccount; }
    void setRunningAccount(Account *acc) { m_runningAccount = acc; }
 
    Schedule *currentSchedule() const { return m_currentSchedule; }
    virtual void setCurrentSchedule(long id);
    // NOTE: Cannot use setCurrentSchedule() due to overload/casting problems
    void setCurrentSchedulePtr(Schedule *schedule) { m_currentSchedule = schedule; }
    
    TQIntDict<Schedule> &schedules() { return m_schedules; }
    Schedule *findSchedule(const TQString name, const Schedule::Type type) const;
    Schedule *findSchedule(const Schedule::Type type) const;
    Schedule *findSchedule(long id) const { return m_schedules[id]; }
    void takeSchedule(const Schedule *schedule);
    void addSchedule(Schedule *schedule);
    Schedule *createSchedule(TQString name, Schedule::Type type, long id);
    Schedule *createSchedule(Schedule *parent);
    
    void setScheduleDeleted(long id, bool onoff);
    virtual void setParentSchedule(Schedule *sch);
    
    DateTime startTime()
        { return m_currentSchedule ? m_currentSchedule->startTime : DateTime(); }
    DateTime endTime()
        { return m_currentSchedule ? m_currentSchedule->endTime : DateTime(); }
 
protected:
    TQPtrList<Node> m_nodes;
    TQPtrList<Relation> m_dependChildNodes;
    TQPtrList<Relation> m_dependParentNodes;
    Node *m_parent;
 
    TQString m_id; // unique id
    TQString m_name;        // Name of this node
    TQString m_leader;      // Person or group responsible for this node
    TQString m_description; // Description of this node
 
    Effort* m_effort;
    
 
    ConstraintType m_constraint;
 
    DateTime m_constraintStartTime;
    DateTime m_constraintEndTime;
 
    bool m_visitedForward;
    bool m_visitedBackward;
    Duration m_durationForward;
    Duration m_durationBackward;
    
    TQDate m_dateOnlyStartDate;
    TQDate m_dateOnlyEndDate;
    Duration m_dateOnlyDuration;
 
    TQIntDict<Schedule> m_schedules;
    Schedule *m_currentSchedule;
 
    TQString m_wbs;
    
    double m_startupCost;
    Account *m_startupAccount;
    double m_shutdownCost;
    Account *m_shutdownAccount;
    Account *m_runningAccount;
    
private:
    void init();
        
#ifndef NDEBUG
public:
    virtual void printDebug(bool children, TQCString indent);
#endif
 
};
 
 
class Effort {
public:
    Effort ( Duration e = Duration::zeroDuration, Duration p = Duration::zeroDuration,
        Duration o = Duration::zeroDuration );
 
    Effort ( double e, double p = 0, double o = 0);
    
    Effort (const Effort &effort);
    ~Effort();
 
    enum Type { Type_Effort = 0,        // Changing amount of resources changes the task duration
                          Type_FixedDuration = 1     // Changing amount of resources will not change the tasks duration
     };
    Type type() const { return m_type; }
    void setType(Type type) { m_type = type; }
    void setType(TQString type);
    TQString typeToString() const;
    
    enum Risktype { Risk_None, Risk_Low, Risk_High };
    Risktype risktype() const { return m_risktype; }
    void setRisktype(Risktype type) { m_risktype = type; }
    void setRisktype(TQString type);
    TQString risktypeToString() const;
 
    enum Use { Use_Expected=0, Use_Optimistic=1, Use_Pessimistic=2 };
    Duration effort(int use) const;
    const Duration& optimistic() const {return m_optimisticEffort;}
    const Duration& pessimistic() const {return m_pessimisticEffort;}
    const Duration& expected() const {return m_expectedEffort;}
 
    void set( Duration e, Duration p = Duration::zeroDuration, Duration o = Duration::zeroDuration );
    void set( int e, int p = -1, int o = -1 );
    void set(unsigned days, unsigned hours, unsigned minutes);
    void expectedEffort(unsigned *days, unsigned *hours, unsigned *minutes);
 
    bool load(TQDomElement &element);
    void save(TQDomElement &element) const;
 
    void setOptimisticRatio(int percent);
    int optimisticRatio() const;
    void setPessimisticRatio(int percent);
    int pessimisticRatio() const;
 
    static const Effort zeroEffort;
 
    Duration variance() const;
    Duration pertExpected() const;
    Duration pertOptimistic() const;
    Duration pertPessimistic() const;
 
private:
    Duration m_optimisticEffort;
    Duration m_pessimisticEffort;
    Duration m_expectedEffort;
 
    Type m_type;
    Risktype m_risktype;
    
#ifndef NDEBUG
public:
    void printDebug(TQCString indent);
#endif
 
};
 
}  //KPlato namespace
 
#endif