31 files changed, 1207 insertions, 98 deletions

diff --git a/libopie2/opiepim/backend/otodoaccessbackend.h b/libopie2/opiepim/backend/otodoaccessbackend.h
index 3bad6b7..7944a2c 100644
--- a/libopie2/opiepim/backend/otodoaccessbackend.h
+++ b/libopie2/opiepim/backend/otodoaccessbackend.h
@@ -14,6 +14,7 @@ public:
     virtual QArray<int> overDue() = 0;
     virtual QArray<int> sorted( bool asc, int sortOrder, int sortFilter,
                                 int cat ) = 0;
+    virtual void        removeAllCompleted() = 0;
 
 };
 
diff --git a/libopie2/opiepim/backend/otodoaccessvcal.cpp b/libopie2/opiepim/backend/otodoaccessvcal.cpp
index ac70ea0..e96cc3c 100644
--- a/libopie2/opiepim/backend/otodoaccessvcal.cpp
+++ b/libopie2/opiepim/backend/otodoaccessvcal.cpp
@@ -154,6 +154,12 @@ bool OTodoAccessVCal::remove( int uid ) {
     m_dirty = true;
     return true;
 }
+void OTodoAccessVCal::removeAllCompleted() {
+    for ( QMap<int, OTodo>::Iterator it = m_map.begin(); it != m_map.end(); ++it ) {
+        if ( (*it).isCompleted() )
+            m_map.remove( it );
+    }
+}
 bool OTodoAccessVCal::replace( const OTodo& to ) {
     m_map.replace( to.uid(), to );
     m_dirty = true;
diff --git a/libopie2/opiepim/backend/otodoaccessvcal.h b/libopie2/opiepim/backend/otodoaccessvcal.h
index 4499a7e..452f602 100644
--- a/libopie2/opiepim/backend/otodoaccessvcal.h
+++ b/libopie2/opiepim/backend/otodoaccessvcal.h
@@ -26,6 +26,8 @@ public:
     bool remove( int uid );
     bool replace( const OTodo& );
 
+    void removeAllCompleted();
+
 private:
     bool m_dirty : 1;
     QString m_file;
diff --git a/libopie2/opiepim/backend/otodoaccessxml.cpp b/libopie2/opiepim/backend/otodoaccessxml.cpp
index c1682c6..b2dfe80 100644
--- a/libopie2/opiepim/backend/otodoaccessxml.cpp
+++ b/libopie2/opiepim/backend/otodoaccessxml.cpp
@@ -28,7 +28,7 @@ bool OTodoAccessXML::load() {
     /*
      * UPDATE dict if you change anything!!!
      */
-    QAsciiDict<int> dict(15);
+    QAsciiDict<int> dict(21);
     dict.setAutoDelete( TRUE );
     dict.insert("Categories" ,     new int(OTodo::Category)         );
     dict.insert("Uid" ,            new int(OTodo::Uid)              );
@@ -43,11 +43,15 @@ bool OTodoAccessXML::load() {
     dict.insert("Progress" ,       new int(OTodo::Progress)         );
     dict.insert("Completed",       new int(OTodo::Completed)        );
     dict.insert("CrossReference",  new int(OTodo::CrossReference)   );
-    dict.insert("HasAlarmDateTime",new int(OTodo::HasAlarmDateTime) );
-    dict.insert("AlarmDateTime",   new int(OTodo::AlarmDateTime)    );
+    dict.insert("State",           new int(OTodo::State)            );
+    dict.insert("Recurrence",      new int(OTodo::Recurrence)       );
+    dict.insert("Alarms",          new int(OTodo::Alarms)           );
+    dict.insert("Reminders",       new int(OTodo::Reminders)        );
+    dict.insert("Notifiers",       new int(OTodo::Notifiers)        );
+    dict.insert("Maintainer",      new int(OTodo::Maintainer)       );
 
     // here the custom XML parser from TT it's GPL
-    // but we want to push that to TT.....
+    // but we want to push OpiePIM... to TT.....
     QFile f(m_file );
     if (!f.open(IO_ReadOnly) )
         return false;
@@ -336,14 +340,6 @@ void OTodoAccessXML::todo( QAsciiDict<int>* dict, OTodo& ev,
         }
         break;
     }
-    case OTodo::HasAlarmDateTime:
-        ev.setHasAlarmDateTime( val.toInt() );
-        break;
-    case OTodo::AlarmDateTime: {
-        /* this sounds better ;) zecke */
-        ev.setAlarmDateTime( TimeConversion::fromISO8601( val.local8Bit() ) );
-        break;
-    }
     default:
         break;
     }
@@ -383,7 +379,6 @@ QString OTodoAccessXML::toString( const OTodo& ev )const {
     */
     // cross refernce
 
-    str += "AlarmDateTime=\"" + TimeConversion::toISO8601( ev.alarmDateTime() ) + "\" ";
 
     return str;
 }
@@ -616,3 +611,9 @@ QArray<int> OTodoAccessXML::sorted( bool asc,  int sortOrder,
     qWarning("array count = %d %d", array.count(), vector.count() );
     return array;
 };
+void OTodoAccessXML::removeAllCompleted() {
+    for ( QMap<int, OTodo>::Iterator it = m_events.begin(); it != m_events.end(); ++it ) {
+        if ( (*it).isCompleted() )
+            m_events.remove( it );
+    }
+}
diff --git a/libopie2/opiepim/backend/otodoaccessxml.h b/libopie2/opiepim/backend/otodoaccessxml.h
index dc41c32..93609fe 100644
--- a/libopie2/opiepim/backend/otodoaccessxml.h
+++ b/libopie2/opiepim/backend/otodoaccessxml.h
@@ -29,6 +29,7 @@ public:
     void clear();
     bool add( const OTodo& );
     bool remove( int uid );
+    void removeAllCompleted();
     bool replace( const OTodo& );
 
     /* our functions */
diff --git a/libopie2/opiepim/core/opimaccesstemplate.h b/libopie2/opiepim/core/opimaccesstemplate.h
index 6de68b1..8cf81c8 100644
--- a/libopie2/opiepim/core/opimaccesstemplate.h
+++ b/libopie2/opiepim/core/opimaccesstemplate.h
@@ -93,6 +93,7 @@ public:
      * @return <i>true</i> if added successfully.
      */
     virtual bool add( const T& t ) ;
+    bool add( const OPimRecord& );
 
     /* only the uid matters */
     /**
@@ -212,6 +213,15 @@ bool OPimAccessTemplate<T>::add( const T& t ) {
     return m_backEnd->add( t );
 }
 template <class T>
+bool OPimAccessTemplate<T>::add( const OPimRecord& rec) {
+    /* same type */
+    if ( rec.rtti() == T::rtti() ) {
+        const T &t = static_cast<const T&>(rec);
+        return add(t);
+    }
+    return false;
+}
+template <class T>
 bool OPimAccessTemplate<T>::remove( const T& t ) {
     return remove( t.uid() );
 }
diff --git a/libopie2/opiepim/core/opimmaintainer.cpp b/libopie2/opiepim/core/opimmaintainer.cpp
index e34f035..92cb25a 100644
--- a/libopie2/opiepim/core/opimmaintainer.cpp
+++ b/libopie2/opiepim/core/opimmaintainer.cpp
@@ -1,6 +1,6 @@
 #include "opimmaintainer.h"
 
