F:/KPlato/koffice/kplato/kptproject.h

Aller à la documentation de ce fichier.

/* 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 <QMap>
#include <QList>
#include <QHash>

#include <klocale.h>

namespace KPlato
{

class Part;
class Schedule;
class StandardWorktime;

class Project : public Node
{
    Q_OBJECT
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( QDomElement &element );
    virtual void save( QDomElement &element ) const;

    QList<ResourceGroup*> &resourceGroups();
    virtual void addResourceGroup( ResourceGroup *resource );
    virtual void insertResourceGroup( unsigned int index, ResourceGroup *resource );
    void deleteResourceGroup( ResourceGroup *resource );
    void deleteResourceGroup( int number );
    ResourceGroup *takeResourceGroup( ResourceGroup *resource )
    {
        int i = m_resourceGroups.indexOf( resource );
        return i != -1 ? m_resourceGroups.takeAt( i ) : 0;
    }

    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, int index = -1 );
    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( QString id );
    Resource *resource( QString id );

    virtual EffortCostMap plannedEffortCostPrDay( const QDate &start, const QDate &end ) const;

    virtual Duration plannedEffort();
    virtual Duration plannedEffort( const QDate &date );
    virtual Duration plannedEffortTo( const QDate &date );

    virtual Duration actualEffort();
    virtual Duration actualEffort( const QDate &date );
    virtual Duration actualEffortTo( const QDate &date );
    virtual double plannedCost();
    virtual double plannedCost( const QDate &date );
    virtual double plannedCostTo( const QDate &date );

    virtual double actualCost();
    virtual double actualCost( const QDate &date );
    virtual double actualCostTo( const QDate &date );

    Calendar *defaultCalendar() { return m_standardWorktime->calendar(); }
    QList<Calendar*> calendars();
    void addCalendar( Calendar *calendar );
    Calendar *calendar( const QString id ) const;

    StandardWorktime *standardWorktime() { return m_standardWorktime; }
    void setStandardWorktime( StandardWorktime * worktime );
    void setDefaultCalendar( Calendar *cal );

    bool legalToLink( Node *par, Node *child );

    virtual const QHash<QString, Node*> &nodeDict() { return nodeIdDict; }

    virtual Node *findNode( const QString &id ) const
    {
        if ( m_parent == 0 ) {
            if ( nodeIdDict.contains( id ) )
                return nodeIdDict[ id ];
            return 0;
        }
        return m_parent->findNode( id );
    }
    virtual bool removeId( const QString &id );
    virtual void insertId( const QString &id, Node *node );
    bool registerNodeId( Node *node );
    QString uniqueNodeId( int seed = 1 );

    ResourceGroup *findResourceGroup( const QString &id ) const
    {
        if ( resourceGroupIdDict.contains( id ) )
            return resourceGroupIdDict[ id ];
        return 0;
    }
    bool removeResourceGroupId( const QString &id )
    {
        if ( resourceGroupIdDict.contains( id ) )
            return resourceGroupIdDict.remove( id );
        return false;
    }
    void insertResourceGroupId( const QString &id, ResourceGroup* group )
    {
        resourceGroupIdDict.insert( id, group );
    }

    Resource *findResource( const QString &id ) const
    {
        if ( resourceIdDict.contains( id ) )
            return resourceIdDict[ id ];
        return 0;
    }
    bool removeResourceId( const QString &id ) { return resourceIdDict.remove( id ); }
    void insertResourceId( const QString &id, Resource *resource )
    { resourceIdDict.insert( id, resource ); }

    virtual Calendar *findCalendar( const QString &id ) const
    {
        if ( id.isEmpty() || !calendarIdDict.contains( id ) )
            return 0;
        return calendarIdDict[ id ];
    }
    virtual bool removeCalendarId( const QString &id );
    virtual void insertCalendarId( const QString &id, Calendar *calendar );

    void generateWBS( int count, WBSDefinition &def, QString wbs = QString() );

    Accounts &accounts() { return m_accounts; }

    virtual void setCurrentSchedule( long id );
    MainSchedule *createSchedule( QString name, Schedule::Type type );
    virtual void setParentSchedule( Schedule *sch );

signals:
    void nodeChanged( Node* );
    void nodeToBeAdded( Node* );
    void nodeAdded( Node* );
    void nodeToBeRemoved( Node* );
    void nodeRemoved( Node* );
    void nodeToBeMoved( Node* );
    void nodeMoved( Node* );
    
protected:
    virtual void changed(Node *node);
    
    Accounts m_accounts;
    QList<ResourceGroup*> m_resourceGroups;

    QList<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( QList<Node*> &startnodes, QList<Node*> &endnodes, QList<Node*> &summarytasks );

    bool legalParents( Node *par, Node *child );
    bool legalChildren( Node *par, Node *child );

private:
    void init();

    QList<Node*> m_startNodes;
    QList<Node*> m_endNodes;
    QList<Node*> m_summarytasks;

    QHash<QString, ResourceGroup*> resourceGroupIdDict;
    QHash<QString, Resource*> resourceIdDict;
    QHash<QString, Node*> nodeIdDict;
    QHash<QString, Calendar*> calendarIdDict;

#ifndef NDEBUG
public:
    void printDebug( bool children, QByteArray indent );
    void printCalendarDebug( QByteArray indent = "" );
#endif
};

}  //KPlato namespace

#endif

---