1 files changed, 717 insertions, 0 deletions

diff --git a/noncore/unsupported/libopie/pim/oevent.cpp b/noncore/unsupported/libopie/pim/oevent.cpp
new file mode 100644
index 0000000..9b31957
--- a/dev/null
+++ b/noncore/unsupported/libopie/pim/oevent.cpp
@@ -0,0 +1,717 @@
+#include <qshared.h>
+#include <qarray.h>
+
+#include <qpe/palmtopuidgen.h>
+#include <qpe/categories.h>
+#include <qpe/stringutil.h>
+
+#include "orecur.h"
+#include "opimresolver.h"
+#include "opimnotifymanager.h"
+
+#include "oevent.h"
+
+int OCalendarHelper::week( const QDate& date) {
+    // Calculates the week this date is in within that
+    // month. Equals the "row" is is in in the month view
+    int week = 1;
+    QDate tmp( date.year(), date.month(), 1 );
+    if ( date.dayOfWeek() < tmp.dayOfWeek() )
+        ++week;
+
+    week += ( date.day() - 1 ) / 7;
+
+    return week;
+}
+int OCalendarHelper::ocurrence( const QDate& date) {
+    // calculates the number of occurrances of this day of the
+    // week till the given date (e.g 3rd Wednesday of the month)
+    return ( date.day() - 1 ) / 7 + 1;
+}
+int OCalendarHelper::dayOfWeek( char day ) {
+    int dayOfWeek = 1;
+    char i = ORecur::MON;
+    while ( !( i & day ) && i <= ORecur::SUN ) {
+        i <<= 1;
+        ++dayOfWeek;
+    }
+    return dayOfWeek;
+}
+int OCalendarHelper::monthDiff( const QDate& first, const QDate& second ) {
+    return ( second.year() - first.year() ) * 12 +
+        second.month() - first.month();
+}
+
+struct OEvent::Data : public QShared {
+    Data() : QShared() {
+        child = 0;
+        recur = 0;
+        manager = 0;
+        isAllDay = false;
+        parent = 0;
+    }
+    ~Data() {
+        delete manager;
+        delete recur;
+    }
+    QString description;
+    QString location;
+    OPimNotifyManager* manager;
+    ORecur* recur;
+    QString note;
+    QDateTime created;
+    QDateTime start;
+    QDateTime end;
+    bool isAllDay : 1;
+    QString timezone;
+    QArray<int>* child;
+    int parent;
+};
+
+OEvent::OEvent( int uid )
+    : OPimRecord( uid ) {
+    data = new Data;
+}
+OEvent::OEvent( const OEvent& ev)
+    : OPimRecord( ev ), data( ev.data )
+{
+    data->ref();
+}
+
+OEvent::OEvent( const QMap<int, QString> map )
+    : OPimRecord( 0 )
+{
+        data = new Data;
+
+        fromMap( map );
+}
+
+OEvent::~OEvent() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0;
+    }
+}
+OEvent& OEvent::operator=( const OEvent& ev) {
+    if ( this == &ev ) return  *this;
+
+    OPimRecord::operator=( ev );
+    ev.data->ref();
+    deref();
+    data = ev.data;
+
+
+    return *this;
+}
+QString OEvent::description()const {
+    return data->description;
+}
+void OEvent::setDescription( const QString& description ) {
+    changeOrModify();
+    data->description = description;
+}
+void OEvent::setLocation( const QString& loc ) {
+    changeOrModify();
+    data->location = loc;
+}
+QString OEvent::location()const {
+    return data->location;
+}
+OPimNotifyManager &OEvent::notifiers()const {
+    // I hope we can skip the changeOrModify here
+    // the notifier should take care of it
+    // and OPimNotify is shared too
+    if (!data->manager )
+        data->manager = new OPimNotifyManager;
+
+    return *data->manager;
+}
+bool OEvent::hasNotifiers()const {
+    if (!data->manager )
+        return false;
+    if (data->manager->reminders().isEmpty() &&
+        data->manager->alarms().isEmpty() )
+        return false;
+
+    return true;
+}
+ORecur OEvent::recurrence()const {
+    if (!data->recur)
+        data->recur = new ORecur;
+
+    return *data->recur;
+}
+void OEvent::setRecurrence( const ORecur& rec) {
+    changeOrModify();
+    if (data->recur )
+        (*data->recur) = rec;
+    else
+        data->recur = new ORecur( rec );
+}
+bool OEvent::hasRecurrence()const {
+    if (!data->recur ) return false;
+    return data->recur->doesRecur();
+}
+QString OEvent::note()const {
+    return data->note;
+}
+void OEvent::setNote( const QString& note ) {
+    changeOrModify();
+    data->note = note;
+}
+QDateTime OEvent::createdDateTime()const {
+    return data->created;
+}
+void OEvent::setCreatedDateTime( const QDateTime& time ) {
+    changeOrModify();
+    data->created = time;
+}
+QDateTime OEvent::startDateTime()const {
+    if ( data->isAllDay )
+        return QDateTime( data->start.date(), QTime(0, 0, 0 ) );
+    return data->start;
+}
+QDateTime OEvent::startDateTimeInZone()const {
+    /* if no timezone, or all day event or if the current and this timeZone match... */
+    if (data->timezone.isEmpty() || data->isAllDay || data->timezone == OTimeZone::current().timeZone() ) return startDateTime();
+
+    OTimeZone zone(data->timezone  );
+    return zone.toDateTime( data->start, OTimeZone::current() );
+}
+void OEvent::setStartDateTime( const QDateTime& dt ) {
+    changeOrModify();
+    data->start = dt;
+}
+QDateTime OEvent::endDateTime()const {
+    /*
+     * if all Day event the end time needs
+     * to be on the same day as the start
+     */
+    if ( data->isAllDay )
+        return QDateTime( data->start.date(), QTime(23, 59, 59 ) );
+    return data->end;
+}
+QDateTime OEvent::endDateTimeInZone()const {
+    /* if no timezone, or all day event or if the current and this timeZone match... */
+    if (data->timezone.isEmpty() || data->isAllDay || data->timezone == OTimeZone::current().timeZone() ) return endDateTime();
+
+    OTimeZone zone(data->timezone  );
+    return zone.toDateTime( data->end, OTimeZone::current() );
+}
+void OEvent::setEndDateTime( const QDateTime& dt ) {
+    changeOrModify();
+    data->end =    dt;
+}
+bool OEvent::isMultipleDay()const {
+    return data->end.date().day() - data->start.date().day();
+}
+bool OEvent::isAllDay()const {
+    return data->isAllDay;
+}
+void OEvent::setAllDay( bool allDay ) {
+    changeOrModify();
+    data->isAllDay = allDay;
+    if (allDay ) data->timezone = "UTC";
+}
+void OEvent::setTimeZone( const QString& tz ) {
+    changeOrModify();
+    data->timezone = tz;
+}
+QString OEvent::timeZone()const {
+    if (data->isAllDay ) return QString::fromLatin1("UTC");
+    return data->timezone;
+}
+bool OEvent::match( const QRegExp& re )const {
+    if ( re.match( data->description ) != -1 ){
+        setLastHitField( Qtopia::DatebookDescription );
+        return true;
+    }
+    if ( re.match( data->note ) != -1 ){
+        setLastHitField( Qtopia::Note );
+        return true;
+    }
+    if ( re.match( data->location ) != -1 ){
+        setLastHitField( Qtopia::Location );
+        return true;
+    }
+    if ( re.match( data->start.toString() ) != -1 ){
+        setLastHitField( Qtopia::StartDateTime );
+        return true;
+    }
+    if ( re.match( data->end.toString() ) != -1 ){
+        setLastHitField( Qtopia::EndDateTime );
+        return true;
+    }
+    return false;
+}
+QString OEvent::toRichText()const {
+    QString text, value;
+
+    // description
+    text += "<b><h3><img src=\"datebook/DateBook\">";
+    if ( !description().isEmpty() ) {
+        text += Qtopia::escapeString(description() ).replace(QRegExp( "[\n]"),  "" );
+    }
+    text += "</h3></b><br><hr><br>";
+
+    // location
+    if ( !(value = location()).isEmpty() ) {
+        text += "<b>" + QObject::tr( "Location:" ) + "</b> ";
+        text += Qtopia::escapeString(value) + "<br>";
+    }
+
+    // all day event
+    if ( isAllDay() ) {
+        text += "<b><i>" + QObject::tr( "This is an all day event" ) + "</i></b><br>";
+    }
+    // multiple day event
+    else if ( isMultipleDay () ) {
+        text += "<b><i>" + QObject::tr( "This is a multiple day event" ) + "</i></b><br>";
+    }
+    // start & end times
+    else {
+        // start time
+        if ( startDateTime().isValid() ) {
+            text += "<b>" + QObject::tr( "Start:") + "</b> ";
+            text += Qtopia::escapeString(startDateTime().toString() ).
+                    replace(QRegExp( "[\n]"),  "<br>" ) + "<br>";
+        }
+
+        // end time
+        if ( endDateTime().isValid() ) {
+            text += "<b>" + QObject::tr( "End:") + "</b> ";
+            text += Qtopia::escapeString(endDateTime().toString() ).
+                    replace(QRegExp( "[\n]"),  "<br>" ) + "<br>";
+        }
+    }
+
+    // categories
+    if ( categoryNames("Calendar").count() ){
+            text += "<b>" + QObject::tr( "Category:") + "</b> ";
+            text += categoryNames("Calendar").join(", ");
+            text += "<br>";
+    }
+
+    //notes
+    if ( !note().isEmpty() ) {
+        text += "<b>" + QObject::tr( "Note:") + "</b><br>";
+        text += note();
+//         text += Qtopia::escapeString(note() ).
+//                 replace(QRegExp( "[\n]"),  "<br>" ) + "<br>";
+    }
+    return text;
+}
+QString OEvent::toShortText()const {
+    QString text;
+    text += QString::number( startDateTime().date().day() );
+    text += ".";
+    text += QString::number( startDateTime().date().month() );
+    text += ".";
+    text += QString::number( startDateTime().date().year() );
+    text += " ";
+    text += QString::number( startDateTime().time().hour() );
+    text += ":";
+    text += QString::number( startDateTime().time().minute() );
+    text += " - ";
+    text += description();
+    return text;
+}
+QString OEvent::type()const {
+    return QString::fromLatin1("OEvent");
+}
+QString OEvent::recordField( int /*id */ )const {
+    return QString::null;
+}
+int OEvent::rtti() {
+    return OPimResolver::DateBook;
+}
+bool OEvent::loadFromStream( QDataStream& ) {
+    return true;
+}
+bool OEvent::saveToStream( QDataStream& )const {
+    return true;
+}
+void OEvent::changeOrModify() {
+    if ( data->count != 1 ) {
+        data->deref();
+        Data* d2 = new Data;
+        d2->description = data->description;
+        d2->location = data->location;
+
+        if (data->manager )
+            d2->manager = new OPimNotifyManager( *data->manager );
+
+        if ( data->recur )
+            d2->recur = new ORecur( *data->recur );
+
+        d2->note = data->note;
+        d2->created = data->created;
+        d2->start = data->start;
+        d2->end = data->end;
+        d2->isAllDay = data->isAllDay;
+        d2->timezone = data->timezone;
+        d2->parent = data->parent;
+
+        if ( data->child ) {
+            d2->child = new QArray<int>( *data->child );
+            d2->child->detach();
+        }
+
+        data = d2;
+    }
+}
+void OEvent::deref() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0;
+    }
+}
+// Exporting Event data to map. Using the same
+// encoding as ODateBookAccessBackend_xml does..
+// Thus, we could remove the stuff there and use this
+// for it and for all other places..
+// Encoding should happen at one place, only ! (eilers)
+QMap<int, QString> OEvent::toMap()const {
+    QMap<int, QString> retMap;
+
+    retMap.insert( OEvent::FUid, QString::number( uid() ) );
+    retMap.insert( OEvent::FCategories, Qtopia::escapeString( Qtopia::Record::idsToString( categories() ) ));
+    retMap.insert( OEvent::FDescription, Qtopia::escapeString( description() ) );
+    retMap.insert( OEvent::FLocation, Qtopia::escapeString( location() ) );
+    retMap.insert( OEvent::FType, isAllDay() ? "AllDay" : "" );
+    OPimAlarm alarm = notifiers().alarms()[0];
+    retMap.insert( OEvent::FAlarm, QString::number( alarm.dateTime().secsTo(  startDateTime() ) / 60 ) );
+    retMap.insert( OEvent::FSound, (alarm.sound() == OPimAlarm::Loud) ? "loud" : "silent" );
+
+    OTimeZone zone(  timeZone().isEmpty() ? OTimeZone::current() : timeZone() );
+    retMap.insert( OEvent::FStart, QString::number( zone.fromUTCDateTime( zone.toDateTime(  startDateTime(), OTimeZone::utc() ) ) ) );
+    retMap.insert( OEvent::FEnd, QString::number( zone.fromUTCDateTime( zone.toDateTime(  endDateTime(), OTimeZone::utc() ) ) ) );
+    retMap.insert( OEvent::FNote, Qtopia::escapeString( note() ) );
+    retMap.insert( OEvent::FTimeZone, timeZone().isEmpty() ? QString( "None" ) : timeZone() );
+    if( parent() )
+            retMap.insert( OEvent::FRecParent, QString::number( parent() ) );
+    if( children().count() ){
+            QArray<int> childr = children();
+            QString buf;
+            for ( uint i = 0; i < childr.count(); i++ ) {
+                    if ( i != 0 ) buf += " ";
+                    buf += QString::number( childr[i] );
+                    }    
+            retMap.insert( OEvent::FRecChildren, buf );
+    }
+    
+    // Add recurrence stuff
+    if( hasRecurrence() ){
+            ORecur recur = recurrence();
+            QMap<int, QString> recFields = recur.toMap();
+            retMap.insert( OEvent::FRType, recFields[ORecur::RType] );
+            retMap.insert( OEvent::FRWeekdays, recFields[ORecur::RWeekdays] );
+            retMap.insert( OEvent::FRPosition, recFields[ORecur::RPosition] );
+            retMap.insert( OEvent::FRFreq, recFields[ORecur::RFreq] );
+            retMap.insert( OEvent::FRHasEndDate, recFields[ORecur::RHasEndDate] );
+            retMap.insert( OEvent::FREndDate, recFields[ORecur::EndDate] );
+            retMap.insert( OEvent::FRCreated, recFields[ORecur::Created] );
+            retMap.insert( OEvent::FRExceptions, recFields[ORecur::Exceptions] );
+    } else {
+            ORecur recur = recurrence();
+            QMap<int, QString> recFields = recur.toMap();
+            retMap.insert( OEvent::FRType, recFields[ORecur::RType] );
+    }
+   
+    return retMap;
+}
+
+void OEvent::fromMap( const QMap<int, QString>& map )
+{
+
+        // We just want to set the UID if it is really stored.
+        if ( !map[OEvent::FUid].isEmpty() )
+                setUid( map[OEvent::FUid].toInt() );
+
+        setCategories( idsFromString( map[OEvent::FCategories] ) );
+        setDescription( map[OEvent::FDescription] );
+        setLocation( map[OEvent::FLocation] );
+
+        if ( map[OEvent::FType] == "AllDay" )
+                setAllDay( true );
+        else
+                setAllDay( false );
+        
+        int alarmTime = -1;
+        if( !map[OEvent::FAlarm].isEmpty() )
+                alarmTime = map[OEvent::FAlarm].toInt();
+
+        int sound = ( ( map[OEvent::FSound] == "loud" ) ? OPimAlarm::Loud : OPimAlarm::Silent );
+        if ( ( alarmTime != -1 )  ){
+                QDateTime dt = startDateTime().addSecs( -1*alarmTime*60 );
+                OPimAlarm al( sound ,  dt  );
+                notifiers().add( al );
+        }
+        if ( !map[OEvent::FTimeZone].isEmpty() && ( map[OEvent::FTimeZone] != "None" ) ){
+                setTimeZone( map[OEvent::FTimeZone] );
+        }
+        
+        time_t start = (time_t) map[OEvent::FStart].toLong();
+        time_t end   = (time_t) map[OEvent::FEnd].toLong();
+
+        /* AllDay is always in UTC */
+        if ( isAllDay() ) {
+                OTimeZone utc = OTimeZone::utc();
+                setStartDateTime( utc.fromUTCDateTime( start ) );
+                setEndDateTime  ( utc.fromUTCDateTime( end   ) );
+                setTimeZone( "UTC"); // make sure it is really utc
+        }else {
+                /* to current date time */
+                // qWarning(" Start is %d", start );
+                OTimeZone zone( timeZone().isEmpty() ? OTimeZone::current() : timeZone() );
+                QDateTime date = zone.toDateTime( start );
+                qWarning(" Start is %s", date.toString().latin1() );
+                setStartDateTime( zone.toDateTime( date, OTimeZone::current() ) );
+
+                date = zone.toDateTime( end );
+                setEndDateTime  ( zone.toDateTime( date, OTimeZone::current() ) );
+        }
+        
+        if ( !map[OEvent::FRecParent].isEmpty() )
+                setParent( map[OEvent::FRecParent].toInt() );
+
+        if ( !map[OEvent::FRecChildren].isEmpty() ){
+                QStringList list = QStringList::split(' ', map[OEvent::FRecChildren] );
+                for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) {
+                        addChild( (*it).toInt() );
+                }
+        }
+        
+        // Fill recurrence stuff and put it directly into the ORecur-Object using fromMap..
+        if( !map[OEvent::FRType].isEmpty() ){
+                QMap<int, QString> recFields;
+                recFields.insert( ORecur::RType, map[OEvent::FRType] );
+                recFields.insert( ORecur::RWeekdays, map[OEvent::FRWeekdays] );
+                recFields.insert( ORecur::RPosition, map[OEvent::FRPosition] );
+                recFields.insert( ORecur::RFreq, map[OEvent::FRFreq] );
+                recFields.insert( ORecur::RHasEndDate, map[OEvent::FRHasEndDate] );
+                recFields.insert( ORecur::EndDate, map[OEvent::FREndDate] );
+                recFields.insert( ORecur::Created, map[OEvent::FRCreated] );
+                recFields.insert( ORecur::Exceptions, map[OEvent::FRExceptions] );
+                ORecur recur( recFields );
+                setRecurrence( recur );
+        }
+        
+}
+
+
+int OEvent::parent()const {
+    return data->parent;
+}
+void OEvent::setParent( int uid ) {
+    changeOrModify();
+    data->parent = uid;
+}
+QArray<int> OEvent::children() const{
+    if (!data->child) return QArray<int>();
+    else
+        return data->child->copy();
+}
+void OEvent::setChildren( const QArray<int>& arr ) {
+    changeOrModify();
+    if (data->child) delete data->child;
+
+    data->child = new QArray<int>( arr );
+    data->child->detach();
+}
+void OEvent::addChild( int uid ) {
+    changeOrModify();
+    if (!data->child ) {
+        data->child = new QArray<int>(1);
+        (*data->child)[0] = uid;
+    }else{
+        int count = data->child->count();
+        data->child->resize( count + 1 );
+        (*data->child)[count] = uid;
+    }
+}
+void OEvent::removeChild( int uid ) {
+    if (!data->child || !data->child->contains( uid ) ) return;
+    changeOrModify();
+    QArray<int> newAr( data->child->count() - 1 );
+    int j = 0;
+    uint count = data->child->count();
+    for ( uint i = 0; i < count; i++ ) {
+        if ( (*data->child)[i] != uid ) {
+            newAr[j] = (*data->child)[i];
+            j++;
+        }
+    }
+    (*data->child) = newAr;
+}
+struct OEffectiveEvent::Data : public QShared {
+    Data() : QShared() {
+    }
+    OEvent event;
+    QDate date;
+    QTime start, end;
+    QDate startDate, endDate;
+    bool dates : 1;
+};
+
+OEffectiveEvent::OEffectiveEvent() {
+    data = new Data;
+    data->date = QDate::currentDate();
+    data->start = data->end = QTime::currentTime();
+    data->dates = false;
+}
+OEffectiveEvent::OEffectiveEvent( const OEvent& ev, const QDate& startDate,
+                                  Position pos ) {
+    data = new Data;
+    data->event = ev;
+    data->date = startDate;
+    if ( pos & Start )
+        data->start = ev.startDateTime().time();
+    else
+        data->start = QTime( 0, 0, 0 );
+
+    if ( pos & End )
+        data->end = ev.endDateTime().time();
+    else
+        data->end = QTime( 23, 59, 59 );
+
+    data->dates = false;
+}
+OEffectiveEvent::OEffectiveEvent( const OEffectiveEvent& ev) {
+    data = ev.data;
+    data->ref();
+}
+OEffectiveEvent::~OEffectiveEvent() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0;
+    }
+}
+OEffectiveEvent& OEffectiveEvent::operator=( const OEffectiveEvent& ev ) {
+    if ( *this == ev ) return  *this;
+
+    ev.data->ref();
+    deref();
+    data = ev.data;
+
+    return *this;
+}
+
+void OEffectiveEvent::setStartTime( const QTime& ti) {
+    changeOrModify();
+    data->start = ti;
+}
+void OEffectiveEvent::setEndTime( const QTime& en) {
+    changeOrModify();
+    data->end = en;
+}
+void OEffectiveEvent::setEvent( const OEvent& ev) {
+    changeOrModify();
+    data->event = ev;
+}
+void OEffectiveEvent::setDate( const QDate& da) {
+    changeOrModify();
+    data->date = da;
+}
+void OEffectiveEvent::setEffectiveDates( const QDate& from,
+                                         const QDate& to ) {
+    if (!from.isValid() ) {
+        data->dates = false;
+        return;
+    }
+
+    data->startDate = from;
+    data->endDate = to;
+}
+QString OEffectiveEvent::description()const {
+    return data->event.description();
+}
+QString OEffectiveEvent::location()const {
+    return data->event.location();
+}
+QString OEffectiveEvent::note()const {
+    return data->event.note();
+}
+OEvent OEffectiveEvent::event()const {
+    return data->event;
+}
+QTime OEffectiveEvent::startTime()const {
+    return data->start;
+}
+QTime OEffectiveEvent::endTime()const {
+    return data->end;
+}
+QDate OEffectiveEvent::date()const {
+    return data->date;
+}
+int OEffectiveEvent::length()const {
+    return (data->end.hour() * 60 - data->start.hour() * 60)
+        + QABS(data->start.minute() - data->end.minute() );
+}
+int OEffectiveEvent::size()const {
+    return ( data->end.hour() - data->start.hour() ) * 3600
+        + (data->end.minute() - data->start.minute() * 60
+        + data->end.second() - data->start.second() );
+}
+QDate OEffectiveEvent::startDate()const {
+    if ( data->dates )
+        return data->startDate;
+    else if ( data->event.hasRecurrence() )  // single day, since multi-day should have a d pointer
+        return data->date;
+    else
+        return data->event.startDateTime().date();
+}
+QDate OEffectiveEvent::endDate()const {
+    if ( data->dates )
+        return data->endDate;
+    else if ( data->event.hasRecurrence() )
+        return data->date;
+    else
+        return data->event.endDateTime().date();
+}
+void OEffectiveEvent::deref() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0;
+    }
+}
+void OEffectiveEvent::changeOrModify() {
+    if ( data->count != 1 ) {
+        data->deref();
+        Data* d2 = new Data;
+        d2->event = data->event;
+        d2->date = data->date;
+        d2->start = data->start;
+        d2->end = data->end;
+        d2->startDate = data->startDate;
+        d2->endDate = data->endDate;
+        d2->dates = data->dates;
+        data = d2;
+    }
+}
+bool OEffectiveEvent::operator<( const OEffectiveEvent &e ) const{
+    if ( data->date < e.date() )
+        return TRUE;
+    if ( data->date == e.date() )
+        return ( startTime() < e.startTime() );
+    else
+        return FALSE;
+}
+bool OEffectiveEvent::operator<=( const OEffectiveEvent &e ) const{
+    return (data->date <= e.date() );
+}
+bool OEffectiveEvent::operator==( const OEffectiveEvent &e ) const {
+    return ( date() == e.date()
+             && startTime() == e.startTime()
+             && endTime()== e.endTime()
+             && event() == e.event() );
+}
+bool OEffectiveEvent::operator!=( const OEffectiveEvent &e ) const {
+    return !(*this == e );
+}
+bool OEffectiveEvent::operator>( const OEffectiveEvent &e ) const {
+    return !(*this <= e );
+}
+bool OEffectiveEvent::operator>= ( const OEffectiveEvent &e ) const {
+    return !(*this < e);
+}