1 files changed, 112 insertions, 15 deletions

diff --git a/libopie2/opiepim/core/opimtodo.cpp b/libopie2/opiepim/core/opimtodo.cpp
index 27b36a6..16ca987 100644
--- a/libopie2/opiepim/core/opimtodo.cpp
+++ b/libopie2/opiepim/core/opimtodo.cpp
@@ -43,120 +43,116 @@
 #include <qpe/categoryselect.h>
 #include <qpe/stringutil.h>
 
 /* QT */
 #include <qobject.h>
 #include <qshared.h>
 
 namespace Opie
 {
 
 struct OPimTodo::OPimTodoData : public QShared
 {
     OPimTodoData() : QShared()
     {
         recur = 0;
         state = 0;
         maintainer = 0;
         notifiers = 0;
     };
     ~OPimTodoData()
     {
         delete recur;
         delete maintainer;
         delete notifiers;
+        delete state;
     }
 
     QDate date;
     bool isCompleted: 1;
     bool hasDate: 1;
     int priority;
     QString desc;
     QString sum;
     QMap<QString, QString> extra;
     ushort prog;
     OPimState *state;
     OPimRecurrence *recur;
     OPimMaintainer *maintainer;
     QDate start;
     QDate completed;
     OPimNotifyManager *notifiers;
 };
 
 
 OPimTodo::OPimTodo( const OPimTodo &event )
         : OPimRecord( event ), data( event.data )
 {
     data->ref();
-    //    owarn << "ref up" << oendl;
 }
 
 
 OPimTodo::~OPimTodo()
 {
 
-    //    owarn << "~OPimTodo " << oendl;
     if ( data->deref() )
     {
-        //        owarn << "OPimTodo::dereffing" << oendl;
         delete data;
         data = 0l;
     }
 }
 
 
 OPimTodo::OPimTodo( bool completed, int priority,
               const QArray<int> &category,
               const QString& summary,
               const QString &description,
               ushort progress,
               bool hasDate, QDate date, int uid )
         : OPimRecord( uid )
 {
-    //    owarn << "OPimTodoData " + summary << oendl;
     setCategories( category );
 
     data = new OPimTodoData;
 
     data->date = date;
     data->isCompleted = completed;
     data->hasDate = hasDate;
     data->priority = priority;
     data->sum = summary;
     data->prog = progress;
     data->desc = Qtopia::simplifyMultiLineSpace( description );
 }
 
 
 OPimTodo::OPimTodo( bool completed, int priority,
               const QStringList &category,
               const QString& summary,
               const QString &description,
               ushort progress,
               bool hasDate, QDate date, int uid )
         : OPimRecord( uid )
 {
-    //    owarn << "OPimTodoData" + summary << oendl;
     setCategories( idsFromString( category.join( ";" ) ) );
 
     data = new OPimTodoData;
 
     data->date = date;
     data->isCompleted = completed;
     data->hasDate = hasDate;
     data->priority = priority;
     data->sum = summary;
     data->prog = progress;
     data->desc = Qtopia::simplifyMultiLineSpace( description );
 }
 
 
 bool OPimTodo::match( const QRegExp &regExp ) const
 {
     if ( QString::number( data->priority ).find( regExp ) != -1 )
     {
         setLastHitField( Priority );
         return true;
     }
     else if ( data->hasDate && data->date.toString().find( regExp ) != -1 )
     {
         setLastHitField( HasDate );
@@ -166,55 +162,75 @@ bool OPimTodo::match( const QRegExp &regExp ) const
     {
         setLastHitField( Description );
         return true;
     }
     else if ( data->sum.find( regExp ) != -1 )
     {
         setLastHitField( Summary );
         return true;
     }
     return false;
 }
 
 
 bool OPimTodo::isCompleted() const
 {
     return data->isCompleted;
 }
 
 
 bool OPimTodo::hasDueDate() const
 {
     return data->hasDate;
 }
 
-
+/**
+ * \brief Does this Todo have a start date
+ *
+ * Does this Todo have a start date. The decision
+ * is based on if the internal startDate isValid
+ * in the sense of QDate::isValid.
+ *
+ * @return True if the startDate isValid
+ * @see startDate
+ * @see setStartDate
+ * @see QDate::isValid()
+ */
 bool OPimTodo::hasStartDate() const
 {
     return data->start.isValid();
 }
 
-
+/**
+ * \brief Does this Todo have a Date when it was completed
+ *
+ * As in \sa hasStartDate() it is determined if there
+ * is a completed date by looking if the internal date
+ * isValid \sa QDate::isValid.
+ *
+ * @see hasStartDate
+ * @return True if the completedDate is set and valid.
+ */
 bool OPimTodo::hasCompletedDate() const
 {
     return data->completed.isValid();
 }
 
 
 int OPimTodo::priority() const
 {
     return data->priority;
 }
 
 
 QString OPimTodo::summary() const
 {
     return data->sum;
 }
 
 
 ushort OPimTodo::progress() const
 {
     return data->prog;
 }
 
 
@@ -287,49 +303,48 @@ bool OPimTodo::hasMaintainer() const
 OPimMaintainer OPimTodo::maintainer() const
 {
     if ( !data->maintainer ) return OPimMaintainer();
 
     return ( *data->maintainer );
 }
 
 
 void OPimTodo::setCompleted( bool completed )
 {
     changeOrModify();
     data->isCompleted = completed;
 }
 
 
 void OPimTodo::setHasDueDate( bool hasDate )
 {
     changeOrModify();
     data->hasDate = hasDate;
 }
 
 
 void OPimTodo::setDescription( const QString &desc )
 {
-    //    owarn << "desc " + desc << oendl;
     changeOrModify();
     data->desc = Qtopia::simplifyMultiLineSpace( desc );
 }
 
 
 void OPimTodo::setSummary( const QString& sum )
 {
     changeOrModify();
     data->sum = sum;
 }
 
 
 void OPimTodo::setPriority( int prio )
 {
     changeOrModify();
     data->priority = prio;
 }
 
 
 void OPimTodo::setDueDate( const QDate& date )
 {
     changeOrModify();
     data->date = date;
 }
@@ -359,49 +374,49 @@ void OPimTodo::setState( const OPimState& state )
 }
 
 
 void OPimTodo::setRecurrence( const OPimRecurrence& rec )
 {
     changeOrModify();
     if ( data->recur )
         ( *data->recur ) = rec;
     else
         data->recur = new OPimRecurrence( rec );
 }
 
 
 void OPimTodo::setMaintainer( const OPimMaintainer& pim )
 {
     changeOrModify();
 
     if ( data->maintainer )
         ( *data->maintainer ) = pim;
     else
         data->maintainer = new OPimMaintainer( pim );
 }
 
 
-bool OPimTodo::isOverdue( )
+bool OPimTodo::isOverdue( )const
 {
     if ( data->hasDate && !data->isCompleted )
         return QDate::currentDate() > data->date;
     return false;
 }
 
 
 void OPimTodo::setProgress( ushort progress )
 {
     changeOrModify();
     data->prog = progress;
 }
 
 
 QString OPimTodo::toShortText() const
 {
     return summary();
 }
 
 
 /*!
   Returns a richt text string
 */
 QString OPimTodo::toRichText() const
@@ -572,142 +587,224 @@ bool OPimTodo::operator>=( const OPimTodo &toDoEvent ) const
     }
     return true;
 }
 
 
 bool OPimTodo::operator==( const OPimTodo &toDoEvent ) const
 {
     if ( data->priority != toDoEvent.data->priority ) return false;
     if ( data->priority != toDoEvent.data->prog ) return false;
     if ( data->isCompleted != toDoEvent.data->isCompleted ) return false;
     if ( data->hasDate != toDoEvent.data->hasDate ) return false;
     if ( data->date != toDoEvent.data->date ) return false;
     if ( data->sum != toDoEvent.data->sum ) return false;
     if ( data->desc != toDoEvent.data->desc ) return false;
     if ( data->maintainer != toDoEvent.data->maintainer )
         return false;
 
     return OPimRecord::operator==( toDoEvent );
 }
 
 
 void OPimTodo::deref()
 {
 
-    //    owarn << "deref in ToDoEvent" << oendl;
     if ( data->deref() )
     {
-        //        owarn << "deleting" << oendl;
         delete data;
         data = 0;
     }
 }
 
 
 OPimTodo &OPimTodo::operator=( const OPimTodo &item )
 {
     if ( this == &item ) return * this;
 
     OPimRecord::operator=( item );
-    //owarn << "operator= ref " << oendl;
     item.data->ref();
     deref();
     data = item.data;
 
     return *this;
 }
 
 
 QMap<int, QString> OPimTodo::toMap() const
 {
     QMap<int, QString> map;
 
     map.insert( Uid, QString::number( uid() ) );
     map.insert( Category, idsToString( categories() ) );
     map.insert( HasDate, QString::number( data->hasDate ) );
     map.insert( Completed, QString::number( data->isCompleted ) );
     map.insert( Description, data->desc );
     map.insert( Summary, data->sum );
     map.insert( Priority, QString::number( data->priority ) );
     map.insert( DateDay, QString::number( data->date.day() ) );
     map.insert( DateMonth, QString::number( data->date.month() ) );
     map.insert( DateYear, QString::number( data->date.year() ) );
     map.insert( Progress, QString::number( data->prog ) );
     //    map.insert( CrossReference, crossToString() );
     /* FIXME!!!   map.insert( State,  );
     map.insert( Recurrence, );
     map.insert( Reminders, );
     map.
     */
     return map;
 }
 
 
 /**
  *  change or modify looks at the ref count and either
  *  creates a new QShared Object or it can modify it
  * right in place
  */
 void OPimTodo::changeOrModify()
 {
     if ( data->count != 1 )
     {
-        owarn << "changeOrModify" << oendl;
         data->deref();
         OPimTodoData* d2 = new OPimTodoData();
         copy( data, d2 );
         data = d2;
     }
 }
 
 
 // WATCHOUT
 /*
  * if you add something to the Data struct
  * be sure to copy it here
  */
 void OPimTodo::copy( OPimTodoData* src, OPimTodoData* dest )
 {
     dest->date = src->date;
     dest->isCompleted = src->isCompleted;
     dest->hasDate = src->hasDate;
     dest->priority = src->priority;
     dest->desc = src->desc;
     dest->sum = src->sum;
     dest->extra = src->extra;
     dest->prog = src->prog;
 
     if ( src->state )
         dest->state = new OPimState( *src->state );
 
     if ( src->recur )
         dest->recur = new OPimRecurrence( *src->recur );
 
     if ( src->maintainer )
         dest->maintainer = new OPimMaintainer( *src->maintainer )
                            ;
     dest->start = src->start;
     dest->completed = src->completed;
 
     if ( src->notifiers )
         dest->notifiers = new OPimNotifyManager( *src->notifiers );
 }
 
 
 QString OPimTodo::type() const
 {
     return QString::fromLatin1( "OPimTodo" );
 }
 
 
