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

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
   Copyright (C) 2003 - 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; 
   version 2 of the License.

   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 KPTCALENDAR_H
#define KPTCALENDAR_H

#include "kptmap.h"
#include "kptduration.h"

#include <qdatetime.h>
#include <QPair>
#include <QList>

class QDomElement;
class QDateTime;
class QTime;
class QDate;
class QString;

namespace KPlato
{

class DateTime;
class Project;

typedef QPair<QTime, QTime> TimeInterval;
typedef QPair<DateTime, DateTime> DateTimeInterval;
        
class CalendarDay {

public:
    CalendarDay();
    CalendarDay(int state);
    CalendarDay(QDate date, int state=0);
    CalendarDay(CalendarDay *day);
    ~CalendarDay();

    bool load(QDomElement &element);
    void save(QDomElement &element) const;

    const QList<TimeInterval*> &workingIntervals() const { return m_workingIntervals; }
    void addInterval(TimeInterval *interval);
    void addInterval(TimeInterval interval) { addInterval(new TimeInterval(interval)); }
    void clearIntervals() { m_workingIntervals.clear(); }
    void setIntervals(QList<TimeInterval*> intervals) { 
        m_workingIntervals.clear();
        m_workingIntervals = intervals;
    }
    
    QTime startOfDay() const;
    QTime endOfDay() const;
    
    QDate date() const { return m_date; }
    void setDate(QDate date) { m_date = date; }
    int state() const { return m_state; }
    void setState(int state) { m_state = state; }

    bool operator==(const CalendarDay *day) const;
    bool operator==(const CalendarDay &day) const;
    bool operator!=(const CalendarDay *day) const;
    bool operator!=(const CalendarDay &day) const;

    Duration effort(const QTime &start, const QTime &end);

    TimeInterval interval(const QTime &start, const QTime &end) const;
    
    bool hasInterval() const;

    bool hasInterval(const QTime &start, const QTime &end) const;
    
    Duration duration() const;
    
    const CalendarDay &copy(const CalendarDay &day);

private:
    QDate m_date; //NOTE: inValid if used for weekdays
    int m_state;
    QList<TimeInterval*> m_workingIntervals;

#ifndef NDEBUG
public:
    void printDebug(QString indent="");
#endif
};

class CalendarWeekdays {

public:
    CalendarWeekdays();
    CalendarWeekdays(CalendarWeekdays *weekdays);
    ~CalendarWeekdays();

    bool load(QDomElement &element);
    void save(QDomElement &element) const;

    void addWeekday(CalendarDay *day) { m_weekdays.append(day); }
    const QList<CalendarDay*> &weekdays() const { return m_weekdays; }
    CalendarDay *weekday(int day) const;
    CalendarDay *weekday(const QDate &date) const { return weekday(date.dayOfWeek()-1); }
    CalendarDay *replace(int weekday, CalendarDay *day) {
        CalendarDay *d = m_weekdays.at(weekday);
        m_weekdays.replace(weekday, day);
        return d;
    }
    IntMap map();
    
    void setWeekday(IntMap::iterator it, int state) { m_weekdays.at(it.key())->setState(state); }

    int state(const QDate &date) const;
    int state(int weekday) const;
    void setState(int weekday, int state);
    
    const QList<TimeInterval*> &intervals(int weekday) const;
    void setIntervals(int weekday, QList<TimeInterval*>intervals);
    void clearIntervals(int weekday);
    
    bool operator==(const CalendarWeekdays *weekdays) const;
    bool operator!=(const CalendarWeekdays *weekdays) const;

    Duration effort(const QDate &date, const QTime &start, const QTime &end);
    
    TimeInterval interval(const QDate date, const QTime &start, const QTime &end) const;
    bool hasInterval(const QDate date, const QTime &start, const QTime &end) const;
    bool hasInterval() const;

    Duration duration() const;
    Duration duration(int weekday) const;

    QTime startOfDay(int weekday) const;
    QTime endOfDay(int weekday) const;

    const CalendarWeekdays &copy(const CalendarWeekdays &weekdays);

private:
    QList<CalendarDay*> m_weekdays;
    double m_workHours;

#ifndef NDEBUG
public:
    void printDebug(QString indent="");
#endif
};

class Calendar {

public:
    Calendar();
    Calendar(QString name, Calendar *parent=0);
    Calendar(Calendar *calendar);
    ~Calendar();

    QString name() const { return m_name; }
    void setName(QString name) { m_name = name; }

