fix up OTodo::hasNotifiers

add a const notifiers() function
and fix OPimNotifyManager::isEmpty

3 files changed, 17 insertions, 3 deletions

diff --git a/libopie2/opiepim/core/opimnotifymanager.cpp b/libopie2/opiepim/core/opimnotifymanager.cpp
index 49af757..06b5987 100644
--- a/libopie2/opiepim/core/opimnotifymanager.cpp
+++ b/libopie2/opiepim/core/opimnotifymanager.cpp
@@ -1,72 +1,74 @@
 #include "opimnotifymanager.h"
 
 OPimNotifyManager::OPimNotifyManager( const Reminders& rem,  const Alarms& al)
     : m_rem( rem ), m_al( al )
 {}
 OPimNotifyManager::~OPimNotifyManager() {
 }
 /* use static_cast and type instead of dynamic... */
 void OPimNotifyManager::add( const OPimNotify& noti) {
     if ( noti.type() == QString::fromLatin1("OPimReminder") ) {
         const OPimReminder& rem = static_cast<const OPimReminder&>(noti);
         m_rem.append( rem );
     }else if ( noti.type() == QString::fromLatin1("OPimAlarm") ) {
         const OPimAlarm& al = static_cast<const OPimAlarm&>(noti);
         m_al.append( al );
     }
 }
 void OPimNotifyManager::remove( const OPimNotify& noti) {
     if ( noti.type() == QString::fromLatin1("OPimReminder") ) {
         const OPimReminder& rem = static_cast<const OPimReminder&>(noti);
         m_rem.remove( rem );
     }else if ( noti.type() == QString::fromLatin1("OPimAlarm") ) {
         const OPimAlarm& al = static_cast<const OPimAlarm&>(noti);
         m_al.remove( al );
     }
 }
 void OPimNotifyManager::replace( const OPimNotify& noti) {
     if ( noti.type() == QString::fromLatin1("OPimReminder") ) {
         const OPimReminder& rem = static_cast<const OPimReminder&>(noti);
         m_rem.remove( rem );
         m_rem.append( rem );
     }else if ( noti.type() == QString::fromLatin1("OPimAlarm") ) {
         const OPimAlarm& al = static_cast<const OPimAlarm&>(noti);
         m_al.remove( al );
         m_al.append( al );
     }
 }
 OPimNotifyManager::Reminders OPimNotifyManager::reminders()const {
     return m_rem;
 }
 OPimNotifyManager::Alarms    OPimNotifyManager::alarms()const {
     return m_al;
 }
 void OPimNotifyManager::setAlarms( const Alarms& al) {
     m_al = al;
 }
 void OPimNotifyManager::setReminders( const Reminders& rem) {
     m_rem = rem;
 }
 /* FIXME!!! */
 /**
  * The idea is to check if the provider for our service
  * is online
  * if it is we will use QCOP
  * if not the Factory to get the backend...
  * Qtopia1.6 services would be kewl to have here....
  */
 void OPimNotifyManager::registerNotify( const OPimNotify& ) {
 
 }
 /* FIXME!!! */
 /**
  * same as above...
  * Also implement Url model
  * have a MainWindow....
  */
 void OPimNotifyManager::deregister( const OPimNotify& ) {
 
 }
 bool OPimNotifyManager::isEmpty()const {
-    return ( m_rem.isEmpty() && m_al.isEmpty() );
+    qWarning("is Empty called on OPimNotifyManager %d %d", m_rem.count(), m_al.count() );
+    if ( m_rem.isEmpty() && m_al.isEmpty() ) return true;
+    else return false;
 }
