Fixed a lot of worse bugs in the databook-backend for SQL.

It was found by doing equivalence checks between events, moved between xml
and sql backend, using opimconverter..
More bugfixes will follow..

3 files changed, 24 insertions, 16 deletions

diff --git a/libopie2/opiepim/backend/odatebookaccessbackend_sql.cpp b/libopie2/opiepim/backend/odatebookaccessbackend_sql.cpp
index 6c32b40..f4f3c94 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend_sql.cpp
+++ b/libopie2/opiepim/backend/odatebookaccessbackend_sql.cpp
@@ -45,193 +45,193 @@
 
 #include <opie2/opimrecurrence.h>
 #include <opie2/odatebookaccessbackend_sql.h>
 
 using namespace Opie::DB;
 
 namespace {
         /**
          * a find query for custom elements
          */
         class FindCustomQuery : public OSQLQuery {
         public:
                 FindCustomQuery(int uid);
                 FindCustomQuery(const QArray<int>& );
                 ~FindCustomQuery();
                 QString query()const;
         private:
                 QString single()const;
                 QString multi()const;
                 QArray<int> m_uids;
                 int m_uid;
         };
 
         FindCustomQuery::FindCustomQuery(int uid)
                 : OSQLQuery(), m_uid( uid ) {
         }
         FindCustomQuery::FindCustomQuery(const QArray<int>& ints)
                 : OSQLQuery(), m_uids( ints ){
         }
         FindCustomQuery::~FindCustomQuery() {
         }
         QString FindCustomQuery::query()const{
         //      if ( m_uids.count() == 0 )
                         return single();
         }
         QString FindCustomQuery::single()const{
                 QString qu = "select uid, type, value from custom_data where uid = ";
                 qu += QString::number(m_uid);
                 return qu;
         }
 }
 
 
 namespace Opie {
 
 
 ODateBookAccessBackend_SQL::ODateBookAccessBackend_SQL( const QString& ,
                                                         const QString& fileName )
         : ODateBookAccessBackend(), m_driver( NULL ) 
 {
         m_fileName = fileName.isEmpty() ? Global::applicationFileName( "datebook", "datebook.db" ) : fileName;
 
     // Get the standart sql-driver from the OSQLManager..
     OSQLManager man;
     m_driver = man.standard();
     m_driver->setUrl( m_fileName );
 
     initFields();
 
     load();
 }
 
 ODateBookAccessBackend_SQL::~ODateBookAccessBackend_SQL() {
         if( m_driver )
                 delete m_driver;
 }
 
 void ODateBookAccessBackend_SQL::initFields()
 {
 
         // This map contains the translation of the fieldtype id's to 
         // the names of the table columns
         m_fieldMap.insert( OPimEvent::FUid, "uid" );
         m_fieldMap.insert( OPimEvent::FCategories, "Categories" );
         m_fieldMap.insert( OPimEvent::FDescription, "Description" );
         m_fieldMap.insert( OPimEvent::FLocation, "Location" );
         m_fieldMap.insert( OPimEvent::FType, "Type" );
         m_fieldMap.insert( OPimEvent::FAlarm, "Alarm" );
         m_fieldMap.insert( OPimEvent::FSound, "Sound" );
         m_fieldMap.insert( OPimEvent::FRType, "RType" );
         m_fieldMap.insert( OPimEvent::FRWeekdays, "RWeekdays" );
         m_fieldMap.insert( OPimEvent::FRPosition, "RPosition" );
         m_fieldMap.insert( OPimEvent::FRFreq, "RFreq" );
         m_fieldMap.insert( OPimEvent::FRHasEndDate, "RHasEndDate" );
         m_fieldMap.insert( OPimEvent::FREndDate, "REndDate" );
         m_fieldMap.insert( OPimEvent::FRCreated, "RCreated" );
         m_fieldMap.insert( OPimEvent::FRExceptions, "RExceptions" );
         m_fieldMap.insert( OPimEvent::FStart, "Start" );
         m_fieldMap.insert( OPimEvent::FEnd, "End" );
         m_fieldMap.insert( OPimEvent::FNote, "Note" );
         m_fieldMap.insert( OPimEvent::FTimeZone, "TimeZone" );
         m_fieldMap.insert( OPimEvent::FRecParent, "RecParent" );
         m_fieldMap.insert( OPimEvent::FRecChildren, "Recchildren" );
 
         // Create a map that maps the column name to the id
         QMapConstIterator<int, QString> it;
-        for ( it = ++m_fieldMap.begin(); it != m_fieldMap.end(); ++it ){
+        for ( it = m_fieldMap.begin(); it != m_fieldMap.end(); ++it ){
                 m_reverseFieldMap.insert( it.data(), it.key() );
         }
         
 }
 
 bool ODateBookAccessBackend_SQL::load() 
 {
         if (!m_driver->open() )
                 return false;
 
         // Don't expect that the database exists.
         // It is save here to create the table, even if it
         // do exist. ( Is that correct for all databases ?? )
                 QStringqu = "create table datebook( uid INTEGER PRIMARY KEY ";
         
         QMap<int, QString>::Iterator it;
         for ( it = ++m_fieldMap.begin(); it != m_fieldMap.end(); ++it ){
                 qu += QString( ",%1 VARCHAR(10)" ).arg( it.data() );
         }
         qu += " );";
                 
         qu += "create table custom_data( uid INTEGER, id INTEGER, type VARCHAR(10), priority INTEGER, value VARCHAR(10), PRIMARY KEY /* identifier */ (uid, id) );";
 
         qWarning( "command: %s", qu.latin1() );
 
         OSQLRawQuery raw( qu );
         OSQLResult res = m_driver->query( &raw );
         if ( res.state() != OSQLResult::Success )
                 return false;
 
         update();
 
         return true;
 }
 
 void ODateBookAccessBackend_SQL::update()
 {
 
         QString qu = "select uid from datebook";
         OSQLRawQuery raw( qu );
         OSQLResult res = m_driver->query( &raw );
         if ( res.state() != OSQLResult::Success ){
                 // m_uids.clear();
                 return;
         }
         
         m_uids = extractUids( res );
         
 }
 
 bool ODateBookAccessBackend_SQL::reload() 
 {
         return load();
 }
 
 bool ODateBookAccessBackend_SQL::save() 
 {
         return m_driver->close();  // Shouldn't m_driver->sync be better than close ? (eilers)
 }
 
 QArray<int> ODateBookAccessBackend_SQL::allRecords()const 
 {
         return m_uids;
 }
 
 QArray<int> ODateBookAccessBackend_SQL::queryByExample(const OPimEvent&, int,  const QDateTime& ) {
         return QArray<int>();
 }
 
 void ODateBookAccessBackend_SQL::clear() 
 {
         QString qu = "drop table datebook;";
         qu += "drop table custom_data;";
 
         OSQLRawQuery raw( qu );
         OSQLResult res = m_driver->query( &raw );
 
         reload();
 }
 
 
 OPimEvent ODateBookAccessBackend_SQL::find( int uid ) const{
         qDebug( "ODateBookAccessBackend_SQL::find( %d )", uid ); 
 
         QString qu = "select *";
         qu += "from datebook where uid = " + QString::number(uid);
 
         qDebug( "Query: %s", qu.latin1() );
 
         OSQLRawQuery raw( qu );
         OSQLResult res = m_driver->query( &raw );
 
         OSQLResultItem resItem = res.first();
 
         // Create Map for date event and insert UID
         QMap<int,QString> dateEventMap;
diff --git a/libopie2/opiepim/core/opimevent.cpp b/libopie2/opiepim/core/opimevent.cpp
index 8bf8b25..9d46651 100644
--- a/libopie2/opiepim/core/opimevent.cpp
+++ b/libopie2/opiepim/core/opimevent.cpp
@@ -462,296 +462,304 @@ QString OPimEvent::toShortText() const
     text += " ";
     text += QString::number( startDateTime().time().hour() );
     text += ":";
     text += QString::number( startDateTime().time().minute() );
     text += " - ";
     text += description();
     return text;
 }
 
 
 QString OPimEvent::type() const
 {
     return QString::fromLatin1( "OPimEvent" );
 }
 
 
 QString OPimEvent::recordField( int /*id */ ) const
 {
     return QString::null;
 }
 
 
 int OPimEvent::rtti() const
 {
     return OPimResolver::DateBook;
 }
 
 
 bool OPimEvent::loadFromStream( QDataStream& )
 {
     return true;
 }
 
 
 bool OPimEvent::saveToStream( QDataStream& ) const
 {
     return true;
 }
 
 
 void OPimEvent::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 OPimRecurrence( *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 OPimEvent::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> OPimEvent::toMap() const
 {
     QMap<int, QString> retMap;
 
     retMap.insert( OPimEvent::FUid, QString::number( uid() ) );
     retMap.insert( OPimEvent::FCategories, Qtopia::escapeString( Qtopia::Record::idsToString( categories() ) ) );
     retMap.insert( OPimEvent::FDescription, Qtopia::escapeString( description() ) );
     retMap.insert( OPimEvent::FLocation, Qtopia::escapeString( location() ) );
     retMap.insert( OPimEvent::FType, isAllDay() ? "AllDay" : "" );
-    OPimAlarm alarm = notifiers().alarms() [ 0 ];
-    retMap.insert( OPimEvent::FAlarm, QString::number( alarm.dateTime().secsTo( startDateTime() ) / 60 ) );
-    retMap.insert( OPimEvent::FSound, ( alarm.sound() == OPimAlarm::Loud ) ? "loud" : "silent" );
+    if ( notifiers().alarms().count() ){ 
+            // Currently we just support one alarm.. (eilers)
+            OPimAlarm alarm = notifiers().alarms() [ 0 ];
+            retMap.insert( OPimEvent::FAlarm, QString::number( alarm.dateTime().secsTo( startDateTime() ) / 60 ) );
+            retMap.insert( OPimEvent::FSound, ( alarm.sound() == OPimAlarm::Loud ) ? "loud" : "silent" );
+    }
 
     OPimTimeZone zone( timeZone().isEmpty() ? OPimTimeZone::current() : timeZone() );
     retMap.insert( OPimEvent::FStart, QString::number( zone.fromUTCDateTime( zone.toDateTime( startDateTime(), OPimTimeZone::utc() ) ) ) );
     retMap.insert( OPimEvent::FEnd, QString::number( zone.fromUTCDateTime( zone.toDateTime( endDateTime(), OPimTimeZone::utc() ) ) ) );
     retMap.insert( OPimEvent::FNote, Qtopia::escapeString( note() ) );
     retMap.insert( OPimEvent::FTimeZone, timeZone().isEmpty() ? QString( "None" ) : timeZone() );
     if ( parent() )
         retMap.insert( OPimEvent::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( OPimEvent::FRecChildren, buf );
     }
 
     // Add recurrence stuff
     if ( hasRecurrence() )
     {
         OPimRecurrence recur = recurrence();
         QMap<int, QString> recFields = recur.toMap();
         retMap.insert( OPimEvent::FRType, recFields[ OPimRecurrence::RType ] );
         retMap.insert( OPimEvent::FRWeekdays, recFields[ OPimRecurrence::RWeekdays ] );
         retMap.insert( OPimEvent::FRPosition, recFields[ OPimRecurrence::RPosition ] );
         retMap.insert( OPimEvent::FRFreq, recFields[ OPimRecurrence::RFreq ] );
         retMap.insert( OPimEvent::FRHasEndDate, recFields[ OPimRecurrence::RHasEndDate ] );
         retMap.insert( OPimEvent::FREndDate, recFields[ OPimRecurrence::EndDate ] );
         retMap.insert( OPimEvent::FRCreated, recFields[ OPimRecurrence::Created ] );
         retMap.insert( OPimEvent::FRExceptions, recFields[ OPimRecurrence::Exceptions ] );
     }
     else
     {
         OPimRecurrence recur = recurrence();
         QMap<int, QString> recFields = recur.toMap();
         retMap.insert( OPimEvent::FRType, recFields[ OPimRecurrence::RType ] );
     }
 
     return retMap;
 }
 
 
 void OPimEvent::fromMap( const QMap<int, QString>& map )
 {
 
     // We just want to set the UID if it is really stored.
     if ( !map[ OPimEvent::FUid ].isEmpty() )
         setUid( map[ OPimEvent::FUid ].toInt() );
 
     setCategories( idsFromString( map[ OPimEvent::FCategories ] ) );
     setDescription( map[ OPimEvent::FDescription ] );
     setLocation( map[ OPimEvent::FLocation ] );
 
     if ( map[ OPimEvent::FType ] == "AllDay" )
         setAllDay( true );
     else
         setAllDay( false );
 
-    int alarmTime = -1;
-    if ( !map[ OPimEvent::FAlarm ].isEmpty() )
-        alarmTime = map[ OPimEvent::FAlarm ].toInt();
-
-    int sound = ( ( map[ OPimEvent::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[ OPimEvent::FTimeZone ].isEmpty() && ( map[ OPimEvent::FTimeZone ] != "None" ) )
     {
         setTimeZone( map[ OPimEvent::FTimeZone ] );
     }
 
     time_t start = ( time_t ) map[ OPimEvent::FStart ].toLong();
     time_t end = ( time_t ) map[ OPimEvent::FEnd ].toLong();
 
     /* AllDay is always in UTC */
     if ( isAllDay() )
     {
         OPimTimeZone utc = OPimTimeZone::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 );
         OPimTimeZone zone( timeZone().isEmpty() ? OPimTimeZone::current() : timeZone() );
         QDateTime date = zone.toDateTime( start );
         qWarning( " Start is %s", date.toString().latin1() );
         setStartDateTime( zone.toDateTime( date, OPimTimeZone::current() ) );
 
         date = zone.toDateTime( end );
         setEndDateTime ( zone.toDateTime( date, OPimTimeZone::current() ) );
     }
 
+    int alarmTime = -1;
+    if ( !map[ OPimEvent::FAlarm ].isEmpty() )
+        alarmTime = map[ OPimEvent::FAlarm ].toInt();
+
+    int sound = ( ( map[ OPimEvent::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[ OPimEvent::FNote ].isEmpty() )
+            setNote( map[ OPimEvent::FNote ] );
+
     if ( !map[ OPimEvent::FRecParent ].isEmpty() )
         setParent( map[ OPimEvent::FRecParent ].toInt() );
 
     if ( !map[ OPimEvent::FRecChildren ].isEmpty() )
     {
         QStringList list = QStringList::split( ' ', map[ OPimEvent::FRecChildren ] );
         for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it )
         {
             addChild( ( *it ).toInt() );
         }
     }
 
     // Fill recurrence stuff and put it directly into the OPimRecurrence-Object using fromMap..
     if ( !map[ OPimEvent::FRType ].isEmpty() )
     {
         QMap<int, QString> recFields;
         recFields.insert( OPimRecurrence::RType, map[ OPimEvent::FRType ] );
         recFields.insert( OPimRecurrence::RWeekdays, map[ OPimEvent::FRWeekdays ] );
         recFields.insert( OPimRecurrence::RPosition, map[ OPimEvent::FRPosition ] );
         recFields.insert( OPimRecurrence::RFreq, map[ OPimEvent::FRFreq ] );
         recFields.insert( OPimRecurrence::RHasEndDate, map[ OPimEvent::FRHasEndDate ] );
         recFields.insert( OPimRecurrence::EndDate, map[ OPimEvent::FREndDate ] );
         recFields.insert( OPimRecurrence::Created, map[ OPimEvent::FRCreated ] );
         recFields.insert( OPimRecurrence::Exceptions, map[ OPimEvent::FRExceptions ] );
         OPimRecurrence recur( recFields );
         setRecurrence( recur );
     }
 
 }
 
 
 int OPimEvent::parent() const
 {
     return data->parent;
 }
 
 
 void OPimEvent::setParent( int uid )
 {
     changeOrModify();
     data->parent = uid;
 }
 
 
 QArray<int> OPimEvent::children() const
 {
     if ( !data->child ) return QArray<int>();
     else
         return data->child->copy();
 }
 
 
 void OPimEvent::setChildren( const QArray<int>& arr )
 {
     changeOrModify();
     if ( data->child ) delete data->child;
 
     data->child = new QArray<int>( arr );
     data->child->detach();
 }
 
 
 void OPimEvent::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 OPimEvent::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;
 }
diff --git a/libopie2/opiepim/core/opimevent.h b/libopie2/opiepim/core/opimevent.h
index 56fe917..5553cac 100644
--- a/libopie2/opiepim/core/opimevent.h
+++ b/libopie2/opiepim/core/opimevent.h
@@ -1,178 +1,178 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) Stefan Eilers <Eilers.Stefan@epost.de>
               =.             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.
 */
 // CONTAINS GPLed code of TT
 
 #ifndef OEVENT_H
 #define OEVENT_H
 
 /* OPIE */
 #include <opie2/opimtimezone.h>
 #include <opie2/opimrecord.h>
 #include <qpe/recordfields.h>
 #include <qpe/palmtopuidgen.h>
 
 /* QT */
 #include <qstring.h>
 #include <qdatetime.h>
 #include <qvaluelist.h>
 
 namespace Opie
 {
 struct OCalendarHelper
 {
     /** calculate the week number of the date */
     static int week( const QDate& );
     /** calculate the occurence of week days since the start of the month */
     static int ocurrence( const QDate& );
 
     // returns the dayOfWeek for the *first* day it finds (ignores
     // any further days!). Returns 1 (Monday) if there isn't any day found
     static int dayOfWeek( char day );
 
     /** returns the diff of month */
     static int monthDiff( const QDate& first, const QDate& second );
 
 };
 
 class OPimNotifyManager;
 class OPimRecurrence;
 
 /**
  * This is the container for all Events. It encapsules all
  * available information for a single Event
  * @short container for events.
  */
 class OPimEvent : public OPimRecord
 {
   public:
     typedef QValueList<OPimEvent> ValueList;
     /**
      * RecordFields contain possible attributes
      * used in the Results of toMap()..
      */
     enum RecordFields {
         FUid = Qtopia::UID_ID,
         FCategories = Qtopia::CATEGORY_ID,
-        FDescription = 0,
+        FDescription /* = 0 Why this ? (eilers) */,
         FLocation,
         FType,
         FAlarm,
         FSound,
         FRType,
         FRWeekdays,
         FRPosition,
         FRFreq,
         FRHasEndDate,
         FREndDate,
         FRCreated,
         FRExceptions,
         FStart,
         FEnd,
         FNote,
         FTimeZone,
         FRecParent,
         FRecChildren,
     };
 
     /**
      * Start with an Empty OPimEvent. UID == 0 means that it is empty
      */
     OPimEvent( int uid = 0 );
 
     /**
      * copy c'tor
      */
     OPimEvent( const OPimEvent& );
 
     /**
      * Create OPimEvent, initialized by map
      * @see enum RecordFields
      */
     OPimEvent( const QMap<int, QString> map );
     ~OPimEvent();
     OPimEvent &operator=( const OPimEvent& );
 
     QString description() const;
     void setDescription( const QString& description );
 
     QString location() const;
     void setLocation( const QString& loc );
 
     bool hasNotifiers() const;
     OPimNotifyManager &notifiers() const;
 
     OPimRecurrence recurrence() const;
     void setRecurrence( const OPimRecurrence& );
     bool hasRecurrence() const;
 
     QString note() const;
     void setNote( const QString& note );
 
 
     QDateTime createdDateTime() const;
     void setCreatedDateTime( const QDateTime& dt );
 
     /** set the date to dt. dt is the QDateTime in localtime */
     void setStartDateTime( const QDateTime& );
     /** returns the datetime in the local timeZone */
     QDateTime startDateTime() const;
 
     /** returns the start datetime in the current zone */
     QDateTime startDateTimeInZone() const;
 
     /** in current timezone */
     void setEndDateTime( const QDateTime& );
     /** in current timezone */
     QDateTime endDateTime() const;
     QDateTime endDateTimeInZone() const;
 
     bool isMultipleDay() const;
     bool isAllDay() const;
     void setAllDay( bool isAllDay );
 
     /* pin this event to a timezone! FIXME */
     void setTimeZone( const QString& timeZone );
     QString timeZone() const;
 
 
     virtual bool match( const QRegExp& ) const;
 
     /** For exception to recurrence here is a list of children...  */
     QArray<int> children() const;
     void setChildren( const QArray<int>& );
     void addChild( int uid );
     void removeChild( int uid );
 
     /** return the parent OPimEvent */
     int parent() const;
     void setParent( int uid );
 
 
     /* needed reimp */
     QString toRichText() const;