-OPimMaintainer::OPimMaintainer( enum Mode mode, int uid )
+OPimMaintainer::OPimMaintainer( int mode, int uid )
     :  m_mode(mode), m_uid(uid )
 {}
 OPimMaintainer::~OPimMaintainer() {
@@ -23,13 +23,13 @@ bool OPimMaintainer::operator==( const OPimMaintainer& main ) {
 bool OPimMaintainer::operator!=( const OPimMaintainer& main ) {
     return !(*this == main );
 }
-OPimMaintainer::Mode OPimMaintainer::mode()const {
+int OPimMaintainer::mode()const {
     return m_mode;
 }
 int OPimMaintainer::uid()const {
     return m_uid;
 }
-void OPimMaintainer::setMode( enum Mode mo) {
+void OPimMaintainer::setMode( int mo) {
     m_mode = mo;
 }
 void OPimMaintainer::setUid( int uid ) {
diff --git a/libopie2/opiepim/core/opimmaintainer.h b/libopie2/opiepim/core/opimmaintainer.h
index 310e15a..793d066 100644
--- a/libopie2/opiepim/core/opimmaintainer.h
+++ b/libopie2/opiepim/core/opimmaintainer.h
@@ -9,10 +9,12 @@
 class OPimMaintainer {
 public:
     enum Mode { Undefined = -1,
-                Responsible = 0,
+                Nothing = 0,
+                Responsible,
                 DoneBy,
-                Coordinating };
-    OPimMaintainer( enum Mode mode = Undefined, int uid = 0);
+                Coordinating,
+    };
+    OPimMaintainer( int mode = Undefined, int uid = 0);
     OPimMaintainer( const OPimMaintainer& );
     ~OPimMaintainer();
 
@@ -21,15 +23,17 @@ public:
     bool operator!=( const OPimMaintainer& );
 
 
-    Mode mode()const;
+    int mode()const;
     int uid()const;
 
-    void setMode( enum Mode );
+    void setMode( int mode );
     void setUid( int uid );
 
 private:
-    Mode m_mode;
+    int m_mode;
     int m_uid;
+    class Private;
+    Private *d;
 
 };
 
diff --git a/libopie2/opiepim/core/opimnotify.cpp b/libopie2/opiepim/core/opimnotify.cpp
new file mode 100644
index 0000000..af5514b
--- a/dev/null
+++ b/libopie2/opiepim/core/opimnotify.cpp
@@ -0,0 +1,227 @@
+#include <qshared.h>
+
+#include "opimnotify.h"
+
+struct OPimNotify::Data : public QShared {
+    Data() : QShared(),dur(-1),parent(0) {
+
+    }
+    QDateTime start;
+    int dur;
+    QString application;
+    int parent;
+};
+
+OPimNotify::OPimNotify( const QDateTime& start, int duration, int parent ) {
+    data = new Data;
+    data->start = start;
+    data->dur = duration;
+    data->parent = parent;
+}
+OPimNotify::OPimNotify( const OPimNotify& noti)
+    : data( noti.data )
+{
+    data->ref();
+}
+OPimNotify::~OPimNotify() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0l;
+    }
+}
+
+OPimNotify &OPimNotify::operator=( const OPimNotify& noti) {
+    noti.data->ref();
+    deref();
+    data = noti.data;
+
+    return *this;
+}
+bool OPimNotify::operator==( const OPimNotify& noti ) {
+    if ( data == noti.data ) return true;
+    if ( data->dur != noti.data->dur ) return false;
+    if ( data->parent != noti.data->parent ) return false;
+    if ( data->application != noti.data->application ) return false;
+    if ( data->start != noti.data->start ) return false;
+
+    return true;
+}
+QDateTime OPimNotify::dateTime()const {
+    return data->start;
+}
+QString OPimNotify::service()const {
+    return data->application;
+}
+int OPimNotify::parent()const {
+    return data->parent;
+}
+int OPimNotify::duration()const {
+    return data->dur;
+}
+QDateTime OPimNotify::endTime()const {
+    return QDateTime( data->start.date(), data->start.time().addSecs( data->dur) );
+}
+void OPimNotify::setDateTime( const QDateTime& time ) {
+    copyIntern();
+    data->start = time;
+}
+void OPimNotify::setDuration( int dur ) {
+    copyIntern();
+    data->dur = dur;
+}
+void OPimNotify::setParent( int uid ) {
+    copyIntern();
+    data->parent = uid;
+}
+void OPimNotify::setService( const QString& str ) {
+    copyIntern();
+    data->application = str;
+}
+void OPimNotify::copyIntern() {
+    if ( data->count != 1 ) {
+        data->deref();
+        Data* dat = new Data;
+        dat->start = data->start;
+        dat->dur   = data->dur;
+        dat->application = data->application;
+        dat->parent = data->parent;
+        data = dat;
+    }
+}
+void OPimNotify::deref() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0;
+    }
+}
+
+/***********************************************************/
+struct OPimAlarm::Data : public QShared {
+    Data() : QShared() {
+        sound = 1;
+    }
+    int sound;
+    QString file;
+};
+OPimAlarm::OPimAlarm( int sound, const QDateTime& start, int duration, int parent )
+    : OPimNotify( start, duration, parent )
+{
+    data = new Data;
+    data->sound = sound;
+}
+OPimAlarm::OPimAlarm( const OPimAlarm& al)
+    : OPimNotify(al), data( al.data )
+{
+    data->ref();
+}
+OPimAlarm::~OPimAlarm() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0l;
+    }
+}
+OPimAlarm &OPimAlarm::operator=( const OPimAlarm& al)
+{
+    OPimNotify::operator=( al );
+    deref();
+    al.data->ref();
+
+    data = al.data;
+
+
+    return *this;
+}
+bool OPimAlarm::operator==( const OPimAlarm& al) {
+    if ( data->sound != al.data->sound ) return false;
+    else if ( data->sound == Custom && data->file != al.data->file )
+        return false;
+
+    return OPimNotify::operator==( al );
+}
+QString OPimAlarm::type()const {
+    return QString::fromLatin1("OPimAlarm");
+}
+int OPimAlarm::sound()const {
+    return data->sound;
+}
+QString OPimAlarm::file()const {
+    return data->file;
+}
+void OPimAlarm::setSound( int snd) {
+    copyIntern();
+    data->sound = snd;
+}
+void OPimAlarm::setFile( const QString& sound ) {
+    copyIntern();
+    data->file = sound;
+}
+void OPimAlarm::deref() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0l;
+    }
+}
+void OPimAlarm::copyIntern() {
+    if ( data->count != 1 ) {
+        data->deref();
+        Data *newDat = new Data;
+        newDat->sound = data->sound;
+        newDat->file  = data->file;
+        data = newDat;
+    }
+}
+/************************/
+struct OPimReminder::Data : public QShared {
+    Data() : QShared(), record( 0) {
+    }
+    int record;
+
+};
+OPimReminder::OPimReminder( int uid, const QDateTime& start,  int dur, int parent )
+    : OPimNotify( start, dur, parent )
+{
+    data = new Data;
+    data->record = uid;
+}
+OPimReminder::OPimReminder( const OPimReminder& rem )
+    :  OPimNotify( rem ), data( rem.data )
+{
+    data->ref();
+}
+OPimReminder& OPimReminder::operator=( const OPimReminder& rem) {
+    OPimNotify::operator=(rem );
+
+    deref();
+    rem.data->ref();
+    data = rem.data;
+
+    return *this;
+}
+bool OPimReminder::operator==( const OPimReminder& rem) {
+    if ( data->record != rem.data->record ) return false;
+
+    return OPimNotify::operator==( rem );
+}
+QString OPimReminder::type()const {
+    return QString::fromLatin1("OPimReminder");
+}
+int OPimReminder::recordUid()const {
+    return data->record;
+}
+void OPimReminder::setRecordUid( int uid ) {
+    copyIntern();
+    data->record = uid;
+}
+void OPimReminder::deref() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0l;
+    }
+}
+void OPimReminder::copyIntern() {
+    if ( data->count != 1 ) {
+        Data* da = new Data;
+        da->record = data->record;
+        data = da;
+    }
+}
diff --git a/libopie2/opiepim/core/opimnotify.h b/libopie2/opiepim/core/opimnotify.h
new file mode 100644
index 0000000..3501948
--- a/dev/null
+++ b/libopie2/opiepim/core/opimnotify.h
@@ -0,0 +1,142 @@
+#ifndef OPIE_PIM_NOTIFY_H
+#define OPIE_PIM_NOTIFY_H
+
+#include <qdatetime.h>
+#include <qvaluelist.h>
+
+/**
+ * This is the base class of Notifiers. Possible
+ * notifiers would be Alarms, Reminders
+ * What they share is that they have
+ * A DateTime, Type, Duration
+ * This is what this base class takes care of
+ * on top of that it's shared
+ */
+/*
+ * TALK to eilers: have a class OPimDuration which sets the Duration
+ *                 given on the Due/Start Date? -zecke
+ * discuss: do we need a uid for the notify? -zecke
+ */
+class OPimNotify {
+public:
+    typedef QValueList<OPimNotify> ValueList;
+    OPimNotify( const QDateTime& start = QDateTime(), int duration = 0, int parent = 0 );
+    OPimNotify( const OPimNotify& );
+    virtual ~OPimNotify();
+
+    OPimNotify &operator=(const OPimNotify& );
+    bool operator==( const OPimNotify& );
+
+    virtual QString type()const = 0;
+
+    /** start date */
+    QDateTime dateTime()const;
+    QString service()const;
+
+    /**
+     * RETURN the parent uid
+     */
+    int parent()const;
+
+    /**
+     * in Seconds
+     */
+    int duration()const;
+
+    /**
+     * Start Time + Duration
+     */
+    QDateTime endTime()const;
+
+    void setDateTime( const QDateTime& );
+    void setDuration( int dur );
+    void setParent(int uid );
+    void setService( const QString& );
+
+
+private:
+    inline void copyIntern();
+    void deref();
+    struct Data;
+    Data* data;
+
+    /* d-pointer */
+    class NotifyPrivate;
+    NotifyPrivate* d;
+
+};
+/**
+ * An alarm is a sound/mail/buzzer played/send
+ * at a given time to inform about
+ * an Event
+ */
+class OPimAlarm : public OPimNotify {
+public:
+    enum Sound{Loud=0, Silent, Custom };
+    OPimAlarm( int sound = Silent, const QDateTime& start = QDateTime(), int duration = 0, int parent = 0 );
+    OPimAlarm( const OPimAlarm& );
+    ~OPimAlarm();
+
+    OPimAlarm &operator=( const OPimAlarm& );
+    bool operator==( const OPimAlarm& );
+    QString type()const;
+
+    int sound()const;
+    QString file()const;
+
+    void setSound( int );
+    /* only when sound is custom... */
+    void setFile( const QString& sound );
+
+private:
+    void deref();
+    void copyIntern();
+    struct Data;
+    Data * data;
+
+    class Private;
+    Private* d;
+
+};
+
+/**
+ * A Reminder will be put into the
+ * datebook
+ */
+class OPimReminder : public OPimNotify {
+public:
+
+    /**
+     * c'tor of a reminder
+     * @param uid The uid of the Record inside the Datebook
+     * @param start the StartDate invalid for all day...
+     * @param duration The duration of the event ( -1 for all day )
+     * @param parent The 'parent' record of this reminder
+     */
+    OPimReminder( int uid = 0,  const QDateTime& start = QDateTime(),
+                  int duration = 0, int parent = 0  );
+    OPimReminder( const OPimReminder& );
+    OPimReminder &operator=(const OPimReminder& );
+
+    QString type()const;
+
+    bool operator==( const OPimReminder& );
+
+    /**
+     * the uid of the alarm
+     * inside the 'datebook' application
+     */
+    int recordUid()const;
+    void setRecordUid( int uid );
+
+private:
+    void deref();
+    void copyIntern();
+
+    struct Data;
+    Data* data;
+    class Private;
+    Private *d;
+};
+
+#endif
diff --git a/libopie2/opiepim/core/opimnotifymanager.cpp b/libopie2/opiepim/core/opimnotifymanager.cpp
new file mode 100644
index 0000000..be4a1c2
--- a/dev/null
+++ b/libopie2/opiepim/core/opimnotifymanager.cpp
@@ -0,0 +1,69 @@
+#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& ) {
+
+}
diff --git a/libopie2/opiepim/core/opimnotifymanager.h b/libopie2/opiepim/core/opimnotifymanager.h
new file mode 100644
index 0000000..0eebc9b
--- a/dev/null
+++ b/libopie2/opiepim/core/opimnotifymanager.h
@@ -0,0 +1,51 @@
+#ifndef OPIE_PIM_NOTIFY_MANAGER_H
+#define OPIE_PIM_NOTIFY_MANAGER_H
+
+#include <qvaluelist.h>
+
+#include <opie/opimnotify.h>
+
+/**
+ * The notify manager keeps track of the Notifiers....
+ */
+class OPimNotifyManager {
+public:
+    typedef QValueList<OPimReminder> Reminders;
+    typedef QValueList<OPimAlarm>    Alarms;
+    OPimNotifyManager( const Reminders& rems = Reminders(), const Alarms& alarms = Alarms() );
+    ~OPimNotifyManager();
+
+    /* we will cast it for you ;) */
+    void add( const OPimNotify& );
+    void remove( const OPimNotify& );
+    /* replaces all with this one! */
+    void replace( const OPimNotify& );
+
+    Reminders reminders()const;
+    Alarms    alarms()const;
+
+    void setAlarms( const Alarms& );
+    void setReminders( const Reminders& );
+
+    /* register is a Ansi C keyword... */
+    /**
+     * This function will register the Notify to the Alarm Server
+     * or datebook depending on the type of the notify
+     */
+    void registerNotify( const OPimNotify& );
+
+    /**
+     * this will do the opposite..
+     */
+    void deregister( const OPimNotify& );
+
+private:
+    Reminders m_rem;
+    Alarms m_al;
+
+    class Private;
+    Private *d;
+
+};
+
+#endif
diff --git a/libopie2/opiepim/core/opimrecord.cpp b/libopie2/opiepim/core/opimrecord.cpp
index 0e3be9d..49b5bf9 100644
--- a/libopie2/opiepim/core/opimrecord.cpp
+++ b/libopie2/opiepim/core/opimrecord.cpp
@@ -79,3 +79,6 @@ Qtopia::UidGen &OPimRecord::uidGen() {
 OPimXRefManager &OPimRecord::xrefmanager() {
     return m_xrefman;
 }
+int OPimRecord::rtti(){
+    return 0;
+}
diff --git a/libopie2/opiepim/core/opimrecord.h b/libopie2/opiepim/core/opimrecord.h
index 1642a5e..ec99a13 100644
--- a/libopie2/opiepim/core/opimrecord.h
+++ b/libopie2/opiepim/core/opimrecord.h
@@ -89,8 +89,8 @@ public:
     /**
      * returns a reference of the
      * Cross Reference Manager
-     * Partner One is THIS PIM RECORD!
-     * Two is the Partner where we link to
+     * Partner 'One' is THIS PIM RECORD!
+     * 'Two' is the Partner where we link to
      */
     OPimXRefManager& xrefmanager();
 
@@ -99,6 +99,12 @@ public:
      */
     virtual void setUid( int uid );
 
+    /*
+     * used inside the Templates for casting
+     * REIMPLEMENT in your ....
+     */
+    static int rtti();
+
 protected:
     Qtopia::UidGen &uidGen();
 //    QString crossToString()const;
diff --git a/libopie2/opiepim/core/opimresolver.h b/libopie2/opiepim/core/opimresolver.h
new file mode 100644
index 0000000..86ae3eb
--- a/dev/null
+++ b/libopie2/opiepim/core/opimresolver.h
@@ -0,0 +1,56 @@
+#ifndef OPIE_PIM_RESOLVER
+#define OPIE_PIM_RESOLVER
+
+#include <qstring.h>
+#include <qvaluelist.h>
+
+/**
+ * OPimResolver is a MetaClass to access
+ * available backends read only.
+ * It will be used to resolve uids + app names
+ * to full informations
+ * to traverse through a list of alarms, reminders
+ * to get access to built in PIM functionality
+ * and to more stuff
+ * THE PERFORMANCE will depend on THE BACKEND
+ * USING XML is a waste of memory!!!!!
+ */
+class OPimResolver : public QObject {
+public:
+    enum BuiltIn { TodoList = 0,
+                   DateBook,
+                   AddressBook
+    };
+    static OPimResolver* self();
+
+
+    /*
+     * return a record for a uid
+     * and an app
+     */
+    OPimRecord &record( const QString& service, int uid );
+
+    /**
+     * return the QCopChannel for service
+     * When we will use Qtopia Services it will be used here
+     */
+    QString qcopChannel( enum BuiltIn& )const;
+    QString qcopChannel( const QString& service );
+
+    /**
+     * return a list of available services
+     */
+    QStringList services()const;
+
+    /**
+     * add a record to a service... ;)
+     */
+    bool add( const QString& service, const OPimRecord& );
+
+private:
+    OPimResolver();
+    OPimRecord *m_last;
+
+}:
+
+#endif
diff --git a/libopie2/opiepim/core/opimxref.cpp b/libopie2/opiepim/core/opimxref.cpp
index 5cae871..8eefbd8 100644
--- a/libopie2/opiepim/core/opimxref.cpp
+++ b/libopie2/opiepim/core/opimxref.cpp
@@ -34,8 +34,8 @@ void OPimXRef::setPartner( enum Partners par,  const OPimXRefPartner& part) {
     m_partners[par] = part;
 }
 bool OPimXRef::containsString( const QString& string ) const{
-    if ( m_partners[One].appName() == string ||
-         m_partners[Two].appName() == string ) return true;
+    if ( m_partners[One].service() == string ||
+         m_partners[Two].service() == string ) return true;
 
     return false;
 }
diff --git a/libopie2/opiepim/core/opimxref.h b/libopie2/opiepim/core/opimxref.h
index 354739a..6852651 100644
--- a/libopie2/opiepim/core/opimxref.h
+++ b/libopie2/opiepim/core/opimxref.h
@@ -26,7 +26,7 @@ public:
 
     void setPartner( enum Partners,  const OPimXRefPartner& );
 
-    bool containsString( const QString& appName)const;
+    bool containsString( const QString& service)const;
     bool containsUid( int uid )const;
 
 private:
diff --git a/libopie2/opiepim/core/opimxrefmanager.cpp b/libopie2/opiepim/core/opimxrefmanager.cpp
index 965f542..58bfd24 100644
--- a/libopie2/opiepim/core/opimxrefmanager.cpp
+++ b/libopie2/opiepim/core/opimxrefmanager.cpp
@@ -36,10 +36,10 @@ QStringList OPimXRefManager::apps()const {
 
     QString str;
     for ( it = m_list.begin(); it != m_list.end(); ++it ) {
-        str = (*it).partner( OPimXRef::One ).appName();
+        str = (*it).partner( OPimXRef::One ).service();
         if ( !list.contains( str ) ) list << str;
 
-        str = (*it).partner( OPimXRef::Two ).appName();
+        str = (*it).partner( OPimXRef::Two ).service();
         if ( !list.contains( str ) ) list << str;
     }
     return list;
diff --git a/libopie2/opiepim/core/opimxrefmanager.h b/libopie2/opiepim/core/opimxrefmanager.h
index 9b003a3..39e5eef 100644
--- a/libopie2/opiepim/core/opimxrefmanager.h
+++ b/libopie2/opiepim/core/opimxrefmanager.h
@@ -31,7 +31,7 @@ public:
      */
     QStringList apps()const;
     OPimXRef::ValueList list()const;
-    OPimXRef::ValueList list( const QString& appName )const;
+    OPimXRef::ValueList list( const QString& service )const;
     OPimXRef::ValueList list( int uid )const;
 
 private:
diff --git a/libopie2/opiepim/core/opimxrefpartner.cpp b/libopie2/opiepim/core/opimxrefpartner.cpp
index 028f4e6..6ef3efb 100644
--- a/libopie2/opiepim/core/opimxrefpartner.cpp
+++ b/libopie2/opiepim/core/opimxrefpartner.cpp
@@ -23,7 +23,7 @@ bool OPimXRefPartner::operator==( const OPimXRefPartner& par ) {
 
     return true;
 }
-QString OPimXRefPartner::appName()const {
+QString OPimXRefPartner::service()const {
     return m_app;
 }
 int OPimXRefPartner::uid()const {
@@ -32,7 +32,7 @@ int OPimXRefPartner::uid()const {
 int OPimXRefPartner::field()const {
     return m_field;
 }
-void OPimXRefPartner::setAppName( const QString& appName ) {
+void OPimXRefPartner::setService( const QString& appName ) {
     m_app = appName;
 }
 void OPimXRefPartner::setUid( int uid ) {
diff --git a/libopie2/opiepim/core/opimxrefpartner.h b/libopie2/opiepim/core/opimxrefpartner.h
index 808b9ab..d76e384 100644
--- a/libopie2/opiepim/core/opimxrefpartner.h
+++ b/libopie2/opiepim/core/opimxrefpartner.h
@@ -12,7 +12,7 @@
  */
 class OPimXRefPartner {
 public:
-    OPimXRefPartner( const QString& appName = QString::null,
+    OPimXRefPartner( const QString& service = QString::null,
                      int uid = 0, int field = -1 );
     OPimXRefPartner( const OPimXRefPartner& );
     OPimXRefPartner& operator=( const OPimXRefPartner& );
@@ -20,11 +20,11 @@ public:
 
     bool operator==(const OPimXRefPartner& );
 
-    QString appName()const;
+    QString service()const;
     int uid()const;
     int field()const;
 
-    void setAppName( const QString& appName );
+    void setService( const QString& service );
     void setUid( int uid );
     void setField( int field );
 private:
diff --git a/libopie2/opiepim/core/orecur.cpp b/libopie2/opiepim/core/orecur.cpp
index 257d4fd..daf3506 100644
--- a/libopie2/opiepim/core/orecur.cpp
+++ b/libopie2/opiepim/core/orecur.cpp
@@ -22,6 +22,9 @@ struct ORecur::Data : public QShared {
     time_t end;
     time_t create;
     int rep;
+    QString app;
+    ExceptionList list;
+    QDate start;
 };
 
 
@@ -55,6 +58,298 @@ ORecur &ORecur::operator=( const ORecur& re) {
 
     return *this;
 }
+bool ORecur::doesRecur()const {
+    return !( type() == NoRepeat );
+}
+/*
+ * we try to be smart here
+ *
+ */
+bool ORecur::doesRecur( const QDate& date ) {
+    /* the day before the recurrance */
+    QDate da = date.addDays(-1);
+
+    QDate recur;
+    if (!nextOcurrence( da, recur ) )
+        return false;
+
+    return (recur == date);
+}
+// FIXME unuglify!
+// GPL from Datebookdb.cpp
+// FIXME exception list!
+bool ORecur::nextOcurrence( const QDate& from, QDate& next ) {
+
+   // easy checks, first are we too far in the future or too far in the past?
+    QDate tmpDate;
+    int freq = frequency();
+    int diff, diff2, a;
+    int iday, imonth, iyear;
+    int dayOfWeek = 0;
+    int firstOfWeek = 0;
+    int weekOfMonth;
+
+
+    if (hasEndDate() && endDate() < from)
+        return FALSE;
+
+    if (start() >= from) {
+        next = start();
+        return TRUE;
+    }
+
+    switch ( type() ) {
+        case Weekly:
+            /* weekly is just daily by 7 */
+            /* first convert the repeatPattern.Days() mask to the next
+               day of week valid after from */
+            dayOfWeek = from.dayOfWeek();
+            dayOfWeek--; /* we want 0-6, doco for above specs 1-7 */
+
+            /* this is done in case freq > 1 and from in week not
+               for this round */
+            // firstOfWeek = 0; this is already done at decl.
+            while(!((1 << firstOfWeek) & days() ))
+                firstOfWeek++;
+
+            /* there is at least one 'day', or there would be no event */
+            while(!((1 << (dayOfWeek % 7)) & days() ))
+                dayOfWeek++;
+
+            dayOfWeek = dayOfWeek % 7; /* the actual day of week */
+            dayOfWeek -= start().dayOfWeek() -1;
+
+            firstOfWeek = firstOfWeek % 7; /* the actual first of week */
+            firstOfWeek -= start().dayOfWeek() -1;
+
+            // dayOfWeek may be negitive now
+            // day of week is number of days to add to start day
+
+            freq *= 7;
+            // FALL-THROUGH !!!!!
+        case Daily:
+            // the add is for the possible fall through from weekly */
+            if(start().addDays(dayOfWeek) > from) {
+                /* first week exception */
+                next = QDate(start().addDays(dayOfWeek) );
+                if ((next > endDate())
+                    && hasEndDate() )
+                    return FALSE;
+                return TRUE;
+            }
+            /* if from is middle of a non-week */
+
+            diff = start().addDays(dayOfWeek).daysTo(from) % freq;
+            diff2 = start().addDays(firstOfWeek).daysTo(from) % freq;
+
+            if(diff != 0)
+                diff = freq - diff;
+            if(diff2 != 0)
+                diff2 = freq - diff2;
+            diff = QMIN(diff, diff2);
+
+            next = QDate(from.addDays(diff));
+            if ( (next > endDate())
+                 && hasEndDate() )
+                return FALSE;
+            return TRUE;
+        case MonthlyDay:
+            iday = from.day();
+            iyear = from.year();
+            imonth = from.month();
+            /* find equivelent day of month for this month */
+            dayOfWeek = start().dayOfWeek();
+            weekOfMonth = (start().day() - 1) / 7;
+
+            /* work out when the next valid month is */
+            a = from.year() - start().year();
+            a *= 12;
+            a = a + (imonth - start().month());
+            /* a is e.start()monthsFrom(from); */
+            if(a % freq) {
+                a = freq - (a % freq);
+                imonth = from.month() + a;
+                if (imonth > 12) {
+                    imonth--;
+                    iyear += imonth / 12;
+                    imonth = imonth % 12;
+                    imonth++;
+                }
+            }
+            /* imonth is now the first month after or on
+               from that matches the frequency given */
+
+            /* find for this month */
+            tmpDate = QDate( iyear, imonth, 1 );
+
+            iday = 1;
+            iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
+            iday += 7 * weekOfMonth;
+            while (iday > tmpDate.daysInMonth()) {
+                imonth += freq;
+                if (imonth > 12) {
+                    imonth--;
+                    iyear += imonth / 12;
+                    imonth = imonth % 12;
+                    imonth++;
+                }
+                tmpDate = QDate( iyear, imonth, 1 );
+                /* these loops could go for a while, check end case now */
+                if ((tmpDate > endDate()) && hasEndDate() )
+                    return FALSE;
+                iday = 1;
+                iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
+                iday += 7 * weekOfMonth;
+            }
+            tmpDate = QDate(iyear, imonth, iday);
+
+            if (tmpDate >= from) {
+                next = tmpDate;
+                if ((next > endDate() ) && hasEndDate() )
+                    return FALSE;
+                return TRUE;
+            }
+
+            /* need to find the next iteration */
+            do {
+                imonth += freq;
+                if (imonth > 12) {
+                    imonth--;
+                    iyear += imonth / 12;
+                    imonth = imonth % 12;
+                    imonth++;
+                }
+                tmpDate = QDate( iyear, imonth, 1 );
+                /* these loops could go for a while, check end case now */
+                if ((tmpDate > endDate()) && hasEndDate() )
+                    return FALSE;
+                iday = 1;
+                iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
+                iday += 7 * weekOfMonth;
+            } while (iday > tmpDate.daysInMonth());
+            tmpDate = QDate(iyear, imonth, iday);
+
+            next = tmpDate;
+            if ((next > endDate()) && hasEndDate() )
+                return FALSE;
+            return TRUE;
+        case MonthlyDate:
+            iday = start().day();
+            iyear = from.year();
+            imonth = from.month();
+
+            a = from.year() - start().year();
+            a *= 12;
+            a = a + (imonth - start().month());
+            /* a is e.start()monthsFrom(from); */
+            if(a % freq) {
+                a = freq - (a % freq);
+                imonth = from.month() + a;
+                if (imonth > 12) {
+                    imonth--;
+                    iyear += imonth / 12;
+                    imonth = imonth % 12;
+                    imonth++;
+                }
+            }
+            /* imonth is now the first month after or on
+               from that matches the frequencey given */
+
+            /* this could go for a while, worse case, 4*12 iterations, probably */
+            while(!QDate::isValid(iyear, imonth, iday) ) {
+                imonth += freq;
+                if (imonth > 12) {
+                    imonth--;
+                    iyear += imonth / 12;
+                    imonth = imonth % 12;
+                    imonth++;
+                }
+                /* these loops could go for a while, check end case now */
+                if ((QDate(iyear, imonth, 1) > endDate()) && hasEndDate() )
+                    return FALSE;
+            }
+
+            if(QDate(iyear, imonth, iday) >= from) {
+                /* done */
+                next = QDate(iyear, imonth, iday);
+                if ((next > endDate()) && hasEndDate() )
+                    return FALSE;
+                return TRUE;
+            }
+
+            /* ok, need to cycle */
+            imonth += freq;
+            imonth--;
+            iyear += imonth / 12;
+            imonth = imonth % 12;
+            imonth++;
+
+            while(!QDate::isValid(iyear, imonth, iday) ) {
+                imonth += freq;
+                imonth--;
+                iyear += imonth / 12;
+                imonth = imonth % 12;
+                imonth++;
+                if ((QDate(iyear, imonth, 1) > endDate()) && hasEndDate() )
+                    return FALSE;
+            }
+
+            next = QDate(iyear, imonth, iday);
+            if ((next > endDate()) && hasEndDate() )
+                return FALSE;
+            return TRUE;
+        case Yearly:
+            iday = start().day();
+            imonth = start().month();
+            iyear = from.year(); // after all, we want to start in this year
+
+            diff = 1;
+            if(imonth == 2 && iday > 28) {
+                /* leap year, and it counts, calculate actual frequency */
+                if(freq % 4)
+                    if (freq % 2)
+                        freq = freq * 4;
+                    else
+                        freq = freq * 2;
+                /* else divides by 4 already, leave freq alone */
+                diff = 4;
+            }
+
+            a = from.year() - start().year();
+            if(a % freq) {
+                a = freq - (a % freq);
+                iyear = iyear + a;
+            }
+
+            /* under the assumption we won't hit one of the special not-leap years twice */
+            if(!QDate::isValid(iyear, imonth, iday)) {
+                /* must have been skipping by leap years and hit one that wasn't, (e.g. 2100) */
+                iyear += freq;
+            }
+
+            if(QDate(iyear, imonth, iday) >= from) {
+                next = QDate(iyear, imonth, iday);
+
+                if ((next > endDate()) && hasEndDate() )
+                    return FALSE;
+                return TRUE;
+            }
+            /* iyear == from.year(), need to advance again */
+            iyear += freq;
+            /* under the assumption we won't hit one of the special not-leap years twice */
+            if(!QDate::isValid(iyear, imonth, iday)) {
+                /* must have been skipping by leap years and hit one that wasn't, (e.g. 2100) */
+                iyear += freq;
+            }
+
+            next = QDate(iyear, imonth, iday);
+            if ((next > endDate()) && hasEndDate() )
+                return FALSE;
+            return TRUE;
+        default:
+            return FALSE;
+    }
+}
 ORecur::RepeatType ORecur::type()const{
     return data->type;
 }
@@ -73,6 +368,9 @@ bool ORecur::hasEndDate()const {
 QDate ORecur::endDate()const {
     return TimeConversion::fromUTC( data->end ).date();
 }
+QDate ORecur::start()const{
+    return data->start;
+}
 time_t ORecur::endDateUTC()const {
     return data->end;
 }
@@ -82,6 +380,12 @@ time_t ORecur::createTime()const {
 int ORecur::repetition()const {
     return data->rep;
 }
+QString ORecur::service()const {
+    return data->app;
+}
+ORecur::ExceptionList& ORecur::exceptions() {
+    return data->list;
+}
 void ORecur::setType( const RepeatType& z) {
     checkOrModify();
     data->type = z;
@@ -118,6 +422,14 @@ void ORecur::setRepitition( int rep ) {
     checkOrModify();
     data->rep = rep;
 }
+void ORecur::setService( const QString& app ) {
+    checkOrModify();
+    data->app = app;
+}
+void ORecur::setStart( const QDate& dt ) {
+    checkOrModify();
+    data->start = dt;
+}
 void ORecur::checkOrModify() {
     if ( data->count !=  1 ) {
         data->deref();
@@ -130,6 +442,9 @@ void ORecur::checkOrModify() {
         d2->end  = data->end;
         d2->create = data->create;
         d2->rep = data->rep;
+        d2->app = data->app;
+        d2->list = data->list;
+        d2->start = data->start;
         data = d2;
     }
 }
diff --git a/libopie2/opiepim/core/orecur.h b/libopie2/opiepim/core/orecur.h
index d24d72d..8713d97 100644
--- a/libopie2/opiepim/core/orecur.h
+++ b/libopie2/opiepim/core/orecur.h
@@ -8,11 +8,12 @@
 #include <sys/types.h>
 
 #include <qdatetime.h>
-
+#include <qvaluelist.h>
 
 
 class ORecur {
 public:
+    typedef QValueList<QDate> ExceptionList;
     enum RepeatType{ NoRepeat = -1, Daily, Weekly, MonthlyDay,
                      MonthlyDate, Yearly };
     enum Days { MON = 0x01, TUE = 0x02, WED = 0x04, THU = 0x08,
@@ -23,14 +24,37 @@ public:
 
     ORecur &operator=( const ORecur& );
     bool operator==(const ORecur& )const;
+
+    bool doesRecur()const;
+    /* if it recurrs on that day */
+    bool doesRecur( const QDate& );
     RepeatType type()const;
     int frequency()const;
     int position()const;
     char days()const;
     bool hasEndDate()const;
+    QDate start()const;
     QDate endDate()const;
     time_t endDateUTC()const;
     time_t createTime()const;
+
+    /**
+     * FromWhereToStart is not included!!!
+     */
+    bool nextOcurrence( const QDate& FromWhereToStart, QDate &recurDate );
+    /**
+     * The module this ORecur belongs to
+     */
+    QString service()const;
+
+    /*
+     * reference to the exception list
+     */
+    ExceptionList &exceptions();
+
+    /**
+     * the current repetition
+     */
     int repetition()const;
 
     void setType( const RepeatType& );
@@ -38,10 +62,13 @@ public:
     void setPosition( int pos );
     void setDays( char c);
     void setEndDate( const QDate& dt );
+    void setStart( const QDate& dt );
     void setEndDateUTC( time_t );
     void setCreateTime( time_t );
     void setHasEndDate( bool b );
     void setRepitition(int );
+
+    void setService( const QString& ser );
 private:
     void deref();
     inline void checkOrModify();
diff --git a/libopie2/opiepim/core/otodoaccess.cpp b/libopie2/opiepim/core/otodoaccess.cpp
index c258de6..d860411 100644
--- a/libopie2/opiepim/core/otodoaccess.cpp
+++ b/libopie2/opiepim/core/otodoaccess.cpp
@@ -45,7 +45,8 @@ OTodoAccess::List OTodoAccess::overDue() {
     return lis;
 }
 void OTodoAccess::addAlarm( const OTodo& event) {
-    if (!event.hasAlarmDateTime() )
+/* FIXME use the new notifier architecture
+  if (!event.hasAlarmDateTime() )
         return;
 
     QDateTime now      = QDateTime::currentDateTime();
@@ -57,6 +58,7 @@ void OTodoAccess::addAlarm( const OTodo& event) {
                                "alarm(QDateTime,int)", event.uid() );
 
     }
+*/
 }
 void OTodoAccess::delAlarm( int uid) {
 
@@ -79,3 +81,6 @@ OTodoAccess::List OTodoAccess::sorted( bool ascending, int sort,int filter, int
     OTodoAccess::List list( ints, this );
     return list;
 }
+void OTodoAccess::removeAllCompleted() {
+    m_todoBackEnd->removeAllCompleted();
+}
diff --git a/libopie2/opiepim/core/otodoaccess.h b/libopie2/opiepim/core/otodoaccess.h
index 390ab0e..c079155 100644
--- a/libopie2/opiepim/core/otodoaccess.h
+++ b/libopie2/opiepim/core/otodoaccess.h
@@ -68,6 +68,17 @@ public:
     void mergeWith( const QValueList<OTodo>& );
 
     /**
+     * delete all already completed items
+     */
+    void removeAllCompleted();
+
+signals:
+    /**
+     * if the OTodoAccess was changed
+     */
+    void signalChanged( const OTodoAccess* );
+private:
+    /**
      * add an Alarm to the AlarmServer
      */
     void addAlarm( const OTodo& );
@@ -78,12 +89,6 @@ public:
      */
     void delAlarm( int uid );
 
-signals:
-    /**
-     * if the OTodoAccess was changed
-     */
-    void signalChanged( const OTodoAccess* );
-private:
     int m_cat;
     OTodoAccessBackend* m_todoBackEnd;
     class OTodoAccessPrivate;
diff --git a/libopie2/opiepim/ocontact.cpp b/libopie2/opiepim/ocontact.cpp
index 917eb0a..efa2777 100644
--- a/libopie2/opiepim/ocontact.cpp
+++ b/libopie2/opiepim/ocontact.cpp
@@ -1095,7 +1095,9 @@ void OContact::insertEmails( const QStringList &v )
     for ( QStringList::ConstIterator it = v.begin(); it != v.end(); ++it )
         insertEmail( *it );
 }
-
+int OContact::rtti() {
+    return 2;
+}
 void OContact::setUid( int i )
 { 
         OPimRecord::setUid(i); 
diff --git a/libopie2/opiepim/ocontact.h b/libopie2/opiepim/ocontact.h
index d97af1c..65ba43e 100644
--- a/libopie2/opiepim/ocontact.h
+++ b/libopie2/opiepim/ocontact.h
@@ -46,7 +46,7 @@ public:
 
     enum journal_action { ACTION_ADD, ACTION_REMOVE, ACTION_REPLACE };
 
-    /* 
+    /*
      * do we need to inline them
      * if yes do we need to inline them this way?
      * -zecke
@@ -211,6 +211,7 @@ public:
     // the emails should be seperated by a comma
     void setEmails( const QString &v );
     QString emails() const { return find( Qtopia::Emails ); }
+    static int rtti();
 
 
 private:
diff --git a/libopie2/opiepim/otodo.cpp b/libopie2/opiepim/otodo.cpp
index 6fcf9f6..ece624a 100644
--- a/libopie2/opiepim/otodo.cpp
+++ b/libopie2/opiepim/otodo.cpp
@@ -15,6 +15,7 @@
 #include "opimstate.h"
 #include "orecur.h"
 #include "opimmaintainer.h"
+#include "opimnotifymanager.h"
 
 #include "otodo.h"
 
@@ -31,11 +32,12 @@ struct OTodo::OTodoData : public QShared {
     QString sum;
     QMap<QString, QString> extra;
     ushort prog;
-    bool hasAlarmDateTime :1;
-    QDateTime alarmDateTime;
     OPimState state;
     ORecur recur;
     OPimMaintainer maintainer;
+    QDate start;
+    QDate completed;
+    OPimNotifyManager notifiers;
 };
 
 OTodo::OTodo(const OTodo &event )
@@ -73,8 +75,6 @@ OTodo::OTodo(bool completed, int priority,
     data->sum = summary;
     data->prog = progress;
     data->desc = Qtopia::simplifyMultiLineSpace(description );
-    data->hasAlarmDateTime = false;
-
 }
 OTodo::OTodo(bool completed, int priority,
                      const QStringList &category,
@@ -96,8 +96,6 @@ OTodo::OTodo(bool completed, int priority,
     data->sum = summary;
     data->prog = progress;
     data->desc = Qtopia::simplifyMultiLineSpace(description );
-    data->hasAlarmDateTime = false;
-
 }
 bool OTodo::match( const QRegExp &regExp )const
 {
@@ -120,9 +118,11 @@ bool OTodo::hasDueDate() const
 {
     return data->hasDate;
 }
-bool OTodo::hasAlarmDateTime() const
-{
-    return data->hasAlarmDateTime;
+bool OTodo::hasStartDate()const {
+    return data->start.isValid();
+}
+bool OTodo::hasCompletedDate()const {
+    return data->completed.isValid();
 }
 int OTodo::priority()const
 {
@@ -140,12 +140,12 @@ QDate OTodo::dueDate()const
 {
     return data->date;
 }
-
-QDateTime OTodo::alarmDateTime() const
-{
-    return data->alarmDateTime;
+QDate OTodo::startDate()const {
+    return data->start;
+}
+QDate OTodo::completedDate()const {
+    return data->completed;
 }
-
 QString OTodo::description()const
 {
     return data->desc;
@@ -169,11 +169,6 @@ void OTodo::setHasDueDate( bool hasDate )
     changeOrModify();
     data->hasDate = hasDate;
 }
-void OTodo::setHasAlarmDateTime( bool hasAlarmDateTime )
-{
-    changeOrModify();
-    data->hasAlarmDateTime = hasAlarmDateTime;
-}
 void OTodo::setDescription(const QString &desc )
 {
 //    qWarning( "desc " + desc );
@@ -190,15 +185,18 @@ void OTodo::setPriority(int prio )
     changeOrModify();
     data->priority = prio;
 }
-void OTodo::setDueDate( QDate date )
+void OTodo::setDueDate( const QDate& date )
 {
     changeOrModify();
     data->date = date;
 }
-void OTodo::setAlarmDateTime( const QDateTime& alarm )
-{
+void OTodo::setStartDate( const QDate& date ) {
     changeOrModify();
-    data->alarmDateTime = alarm;
+    data->start = date;
+}
+void OTodo::setCompletedDate( const QDate& date ) {
+    changeOrModify();
+    data->completed = date;
 }
 void OTodo::setState( const OPimState& state ) {
     changeOrModify();
@@ -254,11 +252,6 @@ QString OTodo::toRichText() const
     text += dueDate().toString();
     text += "<br>";
   }
-  if (hasAlarmDateTime() ){
-    text += "<b>" + QObject::tr( "Alarmed Notification:") + " </b>";
-    text += alarmDateTime().toString();
-    text += "<br>";
-  }
 
   text += "<b>" + QObject::tr( "Category:") + "</b> ";
   text += categoryNames().join(", ");
@@ -266,6 +259,9 @@ QString OTodo::toRichText() const
 
   return text;
 }
+OPimNotifyManager& OTodo::notifiers() {
+    return data->notifiers;
+}
 
 bool OTodo::operator<( const OTodo &toDoEvent )const{
     if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true;
@@ -327,10 +323,6 @@ bool OTodo::operator==(const OTodo &toDoEvent )const
     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->hasAlarmDateTime != toDoEvent.data->hasAlarmDateTime )
-        return false;
-    if ( data->alarmDateTime != toDoEvent.data->alarmDateTime )
-        return false;
     if ( data->maintainer    != toDoEvent.data->maintainer )
         return false;
 
@@ -371,9 +363,11 @@ QMap<int, QString> OTodo::toMap() const {
     map.insert( DateYear, QString::number( data->date.year() ) );
     map.insert( Progress, QString::number( data->prog ) );
 //    map.insert( CrossReference, crossToString() );
-    map.insert( HasAlarmDateTime,  QString::number( data->hasAlarmDateTime ) );
-    map.insert( AlarmDateTime, data->alarmDateTime.toString() );
-
+    /* FIXME!!!   map.insert( State,  );
+    map.insert( Recurrence, );
+    map.insert( Reminders, );
+    map.
+    */
     return map;
 }
 
@@ -408,11 +402,12 @@ void OTodo::copy( OTodoData* src, OTodoData* dest ) {
     dest->sum = src->sum;
     dest->extra = src->extra;
     dest->prog = src->prog;
-    dest->hasAlarmDateTime = src->hasAlarmDateTime;
-    dest->alarmDateTime = src->alarmDateTime;
     dest->state = src->state;
     dest->recur = src->recur;
     dest->maintainer = src->maintainer;
+    dest->start = src->start;
+    dest->completed = src->completed;
+    dest->notifiers = src->notifiers;
 }
 QString OTodo::type() const {
     return QString::fromLatin1("OTodo");
@@ -421,3 +416,6 @@ QString OTodo::recordField(int /*id*/ )const {
     return QString::null;
 }
 
+int OTodo::rtti(){
+    return 1;
+}
diff --git a/libopie2/opiepim/otodo.h b/libopie2/opiepim/otodo.h
index 70b0253..2f66f55 100644
--- a/libopie2/opiepim/otodo.h
+++ b/libopie2/opiepim/otodo.h
@@ -19,6 +19,7 @@
 class OPimState;
 class ORecur;
 class OPimMaintainer;
+class OPimNotifyManager;
 class OTodo : public  OPimRecord  {
 public:
     typedef QValueList<OTodo> ValueList;
@@ -35,13 +36,14 @@ public:
         DateYear,
         Progress,
         CrossReference,
-        HasAlarmDateTime,
-        AlarmDateTime,
         State,
-        Recurrance,
+        Recurrence,
         Alarms,
         Reminders,
-        Notifiers
+        Notifiers,
+        Maintainer,
+        StartDate,
+        CompletedDate
     };
  public:
     // priorities from Very low to very high
@@ -73,9 +75,9 @@ public:
            bool hasDate = false,  QDate date = QDate::currentDate(),
            int uid = 0 /* empty */ );
 
-    /* Copy c'tor
-
-    **/
+    /** Copy c'tor
+     *
+     */
     OTodo(const OTodo & );
 
     /**
@@ -92,6 +94,8 @@ public:
      * Does this Event have a deadline
      */
     bool hasDueDate() const;
+    bool hasStartDate()const;
+    bool hasCompletedDate()const;
 
     /**
      * Does this Event has an alarm time ?
@@ -114,9 +118,14 @@ public:
     QDate dueDate()const;
 
     /**
-     * Alarm Date and Time
+     * When did it start?
+     */
+    QDate startDate()const;
+
+    /**
+     * When was it completed?
      */
-    QDateTime alarmDateTime()const;
+    QDate completedDate()const;
 
     /**
      * What is the state of this OTodo?
@@ -149,8 +158,16 @@ public:
      */
     QString toRichText() const;
 
+    /*
+     * check if the sharing is still fine!! -zecke
+     */
+    /**
+     * return a reference to our notifiers...
+     */
+    OPimNotifyManager &notifiers();
+
     /**
-     * reimplementation
+     * reimplementations
      */
     QString type()const;
     QString toShortText()const;
@@ -172,11 +189,10 @@ public:
      * set if this todo got an end data
      */
     void setHasDueDate( bool hasDate );
-
-    /**
-     * set if this todo has an alarm time and date
-     */
-    void setHasAlarmDateTime ( bool hasAlarm );
+    // 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
@@ -191,8 +207,17 @@ public:
     /**
      * set the end date
      */
-    void setDueDate( QDate 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& );
     /**
@@ -227,6 +252,8 @@ public:
     bool operator==(const OTodo &toDoEvent )const;
     OTodo &operator=(const OTodo &toDoEvent );
 
+    static int rtti();
+
  private:
     class OTodoPrivate;
     struct OTodoData;
diff --git a/libopie2/opiepim/ui/opimmainwindow.cpp b/libopie2/opiepim/ui/opimmainwindow.cpp
new file mode 100644
index 0000000..92be2fd
--- a/dev/null
+++ b/libopie2/opiepim/ui/opimmainwindow.cpp
@@ -0,0 +1,71 @@
+#include <qapplication.h>
+#include <qcopchannel_qws.h>
+
+#include <qpe/qcopenvelope_qws.h>
+
+#include "opimmainwindow.h"
+
+OPimMainWindow::OPimMainWindow( const QString& service, QWidget* parent,
+                                const char* name, WFlags flag )
+    : QMainWindow( parent, name, flag ), m_service( service ), m_fallBack(0l) {
+
+    /*
+     * let's generate our QCopChannel
+     */
+    m_str = QString("QPE/"+m_service).local8Bit();
+    m_channel= new QCopChannel(m_str, this );
+    connect(m_channel, SIGNAL(received(const QCString&, const QByteArray& ) ),
+            this, SLOT( appMessage( const QCString&, const QByteArray& ) ) );
+
+    /* connect flush and reload */
+    connect(qApp, SIGNAL(flush() ),
+            this, SLOT(flush() ) );
+    connect(qApp, SIGNAL(reload() ),
+            this, SLOT(reload() ) );
+}
+OPimMainWindow::~OPimMainWindow() {
+    delete m_channel;
+}
+QCopChannel* OPimMainWindow::channel() {
+    return m_channel;
+}
+void OPimMainWindow::appMessage( const QCString& cmd, const QByteArray& array ) {
+    /*
+     * create demands to create
+     * a new record...
+     */
+    QDataStream stream(array, IO_ReadOnly);
+    if ( cmd == "create()" ) {
+        int uid = create();
+        QCopEnvelope e(m_str, "created(int)" );
+        e << uid;
+    }else if ( cmd == "remove(int)" ) {
+        int uid;
+        stream >> uid;
+        bool rem = remove( uid );
+        QCopEnvelope e(m_str, "removed(bool)" );
+        e << rem;
+    }else if ( cmd == "beam(int,int)" ) {
+        int uid, trans;
+        stream >> uid;
+        stream >> trans;
+        beam( uid, trans );
+    }else if ( cmd == "show(int)" ) {
+        int uid;
+        stream >> uid;
+        show( uid );
+    }else if ( cmd == "edit(int)" ) {
+        int uid;
+        stream >> uid;
+        edit( uid );
+    }else if ( cmd == "add(int,QByteArray)" ) {
+        int rtti;
+        QByteArray array;
+        stream >> rtti;
+        stream >> array;
+        m_fallBack = record(rtti, array );
+        if (!m_fallBack) return;
+        add( *m_fallBack );
+        delete m_fallBack;
+    }
+}
diff --git a/libopie2/opiepim/ui/opimmainwindow.h b/libopie2/opiepim/ui/opimmainwindow.h
new file mode 100644
index 0000000..94100bd
--- a/dev/null
+++ b/libopie2/opiepim/ui/opimmainwindow.h
@@ -0,0 +1,79 @@
+#ifndef OPIE_PIM_MAINWINDOW_H
+#define OPIE_PIM_MAINWINDOW_H
+
+#include <qmainwindow.h>
+
+#include <opie/opimrecord.h>
+
+/**
+ * This is a common Opie PIM MainWindow
+ * it takes care of the QCOP internals
+ * and implements some  functions
+ * for the URL scripting schema
+ */
+/*
+ * due Qt and Templates with signal and slots
+ * do not work that good :(
+ * (Ok how to moc a template ;) )
+ * We will have the mainwindow which calls a struct which
+ * is normally reimplemented as a template ;)
+ */
+
+class QCopChannel;
+class OPimMainWindow : public QMainWindow {
+    Q_OBJECT
+public:
+    enum TransPort { BlueTooth=0,
+                     IrDa };
+
+    OPimMainWindow(  const QString& service, QWidget *parent = 0,  const char* name = 0,
+                     WFlags f = WType_TopLevel);
+    virtual ~OPimMainWindow();
+
+
+protected slots:
+    /* for syncing */
+    virtual void flush()  = 0;
+    virtual void reload() = 0;
+
+    /** create a new Records and return the uid */
+    virtual int create() = 0;
+    /** remove a record with UID == uid */
+    virtual bool remove( int uid ) = 0;
+    /** beam the record with UID = uid */
+    virtual void beam( int uid ,  int transport = IrDa) = 0;
+
+    /** show the record with UID == uid */
+    virtual void show( int uid ) = 0;
+    /** edit the record */
+    virtual void edit( int uid ) = 0;
+
+    /** make a copy of it! */
+    virtual void add( const OPimRecord& ) = 0;
+
+    /* I would love to do this as a template
+     * but can't think of a right way
+     * because I need signal and slots -zecke
+     */
+    /*
+     * the only pointer in the whole PIM API :(
+     */
+    virtual OPimRecord* record( int rtti, const QByteArray& ) = 0;
+    QCopChannel* channel();
+
+private slots:
+    void appMessage( const QCString&, const QByteArray& );
+
+
+private:
+    class Private;
+    Private* d;
+
+    QCopChannel* m_channel;
+    QString m_service;
+    QCString m_str;
+    OPimRecord* m_fallBack;
+};
+
+
+#endif