diff --git a/libopie2/opiepim/otodo.cpp b/libopie2/opiepim/otodo.cpp
index f3df119..a29d88e 100644
--- a/libopie2/opiepim/otodo.cpp
+++ b/libopie2/opiepim/otodo.cpp
@@ -1,475 +1,481 @@
 
 #include <qobject.h>
 #include <qshared.h>
 
 
 
 #include <qpe/palmtopuidgen.h>
 #include <qpe/stringutil.h>
 #include <qpe/palmtoprecord.h>
 #include <qpe/stringutil.h>
 #include <qpe/categories.h>
 #include <qpe/categoryselect.h>
 
 
 #include "opimstate.h"
 #include "orecur.h"
 #include "opimmaintainer.h"
 #include "opimnotifymanager.h"
 #include "opimresolver.h"
 
 #include "otodo.h"
 
 
 struct OTodo::OTodoData : public QShared {
     OTodoData() : QShared() {
         recur = 0;
         state = 0;
         maintainer = 0;
         notifiers = 0;
     };
 
     QDate date;
     bool isCompleted:1;
     bool hasDate:1;
     int priority;
     QString desc;
     QString sum;
     QMap<QString, QString> extra;
     ushort prog;
     OPimState *state;
     ORecur *recur;
     OPimMaintainer *maintainer;
     QDate start;
     QDate completed;
     OPimNotifyManager *notifiers;
 };
 
 OTodo::OTodo(const OTodo &event )
     : OPimRecord( event ),  data( event.data )
 {
     data->ref();
 //    qWarning("ref up");
 }
 OTodo::~OTodo() {
 
 //    qWarning("~OTodo "  );
     if ( data->deref() ) {
 //        qWarning("OTodo::dereffing");
         delete data;
         data = 0l;
     }
 }
 OTodo::OTodo(bool completed, int priority,
                      const QArray<int> &category,
                      const QString& summary,
                      const QString &description,
                      ushort progress,
                      bool hasDate, QDate date, int uid )
     : OPimRecord(  uid )
 {
 //    qWarning("OTodoData " + summary);
     setCategories( category );
 
     data = new OTodoData;
 
     data->date = date;
     data->isCompleted = completed;
     data->hasDate = hasDate;
     data->priority = priority;
     data->sum = summary;
     data->prog = progress;
     data->desc = Qtopia::simplifyMultiLineSpace(description );
 }
 OTodo::OTodo(bool completed, int priority,
                      const QStringList &category,
                      const QString& summary,
                      const QString &description,
                      ushort progress,
                      bool hasDate, QDate date, int uid )
     : OPimRecord(  uid )
 {
 //    qWarning("OTodoData" + summary);
     setCategories( idsFromString( category.join(";") ) );
 
     data = new OTodoData;
 
     data->date = date;
     data->isCompleted = completed;
     data->hasDate = hasDate;
     data->priority = priority;
     data->sum = summary;
     data->prog = progress;
     data->desc = Qtopia::simplifyMultiLineSpace(description );
 }
 bool OTodo::match( const QRegExp &regExp )const
 {
   if( QString::number( data->priority ).find( regExp ) != -1 ){
     return true;
   }else if( data->hasDate && data->date.toString().find( regExp) != -1 ){
     return true;
   }else if(data->desc.find( regExp ) != -1 ){
     return true;
   }else if(data->sum.find( regExp ) != -1 ) {
     return true;
   }
   return false;
 }
 bool OTodo::isCompleted() const
 {
     return data->isCompleted;
 }
 bool OTodo::hasDueDate() const
 {
     return data->hasDate;
 }
 bool OTodo::hasStartDate()const {
     return data->start.isValid();
 }
 bool OTodo::hasCompletedDate()const {
     return data->completed.isValid();
 }
 int OTodo::priority()const
 {
     return data->priority;
 }
 QString OTodo::summary() const
 {
     return data->sum;
 }
 ushort OTodo::progress() const
 {
     return data->prog;
 }
 QDate OTodo::dueDate()const
 {
     return data->date;
 }
 QDate OTodo::startDate()const {
     return data->start;
 }
 QDate OTodo::completedDate()const {
     return data->completed;
 }
 QString OTodo::description()const
 {
     return data->desc;
 }
 bool OTodo::hasState() const{
     if (!data->state ) return false;
     return ( data->state->state() != OPimState::Undefined );
 }
 OPimState OTodo::state()const {
     if (!data->state ) {
         OPimState state;
         return state;
     }
 
     return (*data->state);
 }
 bool OTodo::hasRecurrence()const {
     if (!data->recur) return false;
     return data->recur->doesRecur();
 }
 ORecur OTodo::recurrence()const {
     if (!data->recur) return ORecur();
 
     return (*data->recur);
 }
 bool OTodo::hasMaintainer()const {
     if (!data->maintainer) return false;
 
     return (data->maintainer->mode() != OPimMaintainer::Undefined );
 }
 OPimMaintainer OTodo::maintainer()const {
     if (!data->maintainer) return OPimMaintainer();
 
     return (*data->maintainer);
 }
 void OTodo::setCompleted( bool completed )
 {
     changeOrModify();
     data->isCompleted = completed;
 }
 void OTodo::setHasDueDate( bool hasDate )
 {
     changeOrModify();
     data->hasDate = hasDate;
 }
 void OTodo::setDescription(const QString &desc )
 {
 //    qWarning( "desc " + desc );
     changeOrModify();
     data->desc = Qtopia::simplifyMultiLineSpace(desc );
 }
 void OTodo::setSummary( const QString& sum )
 {
     changeOrModify();
     data->sum = sum;
 }
 void OTodo::setPriority(int prio )
 {
     changeOrModify();
     data->priority = prio;
 }
 void OTodo::setDueDate( const QDate& date )
 {
     changeOrModify();
     data->date = date;
 }
 void OTodo::setStartDate( const QDate& date ) {
     changeOrModify();
     data->start = date;
 }
 void OTodo::setCompletedDate( const QDate& date ) {
     changeOrModify();
     data->completed = date;
 }
 void OTodo::setState( const OPimState& state ) {
     changeOrModify();
     if (data->state )
         (*data->state) = state;
     else
         data->state = new OPimState( state );
 }
 void OTodo::setRecurrence( const ORecur& rec) {
     changeOrModify();
     if (data->recur )
         (*data->recur) = rec;
     else
         data->recur = new ORecur( rec );
 }
 void OTodo::setMaintainer( const OPimMaintainer& pim ) {
     changeOrModify();
 
     if (data->maintainer )
         (*data->maintainer) = pim;
     else
         data->maintainer = new OPimMaintainer( pim );
 }
 bool OTodo::isOverdue( )
 {
     if( data->hasDate && !data->isCompleted)
         return QDate::currentDate() > data->date;
     return false;
 }
 void OTodo::setProgress(ushort progress )
 {
     changeOrModify();
     data->prog = progress;
 }
 QString OTodo::toShortText() const {
  return summary();
 }
 /*!
   Returns a richt text string
 */
 QString OTodo::toRichText() const
 {
   QString text;
   QStringList catlist;
 
   // Description of the todo
   if ( !summary().isEmpty() ) {
     text += "<b>" + QObject::tr( "Summary:") + "</b><br>";
     text += Qtopia::escapeString(summary() ).replace(QRegExp( "[\n]"),  "<br>" ) + "<br>";
   }
   if( !description().isEmpty() ){
     text += "<b>" + QObject::tr( "Description:" ) + "</b><br>";
     text += Qtopia::escapeString(description() ).replace(QRegExp( "[\n]"), "<br>" ) ;
   }
   text += "<br><br><br>";
 
   text += "<b>" + QObject::tr( "Priority:") +" </b>"
     +  QString::number( priority() ) + " <br>";
   text += "<b>" + QObject::tr( "Progress:") + " </b>"
           + QString::number( progress() ) + " %<br>";
   if (hasDueDate() ){
     text += "<b>" + QObject::tr( "Deadline:") + " </b>";
     text += dueDate().toString();
     text += "<br>";
   }
 
   text += "<b>" + QObject::tr( "Category:") + "</b> ";
   text += categoryNames( "Todo List" ).join(", ");
   text += "<br>";
 
   return text;
 }
 bool OTodo::hasNotifiers()const {
     if (!data->notifiers) return false;
-    return data->notifiers->isEmpty();
+    return !data->notifiers->isEmpty();
 }
 OPimNotifyManager& OTodo::notifiers() {
     if (!data->notifiers )
         data->notifiers = new OPimNotifyManager;
     return (*data->notifiers);
 }
