k/koffice-trinity/koffice-trinity-doc_14.1.6-0ubuntu26.04.0+0.3_all.deb

/* 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

KPlato::Account
Account holds one account.
Definition kptaccount.h:49

KPlato::Appointment
A resource (Resource) can be scheduled to be used at any time, this is represented internally with Ap...
Definition kptappointment.h:126

KPlato::DateTime
DateTime is a TQDateTime which knows about Duration.
Definition kptdatetime.h:33

KPlato::Duration
The duration class can be used to store a timespan in a convenient format.
Definition kptduration.h:34

KPlato::Duration::zeroDuration
static const Duration zeroDuration
This is useful for occasions where we need a zero duration.
Definition kptduration.h:126

KPlato::Effort
Any Node will store how much time it takes to complete the node (typically a Task) in the traditional...
Definition kptnode.h:556

KPlato::Effort::zeroEffort
static const Effort zeroEffort
No effort.
Definition kptnode.h:618

KPlato::Effort::pessimisticRatio
int pessimisticRatio() const
Return the "pessimistic" duration as the deviation from "expected" in percent.
Definition kptnode.cpp:937

KPlato::Effort::setOptimisticRatio
void setOptimisticRatio(int percent)
Set the optimistic duration.
Definition kptnode.cpp:920

KPlato::Effort::optimisticRatio
int optimisticRatio() const
Return the "optimistic" duration as deviation from "expected" in percent.
Definition kptnode.cpp:926

KPlato::Effort::setPessimisticRatio
void setPessimisticRatio(int percent)
Set the pessimistic duration.
Definition kptnode.cpp:932

KPlato::Node::addDependChildNode
virtual void addDependChildNode(Node *node, Relation::Type p=Relation::FinishStart)
Adds relation to both this node and address node.
Definition kptnode.cpp:183

KPlato::Node::takeDependParentNode
void takeDependParentNode(Relation *rel)
Takes the relation rel from this node only.
Definition kptnode.cpp:295

KPlato::Node::takeDependChildNode
void takeDependChildNode(Relation *rel)
Takes the relation rel from this node only.
Definition kptnode.cpp:236

KPlato::Node::getExpectedDuration
virtual Duration * getExpectedDuration()=0
Returns the (previously) calculated duration.

KPlato::Node::findSchedule
Schedule * findSchedule(const TQString name, const Schedule::Type type) const
Find schedule matching name and type. Does not return deleted schedule.
Definition kptnode.cpp:688

KPlato::Node::createSchedule
Schedule * createSchedule(TQString name, Schedule::Type type, long id)
Create a new schedule.
Definition kptnode.cpp:674

KPlato::Node::insertDependChildNode
virtual void insertDependChildNode(unsigned int index, Node *node, Relation::Type p=Relation::FinishStart)
Inserts relation to this node at index address index and appends relation to address node.
Definition kptnode.cpp:195

KPlato::Node::actualCostTo
virtual double actualCostTo(const TQDate &)
Actual cost up to and including date.
Definition kptnode.h:317

KPlato::Node::level
virtual int level()
Returns the level this node is in the hierarchy. Top node is level 0.
Definition kptnode.cpp:753

KPlato::Node::actualEffort
virtual Duration actualEffort()
Returns the total actual effort for this task (or subtasks).
Definition kptnode.h:290

KPlato::Node::getLatestFinish
DateTime getLatestFinish() const
getLatestFinish() returns latest time this node can finish
Definition kptnode.h:221

KPlato::Node::appointments
TQPtrList< Appointment > appointments()
Return the list of appointments for current schedule.
Definition kptnode.cpp:624

KPlato::Node::findNode
virtual Node * findNode() const
Find the node with my id.
Definition kptnode.h:399

KPlato::Node::plannedCost
virtual double plannedCost(const TQDate &)
Planned cost on date.
Definition kptnode.h:303

KPlato::Node::plannedCost
virtual double plannedCost()
Planned cost is the sum total of all resources and other costs planned for this node.
Definition kptnode.h:300

KPlato::Node::plannedEffortTo
virtual Duration plannedEffortTo(const TQDate &)
Returns the planned effort up to and including date.
Definition kptnode.h:287

KPlato::Node::actualCost
virtual double actualCost(const TQDate &)
Actual cost on date.
Definition kptnode.h:315

KPlato::Node::saveAppointments
virtual void saveAppointments(TQDomElement &element, long id) const
Save appointments for schedule with id.
Definition kptnode.cpp:616

KPlato::Node::takeSchedule
void takeSchedule(const Schedule *schedule)
Take, don't delete (as in destruct).
Definition kptnode.cpp:660

KPlato::Node::removeId
virtual bool removeId()
Remove myself from the id register.
Definition kptnode.h:404

KPlato::Node::costPerformanceIndex
double costPerformanceIndex(const TQDate &, bool *)
Cost performance index.
Definition kptnode.h:322

KPlato::Node::overbookedResources
virtual TQStringList overbookedResources() const
Return a list of overbooked resources.
Definition kptnode.cpp:383

KPlato::Node::setParentSchedule
virtual void setParentSchedule(Schedule *sch)
Set parent schedule recursivly.
Definition kptnode.cpp:718

KPlato::Node::legalToLink
virtual bool legalToLink(Node *, Node *)
Check if node par can be linked to node child. (Reimplement).
Definition kptnode.h:374

KPlato::Node::m_constraintEndTime
DateTime m_constraintEndTime
m_constraintEndTime is used if any of the constraints FixedInterval, FinishNotLater,...
Definition kptnode.h:517

KPlato::Node::removeId
virtual bool removeId(const TQString &id)
Remove the registered identity id.
Definition kptnode.h:406

KPlato::Node::saveRelations
virtual void saveRelations(TQDomElement &element) const
Save my and my childrens relations.
Definition kptnode.cpp:387

KPlato::Node::legalToLink
bool legalToLink(Node *node)
Check if this node can be linked to node.
Definition kptnode.cpp:559

KPlato::Node::insertId
virtual void insertId(const TQString &id, const Node *node)
Insert node with identity id into the register.
Definition kptnode.h:411

KPlato::Node::actualCost
virtual double actualCost()
Actual cost is the sum total of the reported costs actually used for this node.
Definition kptnode.h:313

KPlato::Node::workStartTime
virtual DateTime workStartTime() const
This is when work can start on this node in accordance with the calendar of allocated resources.
Definition kptnode.h:419

KPlato::Node::addSchedule
void addSchedule(Schedule *schedule)
Add schedule to list, replace if schedule with same id allready exists.
Definition kptnode.cpp:668

KPlato::Node::setCurrentSchedule
virtual void setCurrentSchedule(long id)
Set current schedule to schedule with identity id, for me and my children.
Definition kptnode.cpp:769

KPlato::Node::effortPerformanceIndex
double effortPerformanceIndex(const TQDate &, bool *)
Effort based performance index.
Definition kptnode.h:320

KPlato::Node::plannedCostTo
virtual double plannedCostTo(const TQDate &)
Planned cost from start of activity up to and including date is the sum of all resource costs and oth...
Definition kptnode.h:308

KPlato::Node::setLatestFinish
void setLatestFinish(const DateTime &dt)
setLatestFinish() sets latest time this node can finish given the constraints of the network.
Definition kptnode.h:228

KPlato::Node::resourceOverbooked
virtual bool resourceOverbooked() const
The assigned resource is overbooked.
Definition kptnode.h:263

KPlato::Node::m_constraintStartTime
DateTime m_constraintStartTime
m_constraintTime is used if any of the constraints FixedInterval, StartNotEarlier,...
Definition kptnode.h:512

KPlato::Node::startTime
virtual DateTime startTime() const
Return the scheduled start time.
Definition kptnode.h:174

KPlato::Node::projectNode
virtual Node * projectNode()
Returns a pointer to the project node (main- or sub-project) Returns 0 if no project exists.
Definition kptnode.cpp:109

KPlato::Node::insertDependParentNode
virtual void insertDependParentNode(unsigned int index, Node *node, Relation::Type p=Relation::FinishStart)
Inserts relation to this node at index and appends relation to node.
Definition kptnode.cpp:254

KPlato::Node::notScheduled
bool notScheduled() const
The node has not been scheduled.
Definition kptnode.h:277

KPlato::Node::insertId
virtual void insertId(const TQString &id)
Insert myself into the id register.
Definition kptnode.h:409

KPlato::Node::resourceNotAvailable
bool resourceNotAvailable() const
The requested resource is not available.
Definition kptnode.h:271

KPlato::Node::getRandomDuration
virtual Duration * getRandomDuration()=0
Instead of using the expected duration, generate a random value using the Distribution of each Task.

KPlato::Node::endTime
virtual DateTime endTime() const
Return the scheduled end time.
Definition kptnode.h:179

KPlato::Node::getDelay
Duration * getDelay()
Calculate the delay of this node.
Definition kptnode.cpp:176

KPlato::Node::calcResourceOverbooked
virtual void calcResourceOverbooked()
Calculates if the assigned resource is overbooked within the duration of this node.
Definition kptnode.cpp:376

KPlato::Node::workEndTime
virtual DateTime workEndTime() const
This is when work can finish on this node in accordance with the calendar of allocated resources.
Definition kptnode.h:429

KPlato::Node::actualEffortTo
virtual Duration actualEffortTo(const TQDate &)
Returns the total actual effort for this task (or subtasks) up to and including date.
Definition kptnode.h:294

KPlato::Node::addDependParentNode
virtual void addDependParentNode(Node *node, Relation::Type p=Relation::FinishStart)
Adds relation to both this node and node.
Definition kptnode.cpp:242

KPlato::Node::addAppointment
virtual bool addAppointment(Appointment *appointment)
Return appointment this node have with resource.
Definition kptnode.cpp:636

KPlato::Node::isStartNode
virtual bool isStartNode() const
Check if this node has any dependent parent nodes.
Definition kptnode.cpp:569

KPlato::Node::resourceError
bool resourceError() const
EffortType == Effort, but no resource is requested.
Definition kptnode.h:260

KPlato::Node::getEarliestStart
DateTime getEarliestStart() const
getEarliestStart() returns earliest time this node can start given the constraints of the network.
Definition kptnode.h:209

KPlato::Node::actualEffort
virtual Duration actualEffort(const TQDate &)
Returns the total actual effort for this task (or subtasks) on date.
Definition kptnode.h:292

KPlato::Node::findSchedule
Schedule * findSchedule(long id) const
Find schedule matching id. Also returns deleted schedule.
Definition kptnode.h:472

KPlato::Node::plannedEffort
virtual Duration plannedEffort()
Returns the total planned effort for this task (or subtasks).
Definition kptnode.h:283

KPlato::Node::schedulingError
virtual bool schedulingError() const
The task cannot be scheduled to fullfill all the constraints.
Definition kptnode.h:274

KPlato::Node::plannedEffort
virtual Duration plannedEffort(const TQDate &)
Returns the total planned effort for this task (or subtasks) on date.
Definition kptnode.h:285

KPlato::Node::findNode
virtual Node * findNode(const TQString &id) const
Find the node with identity id.
Definition kptnode.h:401

KPlato::Node::setScheduleDeleted
void setScheduleDeleted(long id, bool onoff)
Set deleted = onoff for schedule with id.
Definition kptnode.cpp:709

KPlato::Node::isEndNode
virtual bool isEndNode() const
Check if this node has any dependent child nodes.
Definition kptnode.cpp:566

KPlato::Node::generateWBS
virtual void generateWBS(int count, WBSDefinition &def, TQString wbs=TQString())
Generate WBS.
Definition kptnode.cpp:758

KPlato::Node::setEarliestStart
void setEarliestStart(const DateTime &dt)
setEarliestStart() sets earliest time this node can start
Definition kptnode.h:215

KPlato::Project
Project is the main node in a project, it contains child nodes and possibly sub-projects.
Definition kptproject.h:52

KPlato::Relation
The relation class couples a 2 nodes together which are dependent on each other.
Definition kptrelation.h:45

KPlato::ResourceGroup
This class represents a group of similar resources to be assigned to a task e.g.
Definition kptresource.h:66

KPlato::Resource
Any resource that is used by a task.
Definition kptresource.h:187

KPlato::Schedule
The Schedule class holds data calculated during project calculation and scheduling,...
Definition kptschedule.h:55

KPlato::Schedule::startTime
DateTime startTime
startTime is the scheduled start time.
Definition kptschedule.h:195

KPlato::Schedule::endTime
DateTime endTime
m_endTime is the scheduled finish time.
Definition kptschedule.h:201