20 files changed, 949 insertions, 29 deletions

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,6 +45,7 @@ OTodoAccess::List OTodoAccess::overDue() {
     return lis;
 }
 void OTodoAccess::addAlarm( const OTodo& event) {
+/* FIXME use the new notifier architecture
     if (!event.hasAlarmDateTime() )
         return;
 
@@ -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;