-QString OPimTodo::recordField( int /*id*/ ) const
+QString OPimTodo::recordField( int  id) const
 {
-    return QString::null;
+    QString res;
+    Q_UNUSED( id )
+#if 0
+    switch( id ) {
+    case HasDate:
+        res = (hasDueDate() ?
+              QObject::tr( "Has a due-date" )
+              : QObject::tr( "No due-date" ));
+        break;
+    case Completed:
+        res = ( isCompleted() ?
+                QObject::tr( "Completed" ) :
+                QObject::tr( "Not completed" ));
+        break;
+    case Description:
+        res = description();
+        break;
+    case Summary:
+        res = summary();
+        break;
+    case Priority:
+        res = QString::number( priority() );
+        break;
+    case DateDay:
+        res = QString::number( dueDate().day() );
+        break;
+    case DateMonth:
+        res = QString::number( dueDate().month() );
+        break;
+    case DateYear:
+        res = QString::number( dueDate().year() );
+        break;
+    case Progress:
+        res = QString::number( progress() );
+        break;
+    case State:
+        res = QString::number( state().state() );
+        break;
+    case Recurrence:
+        res = ( hasRecurrence() ?
+                QString::null /*recurrence().summary()*/ :
+                QObject::tr("No reccurrence"));
+        break;
+    case Alarms:
+        break;
+    case Reminders:
+        break;
+    case Maintainer:
+        break;
+    case StartDate:
+        res = ( hasStartDate() ?
+                /*TimeString::()*/ QString::null :
+                QObject::tr( "No start-date" ) );
+        break;
+    case CompletedDate:
+        res = ( hasCompletedDate() ?
+                /*TimeString::()*/ QString::null :
+                QObject::tr( "No completed-date" ) );
+        break;
+    case DueDate:
+        res = ( hasDueDate() ?
+                /*TimeString::()*/ QString::null :
+                QObject::tr( "No due-date" );
+                break;
+    default:
+        res = OPimRecord::recordField( id );
+    }
+
+#endif
+    return res;
 }
 
 
 int OPimTodo::rtti() const
 {
     return OPimResolver::TodoList;
 }
 
+/**
+ * \brief Provide a SafeCast to OPimTodo from a OPimRecord
+ *
+ * Provide a safe cast that will return 0 if the record
+ * type is not OPimTodo. In the other case it will
+ * be casted to OPimTodo and returned
+ *
+ * @param rec The OPimRecord to be casted
+ *
+ * @return a pointer to OPimTodo or 0l
+ */
+OPimTodo* OPimTodo::safeCast( const OPimRecord* rec ) {
+    return (rec && rec->rtti() == OPimResolver::TodoList ) ?
+        static_cast<OPimTodo*>( const_cast<OPimRecord*>(rec) ) :
+        0l;
+}
+
 }