kptcalendar.h

/* 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 <tqdatetime.h>
#include <tqpair.h>
#include <tqptrlist.h>
 
class TQDomElement;
class TQDateTime;
class TQTime;
class TQDate;
class TQString;
 
namespace KPlato
{
 
class DateTime;
class Project;
 
class CalendarDay {
 
public:
    CalendarDay();
    CalendarDay(int state);
    CalendarDay(TQDate date, int state=0);
    CalendarDay(CalendarDay *day);
    ~CalendarDay();
 
    bool load(TQDomElement &element);
    void save(TQDomElement &element) const;
 
    const TQPtrList<TQPair<TQTime, TQTime> > &workingIntervals() const { return m_workingIntervals; }
    void addInterval(TQPair<TQTime, TQTime> *interval);
    void addInterval(TQPair<TQTime, TQTime> interval) { addInterval(new TQPair<TQTime, TQTime>(interval)); }
    void clearIntervals() { m_workingIntervals.clear(); }
    void setIntervals(TQPtrList<TQPair<TQTime, TQTime> > intervals) { 
        m_workingIntervals.clear();
        m_workingIntervals = intervals;
    }
    
    TQTime startOfDay() const;
    TQTime endOfDay() const;
    
    TQDate date() const { return m_date; }
    void setDate(TQDate 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 TQTime &start, const TQTime &end);

    TQPair<TQTime, TQTime> interval(const TQTime &start, const TQTime &end) const;
    
    bool hasInterval() const;

    bool hasInterval(const TQTime &start, const TQTime &end) const;
    
    Duration duration() const;
    
    const CalendarDay &copy(const CalendarDay &day);
 
private:
    TQDate m_date; //NOTE: inValid if used for weekdays
    int m_state;
    TQPtrList<TQPair<TQTime, TQTime> > m_workingIntervals;
 
#ifndef NDEBUG
public:
    void printDebug(TQCString indent="");
#endif
};
 
class CalendarWeekdays {
 
public:
    CalendarWeekdays();
    CalendarWeekdays(CalendarWeekdays *weekdays);
    ~CalendarWeekdays();
 
    bool load(TQDomElement &element);
    void save(TQDomElement &element) const;
 
    void addWeekday(CalendarDay *day) { m_weekdays.append(day); }
    const TQPtrList<CalendarDay> &weekdays() const { return m_weekdays; }
    CalendarDay *weekday(int day) const;
    CalendarDay *weekday(const TQDate &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 TQDate &date) const;
    int state(int weekday) const;
    void setState(int weekday, int state);
    
    const TQPtrList<TQPair<TQTime, TQTime> > &intervals(int weekday) const;
    void setIntervals(int weekday, TQPtrList<TQPair<TQTime, TQTime> >intervals);
    void clearIntervals(int weekday);
    
    bool operator==(const CalendarWeekdays *weekdays) const;
    bool operator!=(const CalendarWeekdays *weekdays) const;
 
    Duration effort(const TQDate &date, const TQTime &start, const TQTime &end);
    
    TQPair<TQTime, TQTime> interval(const TQDate date, const TQTime &start, const TQTime &end) const;
    bool hasInterval(const TQDate date, const TQTime &start, const TQTime &end) const;
    bool hasInterval() const;
 
    Duration duration() const;
    Duration duration(int weekday) const;

    TQTime startOfDay(int weekday) const;
    TQTime endOfDay(int weekday) const;
 
    const CalendarWeekdays &copy(const CalendarWeekdays &weekdays);
 
private:
    TQPtrList<CalendarDay> m_weekdays;
    double m_workHours;
 
#ifndef NDEBUG
public:
    void printDebug(TQCString indent="");
#endif
};

class Calendar {
 
public:
    Calendar();
    Calendar(TQString name, Calendar *parent=0);
    Calendar(Calendar *calendar);
    ~Calendar();
 
    TQString name() const { return m_name; }
    void setName(TQString 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);
 
    TQString id() const { return m_id; }
    bool setId(TQString id);
    void generateId();
    
    bool load(TQDomElement &element);
    void save(TQDomElement &element) const;

    CalendarDay *findDay(const TQDate &date, bool skipUndefined=false) const;
    bool addDay(CalendarDay *day) { return m_days.insert(0, day); }
    bool removeDay(CalendarDay *day) { return m_days.removeRef(day); }
    CalendarDay *takeDay(CalendarDay *day) { return m_days.take(m_days.find(day)); }
    const TQPtrList<CalendarDay> &days() const { return m_days; }
    
    int parentDayState(const TQDate &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); }
 
    TQString parentId() const { return m_parentId; }
    void setParentId(TQString id) { m_parentId = id; }
 
    bool hasParent(Calendar *cal);

    Duration effort(const TQDate &date, const TQTime &start, const TQTime &end) const;
    Duration effort(const DateTime &start, const DateTime &end) const;

    TQPair<DateTime, DateTime> firstInterval(const DateTime &start, const DateTime &end) const;
    
    TQPair<TQTime, TQTime> firstInterval(const TQDate &date, const TQTime &start, const TQTime &end) const;
    
    bool hasInterval(const DateTime &start, const DateTime &end) const;
        
    bool hasInterval(const TQDate &date, const TQTime &start, const TQTime &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 TQString &id) const;
    bool removeId() { return removeId(m_id); }
    bool removeId(const TQString &id);
    void insertId(const TQString &id);
 
protected:
    const Calendar &copy(Calendar &calendar);
    void init();
    
private:
    TQString m_name;
    Calendar *m_parent;
    Project *m_project;
    bool m_deleted;
    TQString m_id;
    TQString m_parentId;
 
    TQPtrList<CalendarDay> m_days;
    CalendarWeekdays *m_weekdays;
 
#ifndef NDEBUG
public:
    void printDebug(TQCString 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((TQ_INT64)(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((TQ_INT64)(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((TQ_INT64)(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((TQ_INT64)(hours*60.0*60.0)); }
    
    bool load(TQDomElement &element);
    void save(TQDomElement &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(TQCString indent="");
#endif
};
 
}  //KPlato namespace
 
#endif