1 files changed, 1 insertions, 1 deletions

diff --git a/libopie2/opiepim/core/opimrecurrence.cpp b/libopie2/opiepim/core/opimrecurrence.cpp
index 98bd647..4b1d886 100644
--- a/libopie2/opiepim/core/opimrecurrence.cpp
+++ b/libopie2/opiepim/core/opimrecurrence.cpp
@@ -1,691 +1,691 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) The Main Author <main-author@whereever.org>
               =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program 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., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 #include "opimrecurrence.h"
 
 /* OPIE */
 #include <opie2/opimtimezone.h>
 #include <qpe/timeconversion.h>
 
 /* QT */
 #include <qshared.h>
 
 /* STD */
 #include <time.h>
 
 namespace Opie {
 
 struct OPimRecurrence::Data : public QShared {
     Data() : QShared() {
         type = OPimRecurrence::NoRepeat;
         freq = -1;
         days = 0;
         pos = 0;
         create = QDateTime::currentDateTime();
         hasEnd = FALSE;
         end = QDate::currentDate();
     }
     char days; // Q_UINT8 for 8 seven days;)
     OPimRecurrence::RepeatType type;
     int freq;
     int pos;
     bool hasEnd : 1;
     QDate end;
     QDateTime create;
     int rep;
     QString app;
     ExceptionList list;
     QDate start;
 };
 
 
 OPimRecurrence::OPimRecurrence() {
     data = new Data;
 }
 
 OPimRecurrence::OPimRecurrence( const QMap<int, QString>& map )
 {
-    OPimRecurrence();
+    data = new Data;
     fromMap( map );
 }
 
 
 OPimRecurrence::OPimRecurrence( const OPimRecurrence& rec)
     : data( rec.data )
 {
     data->ref();
 }
 
 
 OPimRecurrence::~OPimRecurrence() {
     if ( data->deref() ) {
         delete data;
         data = 0l;
     }
 }
 
 
 void OPimRecurrence::deref() {
     if ( data->deref() ) {
         delete data;
         data = 0l;
     }
 }
 
 
 bool OPimRecurrence::operator==( const OPimRecurrence& )const {
     return false;
 }
 
 
 OPimRecurrence &OPimRecurrence::operator=( const OPimRecurrence& re) {
     if ( *this == re ) return *this;
 
     re.data->ref();
     deref();
     data = re.data;
 
     return *this;
 }
 
 
 bool OPimRecurrence::doesRecur()const {
     return !( type() == NoRepeat );
 }
 
 
 /*
  * we try to be smart here
  *
  */
 bool OPimRecurrence::doesRecur( const QDate& date ) {
     /* the day before the recurrance */
     QDate da = date.addDays(-1);
 
     QDate recur;
     if (!nextOcurrence( da, recur ) )
         return false;
 
     return (recur == date);
 }
 
 
 // FIXME unuglify!
 // GPL from Datebookdb.cpp
 // FIXME exception list!
 bool OPimRecurrence::nextOcurrence( const QDate& from, QDate& next ) {
     bool stillLooking;
     stillLooking  = p_nextOccurrence( from, next );
     while ( stillLooking && data->list.contains(next) )
         stillLooking = p_nextOccurrence( next.addDays(1), next );
 
     return stillLooking;
 }
 
 
 bool OPimRecurrence::p_nextOccurrence( const QDate& from, QDate& next ) {
 
    // easy checks, first are we too far in the future or too far in the past?
     QDate tmpDate;
     int freq = frequency();
     int diff, diff2, a;
     int iday, imonth, iyear;
     int dayOfWeek = 0;
     int firstOfWeek = 0;
     int weekOfMonth;
 
 
     if (hasEndDate() && endDate() < from)
         return FALSE;
 
     if (start() >= from  ) {
         next = start();
         return TRUE;
     }
 
     switch ( type() ) {
         case Weekly:
             /* weekly is just daily by 7 */
             /* first convert the repeatPattern.Days() mask to the next
             day of week valid after from */
             dayOfWeek = from.dayOfWeek();
             dayOfWeek--; /* we want 0-6, doco for above specs 1-7 */
 
             /* this is done in case freq > 1 and from in week not
             for this round */
             // firstOfWeek = 0; this is already done at decl.
             while(!((1 << firstOfWeek) & days() ))
                 firstOfWeek++;
 
             /* there is at least one 'day', or there would be no event */
             while(!((1 << (dayOfWeek % 7)) & days() ))
                 dayOfWeek++;
 
             dayOfWeek = dayOfWeek % 7; /* the actual day of week */
             dayOfWeek -= start().dayOfWeek() -1;
 
             firstOfWeek = firstOfWeek % 7; /* the actual first of week */
             firstOfWeek -= start().dayOfWeek() -1;
 
             // dayOfWeek may be negitive now
             // day of week is number of days to add to start day
 
             freq *= 7;
             // FALL-THROUGH !!!!!
         case Daily:
             // the add is for the possible fall through from weekly */
             if(start().addDays(dayOfWeek) > from) {
                 /* first week exception */
                 next = QDate(start().addDays(dayOfWeek) );
                 if ((next > endDate())
                     && hasEndDate() )
                     return FALSE;
                 return TRUE;
             }
             /* if from is middle of a non-week */
 
             diff = start().addDays(dayOfWeek).daysTo(from) % freq;
             diff2 = start().addDays(firstOfWeek).daysTo(from) % freq;
 
             if(diff != 0)
                 diff = freq - diff;
             if(diff2 != 0)
                 diff2 = freq - diff2;
             diff = QMIN(diff, diff2);
 
             next = QDate(from.addDays(diff));
             if ( (next > endDate())
                 && hasEndDate() )
                 return FALSE;
             return TRUE;
         case MonthlyDay:
             iday = from.day();
             iyear = from.year();
             imonth = from.month();
             /* find equivelent day of month for this month */
             dayOfWeek = start().dayOfWeek();
             weekOfMonth = (start().day() - 1) / 7;
 
             /* work out when the next valid month is */
             a = from.year() - start().year();
             a *= 12;
             a = a + (imonth - start().month());
             /* a is e.start()monthsFrom(from); */
             if(a % freq) {
                 a = freq - (a % freq);
                 imonth = from.month() + a;
                 if (imonth > 12) {
                     imonth--;
                     iyear += imonth / 12;
                     imonth = imonth % 12;
                     imonth++;
                 }
             }
             /* imonth is now the first month after or on
             from that matches the frequency given */
 
             /* find for this month */
             tmpDate = QDate( iyear, imonth, 1 );
 
             iday = 1;
             iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
             iday += 7 * weekOfMonth;
             while (iday > tmpDate.daysInMonth()) {
                 imonth += freq;
                 if (imonth > 12) {
                     imonth--;
                     iyear += imonth / 12;
                     imonth = imonth % 12;
                     imonth++;
                 }
                 tmpDate = QDate( iyear, imonth, 1 );
                 /* these loops could go for a while, check end case now */
                 if ((tmpDate > endDate()) && hasEndDate() )
                     return FALSE;
                 iday = 1;
                 iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
                 iday += 7 * weekOfMonth;
             }
             tmpDate = QDate(iyear, imonth, iday);
 
             if (tmpDate >= from) {
                 next = tmpDate;
                 if ((next > endDate() ) && hasEndDate() )
                     return FALSE;
                 return TRUE;
             }
 
             /* need to find the next iteration */
             do {
                 imonth += freq;
                 if (imonth > 12) {
                     imonth--;
                     iyear += imonth / 12;
                     imonth = imonth % 12;
                     imonth++;
                 }
                 tmpDate = QDate( iyear, imonth, 1 );
                 /* these loops could go for a while, check end case now */
                 if ((tmpDate > endDate()) && hasEndDate() )
                     return FALSE;
                 iday = 1;
                 iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
                 iday += 7 * weekOfMonth;
             } while (iday > tmpDate.daysInMonth());
             tmpDate = QDate(iyear, imonth, iday);
 
             next = tmpDate;
             if ((next > endDate()) && hasEndDate() )
                 return FALSE;
             return TRUE;
         case MonthlyDate:
             iday = start().day();
             iyear = from.year();
             imonth = from.month();
 
             a = from.year() - start().year();
             a *= 12;
             a = a + (imonth - start().month());
             /* a is e.start()monthsFrom(from); */
             if(a % freq) {
                 a = freq - (a % freq);
                 imonth = from.month() + a;
                 if (imonth > 12) {
                     imonth--;
                     iyear += imonth / 12;
                     imonth = imonth % 12;
                     imonth++;
                 }
             }
             /* imonth is now the first month after or on
             from that matches the frequencey given */
 
             /* this could go for a while, worse case, 4*12 iterations, probably */
             while(!QDate::isValid(iyear, imonth, iday) ) {
                 imonth += freq;
                 if (imonth > 12) {
                     imonth--;
                     iyear += imonth / 12;
                     imonth = imonth % 12;
                     imonth++;
                 }
                 /* these loops could go for a while, check end case now */
                 if ((QDate(iyear, imonth, 1) > endDate()) && hasEndDate() )
                     return FALSE;
             }
 
             if(QDate(iyear, imonth, iday) >= from) {
                 /* done */
                 next = QDate(iyear, imonth, iday);
                 if ((next > endDate()) && hasEndDate() )
                     return FALSE;
                 return TRUE;
             }
 
             /* ok, need to cycle */
             imonth += freq;
             imonth--;
             iyear += imonth / 12;
             imonth = imonth % 12;
             imonth++;
 
             while(!QDate::isValid(iyear, imonth, iday) ) {
                 imonth += freq;
                 imonth--;
                 iyear += imonth / 12;
                 imonth = imonth % 12;
                 imonth++;
                 if ((QDate(iyear, imonth, 1) > endDate()) && hasEndDate() )
                     return FALSE;
             }
 
             next = QDate(iyear, imonth, iday);
             if ((next > endDate()) && hasEndDate() )
                 return FALSE;
             return TRUE;
         case Yearly:
             iday = start().day();
             imonth = start().month();
             iyear = from.year(); // after all, we want to start in this year
 
             diff = 1;
             if(imonth == 2 && iday > 28) {
                 /* leap year, and it counts, calculate actual frequency */
                 if(freq % 4)
                     if (freq % 2)
                         freq = freq * 4;
                     else
                         freq = freq * 2;
                 /* else divides by 4 already, leave freq alone */
                 diff = 4;
             }
 
             a = from.year() - start().year();
             if(a % freq) {
                 a = freq - (a % freq);
                 iyear = iyear + a;
             }
 
             /* under the assumption we won't hit one of the special not-leap years twice */
             if(!QDate::isValid(iyear, imonth, iday)) {
                 /* must have been skipping by leap years and hit one that wasn't, (e.g. 2100) */
                 iyear += freq;
             }
 
             if(QDate(iyear, imonth, iday) >= from) {
                 next = QDate(iyear, imonth, iday);
 
                 if ((next > endDate()) && hasEndDate() )
                     return FALSE;
                 return TRUE;
             }
             /* iyear == from.year(), need to advance again */
             iyear += freq;
             /* under the assumption we won't hit one of the special not-leap years twice */
             if(!QDate::isValid(iyear, imonth, iday)) {
                 /* must have been skipping by leap years and hit one that wasn't, (e.g. 2100) */
                 iyear += freq;
             }
 
             next = QDate(iyear, imonth, iday);
             if ((next > endDate()) && hasEndDate() )
                 return FALSE;
             return TRUE;
         default:
             return FALSE;
     }
 }
 
 
 OPimRecurrence::RepeatType OPimRecurrence::type()const{
     return data->type;
 }
 
 
 int OPimRecurrence::frequency()const {
     return data->freq;
 }
 
 
 int OPimRecurrence::position()const {
     return data->pos;
 }
 
 
 char OPimRecurrence::days() const{
     return data->days;
 }
 
 
 bool OPimRecurrence::hasEndDate()const {
     return data->hasEnd;
 }
 
 
 QDate OPimRecurrence::endDate()const {
     return data->end;
 }
 
 
 QDate OPimRecurrence::start()const{
     return data->start;
 }
 
 
 QDateTime OPimRecurrence::createdDateTime()const {
     return data->create;
 }
 
 
 int OPimRecurrence::repetition()const {
     return data->rep;
 }
 
 
 QString OPimRecurrence::service()const {
     return data->app;
 }
 
 
 OPimRecurrence::ExceptionList& OPimRecurrence::exceptions() {
     return data->list;
 }
 
 
 void OPimRecurrence::setType( const RepeatType& z) {
     checkOrModify();
     data->type = z;
 }
 
 
 void OPimRecurrence::setFrequency( int freq ) {
     checkOrModify();
     data->freq = freq;
 }
 
 
 void OPimRecurrence::setPosition( int pos ) {
     checkOrModify();
     data->pos = pos;
 }
 
 
 void OPimRecurrence::setDays( char c ) {
     checkOrModify();
     data->days = c;
 }
 
 
 void OPimRecurrence::setEndDate( const QDate& dt) {
     checkOrModify();
     data->end = dt;
 }
 
 
 void OPimRecurrence::setCreatedDateTime( const QDateTime& t) {
     checkOrModify();
     data->create = t;
 }
 
 
 void OPimRecurrence::setHasEndDate( bool b) {
     checkOrModify();
     data->hasEnd = b;
 }
 
 
 void OPimRecurrence::setRepitition( int rep ) {
     checkOrModify();
     data->rep = rep;
 }
 
 
 void OPimRecurrence::setService( const QString& app ) {
     checkOrModify();
     data->app = app;
 }
 
 
 void OPimRecurrence::setStart( const QDate& dt ) {
     checkOrModify();
     data->start = dt;
 }
 
 
 void OPimRecurrence::checkOrModify() {
     if ( data->count !=  1 ) {
         data->deref();
         Data* d2 = new Data;
         d2->days = data->days;
         d2->type = data->type;
         d2->freq = data->freq;
         d2->pos  = data->pos;
         d2->hasEnd = data->hasEnd;
         d2->end  = data->end;
         d2->create = data->create;
         d2->rep = data->rep;
         d2->app = data->app;
         d2->list = data->list;
         d2->start = data->start;
         data = d2;
     }
 }
 
 
 QString OPimRecurrence::toString()const {
     QString buf;
     QMap<int, QString> recMap = toMap();
 
     buf += " rtype=\"";
     buf += recMap[OPimRecurrence::RType];
     buf += "\"";
     if (data->days > 0 )
         buf += " rweekdays=\"" + recMap[OPimRecurrence::RWeekdays] + "\"";
     if ( data->pos != 0 )
         buf += " rposition=\"" + recMap[OPimRecurrence::RPosition] + "\"";
 
     buf += " rfreq=\"" + recMap[OPimRecurrence::RFreq] + "\"";
     buf += " rhasenddate=\"" + recMap[OPimRecurrence::RHasEndDate]+ "\"";
     if ( data->hasEnd )
         buf += " enddt=\""
             + recMap[OPimRecurrence::EndDate]
             + "\"";
     buf += " created=\"" + recMap[OPimRecurrence::Created] + "\"";
 
     if ( data->list.isEmpty() ) return buf;
     buf += " exceptions=\"";
     buf += recMap[OPimRecurrence::Exceptions];
     buf += "\" ";
 
     return buf;
 }
 
 QString OPimRecurrence::rTypeString() const
 {
     QString retString;
     switch ( data->type ) {
     case OPimRecurrence::Daily:
             retString = "Daily";
             break;
     case OPimRecurrence::Weekly:
             retString = "Weekly";
             break;
     case OPimRecurrence::MonthlyDay:
             retString = "MonthlyDay";
             break;
     case OPimRecurrence::MonthlyDate:
             retString = "MonthlyDate";
             break;
     case OPimRecurrence::Yearly:
             retString = "Yearly";
             break;
     default:
             retString = "NoRepeat";
             break;
 
     }
 
     return retString;
 }
 
 QMap<QString, OPimRecurrence::RepeatType> OPimRecurrence::rTypeValueConvertMap() const
 {
         QMap<QString, RepeatType> convertMap;
 
         convertMap.insert( QString( "Daily" ), OPimRecurrence::Daily );
         convertMap.insert( QString( "Weekly" ), OPimRecurrence::Weekly );
         convertMap.insert( QString( "MonthlyDay" ), OPimRecurrence::MonthlyDay );
         convertMap.insert( QString( "MonthlyDate" ), OPimRecurrence::MonthlyDate );
         convertMap.insert( QString( "Yearly" ), OPimRecurrence::Yearly );
         convertMap.insert( QString( "NoRepeat" ), OPimRecurrence::NoRepeat );
 
         return convertMap;
 }
 
 
 QMap<int, QString> OPimRecurrence::toMap() const
 {
     QMap<int, QString> retMap;
     
     retMap.insert( OPimRecurrence::RType, rTypeString() );
     retMap.insert( OPimRecurrence::RWeekdays, QString::number( static_cast<int>( data->days ) ) );
     retMap.insert( OPimRecurrence::RPosition, QString::number(data->pos ) );
     retMap.insert( OPimRecurrence::RFreq, QString::number( data->freq ) );
     retMap.insert( OPimRecurrence::RHasEndDate, QString::number( static_cast<int>( data->hasEnd ) ) );
     if( data -> hasEnd )
             retMap.insert( OPimRecurrence::EndDate, QString::number( OPimTimeZone::utc().fromUTCDateTime( QDateTime( data->end, QTime(12,0,0) ) ) ) );
     retMap.insert( OPimRecurrence::Created, QString::number( OPimTimeZone::utc().fromUTCDateTime( data->create ) ) );
     
     if ( data->list.isEmpty() ) return retMap;
 
     // save exceptions list here!!
     ExceptionList::ConstIterator it;
     ExceptionList list = data->list;
     QString exceptBuf;
     QDate date;
     for ( it = list.begin(); it != list.end(); ++it ) {
             date = (*it);
             if ( it != list.begin() ) exceptBuf += " ";
             
             exceptBuf += QCString().sprintf("%04d%02d%02d", date.year(), date.month(), date.day() );
     }
 
     retMap.insert( OPimRecurrence::Exceptions, exceptBuf );
 
     return retMap;
 }
 
 void OPimRecurrence::fromMap( const QMap<int, QString>& map )
 {
     QMap<QString, RepeatType> repTypeMap = rTypeValueConvertMap(); 
 
     data -> type  = repTypeMap[ map [OPimRecurrence::RType] ];
     data -> days  = (char) map[ OPimRecurrence::RWeekdays ].toInt();
     data -> pos   = map[ OPimRecurrence::RPosition ].toInt();
     data -> freq = map[ OPimRecurrence::RFreq ].toInt();
     data -> hasEnd= map[ OPimRecurrence::RHasEndDate ].toInt() ? true : false;
     OPimTimeZone utc = OPimTimeZone::utc();
     if ( data -> hasEnd ){
             data -> end = utc.fromUTCDateTime( (time_t) map[ OPimRecurrence::EndDate ].toLong() ).date();
     }
     data -> create = utc.fromUTCDateTime( (time_t) map[ OPimRecurrence::Created ].toLong() ).date();
 
 #if 0
     // FIXME: Exceptions currently not supported...
     // Convert the list of exceptions from QString into ExceptionList
     data -> list.clear();
     QString exceptStr = map[ OPimRecurrence::Exceptions ];
     QStringList exceptList = QStringList::split( " ", exceptStr );
     ...
 #endif
         
         
 }
 
 }