kptproject.h

/* This file is part of the KDE project
   Copyright (C) 2001 Thomas Zander zander@kde.org
   Copyright (C) 2004 - 2006 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 KPTPROJECT_H
#define KPTPROJECT_H
 
#include "kptnode.h"
 
#include "kptaccount.h"
#include "kptcalendar.h"
#include "kptdatetime.h"
#include "kptduration.h"
#include "kptresource.h"
 
#include <tqmap.h>
#include <tqptrlist.h>
#include <tqdict.h>
 
#include <tdelistview.h>
#include <tdelocale.h>
 
namespace KPlato
{
 
class Part;
class Schedule;
class StandardWorktime;
 
//#define DEBUGPERT
class Project : public Node {
public:
    Project(Node *parent = 0);
    ~Project();
 
    virtual int type() const;
 
    void calculate(Schedule *scedule);
    void calculate(Effort::Use use);
    void calculate();
     
    virtual bool calcCriticalPath(bool fromEnd);
    
    virtual DateTime startTime() const;
    virtual DateTime endTime() const;
 
    Duration *getExpectedDuration();
 
    Duration *getRandomDuration();
 
    virtual bool load(TQDomElement &element);
    virtual void save(TQDomElement &element) const;
 
    TQPtrList<ResourceGroup> &resourceGroups();
    virtual void addResourceGroup(ResourceGroup *resource);
    virtual void insertResourceGroup(unsigned int index, ResourceGroup *resource);
    void removeResourceGroup(ResourceGroup *resource);
    void removeResourceGroup(int number);
    ResourceGroup *takeResourceGroup(ResourceGroup *resource)
        { return m_resourceGroups.take(m_resourceGroups.findRef(resource)); }
 
    bool addTask( Node* task, Node* position );
    bool addSubTask( Node* task, Node* position );
    bool addSubTask( Node* task, int index, Node* parent );
    void delTask(Node *node);
    bool canIndentTask(Node* node);
    bool indentTask( Node* node );
    bool canUnindentTask( Node* node );
    bool unindentTask( Node* node );
    bool canMoveTaskUp( Node* node );
    bool moveTaskUp( Node* node );
    bool canMoveTaskDown( Node* node );
    bool moveTaskDown( Node* node );
    Task *createTask(Node* parent);
    Task *createTask(Task &def, Node* parent);
    
    ResourceGroup *group(TQString id);
    Resource *resource(TQString id);
 
    virtual EffortCostMap plannedEffortCostPrDay(const TQDate &start, const TQDate &end) const;
    
    virtual Duration plannedEffort();
    virtual Duration plannedEffort(const TQDate &date);
    virtual Duration plannedEffortTo(const TQDate &date);
    
    virtual Duration actualEffort();
    virtual Duration actualEffort(const TQDate &date);
    virtual Duration actualEffortTo(const TQDate &date);
    virtual double plannedCost();
    virtual double plannedCost(const TQDate &date);
    virtual double plannedCostTo(const TQDate &date);
    
    virtual double actualCost();
    virtual double actualCost(const TQDate &date);
    virtual double actualCostTo(const TQDate &date);
 
    Calendar *defaultCalendar() { return m_standardWorktime->calendar(); }
    TQPtrList<Calendar> calendars();
    void addCalendar(Calendar *calendar);
    Calendar *calendar(const TQString id) const;
 
    StandardWorktime *standardWorktime() { return m_standardWorktime; }
    void setStandardWorktime(StandardWorktime * worktime);
 
    bool legalToLink(Node *par, Node *child);
    
    virtual const TQDict<Node> &nodeDict() { return nodeIdDict; }
    
    virtual Node *findNode(const TQString &id) const 
        { return (m_parent ? m_parent->findNode(id) : nodeIdDict.find(id)); }
    virtual bool removeId(const TQString &id);
    virtual void insertId(const TQString &id, const Node *node);
    bool registerNodeId(Node *node);
    TQString uniqueNodeId(int seed=1);
    
    ResourceGroup *findResourceGroup(const TQString &id) const 
        { return resourceGroupIdDict.find(id); }
    bool removeResourceGroupId(const TQString &id) 
        { return resourceGroupIdDict.remove(id); }
    void insertResourceGroupId(const TQString &id, const ResourceGroup* group) 
        { resourceGroupIdDict.insert(id, group); }
    
    Resource *findResource(const TQString &id) const 
        { return resourceIdDict.find(id); }
    bool removeResourceId(const TQString &id) 
        { return resourceIdDict.remove(id); }
    void insertResourceId(const TQString &id, const Resource *resource) 
        { resourceIdDict.insert(id, resource); }
 
    virtual Calendar *findCalendar(const TQString &id) const 
        { return id.isEmpty() ? 0 : calendarIdDict.find(id); }
    virtual bool removeCalendarId(const TQString &id);
    virtual void insertCalendarId(const TQString &id, const Calendar *calendar);
    
    void setBaselined(bool on) { m_baselined = on; }
    bool isBaselined() const { return m_baselined; }
    
    void generateWBS(int count, WBSDefinition &def, TQString wbs=TQString());
 
    Accounts &accounts() { return m_accounts; }
    
    virtual void setCurrentSchedule(long id);
    MainSchedule *createSchedule(TQString name, Schedule::Type type);
    virtual void setParentSchedule(Schedule *sch);
    
protected:
    Accounts m_accounts;
    TQPtrList<ResourceGroup> m_resourceGroups;
 
    TQPtrList<Calendar> m_calendars;
 
    StandardWorktime *m_standardWorktime;
        
    DateTime calculateForward(int use);
    DateTime calculateBackward(int use);
    DateTime scheduleForward(const DateTime &earliest, int use);
    DateTime scheduleBackward(const DateTime &latest, int use);
    void adjustSummarytask();
 
    void initiateCalculation(Schedule &sch);
    void initiateCalculationLists(TQPtrList<Node> &startnodes, TQPtrList<Node> &endnodes, TQPtrList<Node> &summarytasks);
 
    bool legalParents(Node *par, Node *child);
    bool legalChildren(Node *par, Node *child);
    
private:
    void init();
    
    TQPtrList<Node> m_startNodes;
    TQPtrList<Node> m_endNodes;
    TQPtrList<Node> m_summarytasks;
    
    bool m_baselined;
    
    TQDict<ResourceGroup> resourceGroupIdDict;
    TQDict<Resource> resourceIdDict;
    TQDict<Node> nodeIdDict;        
    TQDict<Calendar> calendarIdDict;
    
#ifndef NDEBUG
#include <tqcstring.h>
public:
    void printDebug(bool children, TQCString indent);
    void printCalendarDebug(TQCString indent="");
#ifdef DEBUGPERT
    static void pert_test();
    static void printTree(Node *n, TQString s);
#endif
#endif
};
 
}  //KPlato namespace
 
#endif