    Calendar *parent() const { return m_parent; }
    void setParent(Calendar *parent) { m_parent = parent; }
    
    Project *project() const { return m_project; }
    void setProject(Project *project);

    bool isDeleted() const { return m_deleted; }
    void setDeleted(bool yes);

    QString id() const { return m_id; }
    bool setId(QString id);
    void generateId();
    
    bool load(QDomElement &element);
    void save(QDomElement &element) const;

    CalendarDay *findDay(const QDate &date, bool skipUndefined=false) const;
    void addDay(CalendarDay *day) { m_days.insert(0, day); }
    void deleteDay(CalendarDay *day) {
        int i = m_days.indexOf(day);
        if (i != -1) {
            m_days.removeAt(i);
        }
        delete day;
    }
        
    CalendarDay *takeDay(CalendarDay *day) {
        int i = m_days.indexOf(day);
        if (i != -1)
            m_days.removeAt(i);
        return day;
    }
    const QList<CalendarDay*> &days() const { return m_days; }
    
    int parentDayState(const QDate &date) const;
    
    IntMap weekdaysMap() { return m_weekdays->map(); }
    void setWeekday(IntMap::iterator it, int state) { m_weekdays->setWeekday(it, state); }
    CalendarWeekdays *weekdays() { return m_weekdays; }
    CalendarDay *weekday(int day) const { return m_weekdays->weekday(day); }

    QString parentId() const { return m_parentId; }
    void setParentId(QString id) { m_parentId = id; }

    bool hasParent(Calendar *cal);

    Duration effort(const QDate &date, const QTime &start, const QTime &end) const;
    Duration effort(const DateTime &start, const DateTime &end) const;

    DateTimeInterval firstInterval(const DateTime &start, const DateTime &end) const;
    
    TimeInterval firstInterval(const QDate &date, const QTime &start, const QTime &end) const;
    
    bool hasInterval(const DateTime &start, const DateTime &end) const;
        
    bool hasInterval(const QDate &date, const QTime &start, const QTime &end) const;
        
    DateTime firstAvailableAfter(const DateTime &time, const DateTime &limit);
    DateTime firstAvailableBefore(const DateTime &time, const DateTime &limit);

    Calendar *findCalendar() const { return findCalendar(m_id); }
    Calendar *findCalendar(const QString &id) const;
    bool removeId() { return removeId(m_id); }
    bool removeId(const QString &id);
    void insertId(const QString &id);

protected:
    const Calendar &copy(Calendar &calendar);
    void init();
    
private:
    QString m_name;
    Calendar *m_parent;
    Project *m_project;
    bool m_deleted;
    QString m_id;
    QString m_parentId;

    QList<CalendarDay*> m_days;
    CalendarWeekdays *m_weekdays;

#ifndef NDEBUG
public:
    void printDebug(QString indent="");
#endif
};

class StandardWorktime
{
public:
    StandardWorktime();
    StandardWorktime(StandardWorktime* worktime);
    ~StandardWorktime();
    
    Duration durationYear() const { return m_year; }
    double year() const { return m_year.toDouble(Duration::Unit_h); }
    void setYear(const Duration year) { m_year = year; }
    void setYear(double hours) { m_year = Duration((qint64)(hours*60.0*60.0)); }
    
    Duration durationMonth() const { return m_month; }
    double month() const  { return m_month.toDouble(Duration::Unit_h); }
    void setMonth(const Duration month) { m_month = month; }
    void setMonth(double hours) { m_month = Duration((qint64)(hours*60.0*60.0)); }
    
    Duration durationWeek() const { return m_week; }
    double week() const { return m_week.toDouble(Duration::Unit_h); }
    void setWeek(const Duration week) { m_week = week; }
    void setWeek(double hours) { m_week = Duration((qint64)(hours*60.0*60.0)); }
    
    Duration durationDay() const { return m_day; }
    double day() const { return m_day.toDouble(Duration::Unit_h); }
    void setDay(const Duration day) { m_day = day; }
    void setDay(double hours) { m_day = Duration((qint64)(hours*60.0*60.0)); }
    
    bool load(QDomElement &element);
    void save(QDomElement &element) const;

    Calendar *calendar() const { return m_calendar; }
    
protected:
    void init();
    
private:
    Duration m_year;
    Duration m_month;
    Duration m_week;
    Duration m_day;
    
    Calendar *m_calendar;
    
#ifndef NDEBUG
public:
    void printDebug(QString indent="");
#endif
};

}  //KPlato namespace

#endif

---