+const OPimNotifyManager& OTodo::notifiers()const{
+    if (!data->notifiers )
+        data->notifiers = new OPimNotifyManager;
+
+    return (*data->notifiers);
+}
 
 bool OTodo::operator<( const OTodo &toDoEvent )const{
     if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true;
     if( !hasDueDate() && toDoEvent.hasDueDate() ) return false;
     if( hasDueDate() && toDoEvent.hasDueDate() ){
         if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide
             return priority() < toDoEvent.priority();
         }else{
             return dueDate() < toDoEvent.dueDate();
         }
     }
     return false;
 }
 bool OTodo::operator<=(const OTodo &toDoEvent )const
 {
     if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true;
     if( !hasDueDate() && toDoEvent.hasDueDate() ) return true;
     if( hasDueDate() && toDoEvent.hasDueDate() ){
         if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide
             return priority() <= toDoEvent.priority();
         }else{
             return dueDate() <= toDoEvent.dueDate();
         }
     }
     return true;
 }
 bool OTodo::operator>(const OTodo &toDoEvent )const
 {
     if( !hasDueDate() && !toDoEvent.hasDueDate() ) return false;
     if( !hasDueDate() &&  toDoEvent.hasDueDate() ) return false;
     if( hasDueDate()  &&  toDoEvent.hasDueDate() ){
         if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide
             return priority() > toDoEvent.priority();
         }else{
             return dueDate() > toDoEvent.dueDate();
         }
     }
     return false;
 }
 bool OTodo::operator>=(const OTodo &toDoEvent )const
 {
     if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true;
     if( !hasDueDate() &&  toDoEvent.hasDueDate() ) return false;
     if( hasDueDate() && toDoEvent.hasDueDate() ){
         if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide
             return priority() > toDoEvent.priority();
         }else{
             return dueDate() > toDoEvent.dueDate();
         }
     }
     return true;
 }
 bool OTodo::operator==(const OTodo &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 OTodo::deref() {
 
 //    qWarning("deref in ToDoEvent");
     if ( data->deref() ) {
 //        qWarning("deleting");
         delete data;
         data= 0;
     }
 }
 OTodo &OTodo::operator=(const OTodo &item )
 {
     if ( this == &item ) return *this;
 
     OPimRecord::operator=( item );
     //qWarning("operator= ref ");
     item.data->ref();
     deref();
     data = item.data;
 
     return *this;
 }
 
 QMap<int, QString> OTodo::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;
 }
 
 QMap<QString, QString> OTodo::toExtraMap()const {
     return data->extra;
 }
 /**
  *  change or modify looks at the ref count and either
  *  creates a new QShared Object or it can modify it
  * right in place
  */
 void OTodo::changeOrModify() {
     if ( data->count != 1 ) {
         qWarning("changeOrModify");
         data->deref();
         OTodoData* d2 = new OTodoData();
         copy(data, d2 );
         data = d2;
     }
 }
 // WATCHOUT
 /*
  * if you add something to the Data struct
  * be sure to copy it here
  */
 void OTodo::copy( OTodoData* src, OTodoData* 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 ORecur( *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 OTodo::type() const {
     return QString::fromLatin1("OTodo");
 }
 QString OTodo::recordField(int /*id*/ )const {
     return QString::null;
 }
 
 int OTodo::rtti(){
     return OPimResolver::TodoList;
 }
diff --git a/libopie2/opiepim/otodo.h b/libopie2/opiepim/otodo.h
index 0e7c73f..4d5ee36 100644
--- a/libopie2/opiepim/otodo.h
+++ b/libopie2/opiepim/otodo.h
@@ -1,289 +1,295 @@
 
 #ifndef OPIE_TODO_EVENT_H
 #define OPIE_TODO_EVENT_H
 
 
 #include <qarray.h>
 #include <qmap.h>
 #include <qregexp.h>
 #include <qstringlist.h>
 #include <qdatetime.h>
 #include <qvaluelist.h>
 
 #include <qpe/recordfields.h>
 #include <qpe/palmtopuidgen.h>
 
 #include <opie/opimrecord.h>
 
 
 class OPimState;
 class ORecur;
 class OPimMaintainer;
 class OPimNotifyManager;
 class OTodo : public  OPimRecord  {
 public:
     typedef QValueList<OTodo> ValueList;
     enum RecordFields {
         Uid = Qtopia::UID_ID,
         Category = Qtopia::CATEGORY_ID,
         HasDate,
         Completed,
         Description,
         Summary,
         Priority,
         DateDay,
         DateMonth,
         DateYear,
         Progress,
         CrossReference,
         State,
         Recurrence,
         Alarms,
         Reminders,
         Notifiers,
         Maintainer,
         StartDate,
         CompletedDate
     };
  public:
     // priorities from Very low to very high
     enum TaskPriority { VeryHigh=1,  High,  Normal,  Low, VeryLow };
 
     /* Constructs a new ToDoEvent
        @param completed Is the TodoEvent completed
        @param priority What is the priority of this ToDoEvent
        @param category Which category does it belong( uid )
        @param summary A small summary of the todo
        @param description What is this ToDoEvent about
        @param hasDate Does this Event got a deadline
        @param date what is the deadline?
        @param uid what is the UUID of this Event
     **/
     OTodo( bool completed = false, int priority = Normal,
            const QStringList &category = QStringList(),
            const QString &summary = QString::null ,
            const QString &description = QString::null,
            ushort progress = 0,
            bool hasDate = false, QDate date = QDate::currentDate(),
            int uid = 0 /*empty*/ );
 
     OTodo( bool completed, int priority,
            const QArray<int>& category,
            const QString& summary = QString::null,
            const QString& description = QString::null,
            ushort progress = 0,
            bool hasDate = false,  QDate date = QDate::currentDate(),
            int uid = 0 /* empty */ );
 
     /** Copy c'tor
      *
      */
     OTodo(const OTodo & );
 
     /**
      *destructor
      */
     ~OTodo();
 
     /**
      * Is this event completed?
      */
     bool isCompleted() const;
 
     /**
      * Does this Event have a deadline
      */
     bool hasDueDate() const;
     bool hasStartDate()const;
     bool hasCompletedDate()const;
 
     /**
      * Does this Event has an alarm time ?
      */
     bool hasAlarmDateTime() const;
 
     /**
      * What is the priority?
      */
     int priority()const ;
 
     /**
      * progress as ushort 0, 20, 40, 60, 80 or 100%
      */
     ushort progress() const;
 
     /**
      * The due Date
      */
     QDate dueDate()const;
 
     /**
      * When did it start?
      */
     QDate startDate()const;
 
     /**
      * When was it completed?
      */
     QDate completedDate()const;
 
     /**
      * does it have a state?
      */
     bool hasState()const;
 
     /**
      * What is the state of this OTodo?
      */
     OPimState state()const;
 
     /**
      * has recurrence?
      */
     bool hasRecurrence()const;
 
     /**
      * the recurrance of this
      */
     ORecur recurrence()const;
 
     /**
      * does this OTodo have a maintainer?
      */
     bool hasMaintainer()const;
 
     /**
      * the Maintainer of this OTodo
      */
     OPimMaintainer maintainer()const;
 
     /**
      * The description of the todo
      */
     QString description()const;
 
     /**
      * A small summary of the todo
      */
     QString summary() const;
 
     /**
      * @reimplemented
      * Return this todoevent in a RichText formatted QString
      */
     QString toRichText() const;
 
     bool hasNotifiers()const;
     /*
-     * check if the sharing is still fine!! -zecke
+     * FIXME check if the sharing is still fine!! -zecke
+     * ### CHECK If API is fine
      */
     /**
      * return a reference to our notifiers...
      */
     OPimNotifyManager &notifiers();
 
     /**
+     *
+     */
+    const OPimNotifyManager &notifiers()const;
+
+    /**
      * reimplementations
      */
     QString type()const;
     QString toShortText()const;
     QMap<QString, QString> toExtraMap()const;
     QString recordField(int id )const;
 
     /**
      * toMap puts all data into the map. int relates
      * to ToDoEvent RecordFields enum
      */
     QMap<int, QString> toMap()const;
 
     /**
      * Set if this Todo is completed
      */
     void setCompleted(bool completed );
 
     /**
      * set if this todo got an end data
      */
     void setHasDueDate( bool hasDate );
     // FIXME we do not have these for start, completed
     // cause we'll use the isNull() of QDate for figuring
     // out if it's has a date...
     // decide what to do here? -zecke
 
     /**
      * Set the priority of the Todo
      */
     void setPriority(int priority );
 
     /**
      * Set the progress.
      */
     void setProgress( ushort progress );
 
     /**
      * set the end date
      */
     void setDueDate( const QDate& date );
 
     /**
      * set the start date
      */
     void setStartDate( const QDate& date );
 
     /**
      * set the completed date
      */
     void setCompletedDate( const QDate& date );
 
     void setRecurrence( const ORecur& );
     /**
      * set the alarm time
      */
     void setAlarmDateTime ( const QDateTime& alarm );
 
     void setDescription(const QString& );
     void setSummary(const QString& );
 
     /**
      * set the state of a Todo
      * @param state State what the todo should take
      */
     void setState( const OPimState& state);
 
     /**
      * set the Maintainer Mode
      */
     void setMaintainer( const OPimMaintainer& );
 
     bool isOverdue();
 
 
     virtual bool match( const QRegExp &r )const;
 
     bool operator<(const OTodo &toDoEvent )const;
     bool operator<=(const OTodo &toDoEvent )const;
     bool operator!=(const OTodo &toDoEvent )const;
     bool operator>(const OTodo &toDoEvent )const;
     bool operator>=(const OTodo &toDoEvent)const;
     bool operator==(const OTodo &toDoEvent )const;
     OTodo &operator=(const OTodo &toDoEvent );
 
     static int rtti();
 
  private:
     class OTodoPrivate;
     struct OTodoData;
 
     void deref();
     inline void changeOrModify();
     void copy( OTodoData* src, OTodoData* dest );
     OTodoPrivate *d;
     OTodoData *data;
 
 };
 inline bool OTodo::operator!=(const OTodo &toDoEvent )const {
     return !(*this == toDoEvent);
 }
 
 
 #endif