1 files changed, 10 insertions, 4 deletions

diff --git a/libopie2/opiepim/oevent.cpp b/libopie2/opiepim/oevent.cpp
index 56ea10d..3ba8a52 100644
--- a/libopie2/opiepim/oevent.cpp
+++ b/libopie2/opiepim/oevent.cpp
@@ -53,397 +53,403 @@ struct OEvent::Data : public QShared {
         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() {
     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& )const {
     // FIXME
     return false;
 }
 QString OEvent::toRichText()const {
     // FIXME
     return "OEvent test";
 }
 QString OEvent::toShortText()const {
     return "OEvent shotText";
 }
 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;
-        d2->manager = data->manager;
-        d2->recur = data->recur;
+
+        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;
-        d2->child = data->child;
 
-        if (d2->child )
+        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;
     }
 }
 // FIXME
 QMap<int, QString> OEvent::toMap()const {
     return QMap<int, QString>();
 }
 QMap<QString, QString> OEvent::toExtraMap()const {
     return QMap<QString, QString>();
 }
 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;
     }
 }