Big PIM API Update Core Part (1/2 of what should be implemented):

OPimRecords:
	-Add a so called safeCast using the rtti value

OPimTodo:
	-Fix memleak with OPimState

OPimOccurrence:
	-New class. Every 'Access' can give occurrences
	 for a period of time

Move Documentation

26 files changed, 1244 insertions, 328 deletions

diff --git a/libopie2/opiepim/core/core.pro b/libopie2/opiepim/core/core.pro
index b1b5655..f943318 100644
--- a/libopie2/opiepim/core/core.pro
+++ b/libopie2/opiepim/core/core.pro
@@ -11,8 +11,9 @@ HEADERS += \
         core/opimglobal.h         \
         core/opimmaintainer.h     \
         core/opimnotify.h         \
         core/opimnotifymanager.h  \       
+	core/opimoccurrence.h     \
         core/opimrecord.h         \
         core/opimrecordlist.h     \
         core/opimrecurrence.h     \
         core/opimresolver.h       \
@@ -34,12 +35,14 @@ SOURCES += \
         core/opimevent.cpp          \     
         core/opimmaintainer.cpp     \
         core/opimnotify.cpp         \
         core/opimnotifymanager.cpp  \       
+	core/opimoccurrence.cpp      \
         core/opimrecord.cpp         \      
         core/opimrecurrence.cpp     \
         core/opimresolver.cpp       \
         core/opimstate.cpp          \       
+	core/opimtemplatebase.cpp   \
         core/opimtimezone.cpp       \
         core/opimtodo.cpp           \
         core/opimxref.cpp           \
         core/opimxrefmanager.cpp    \
diff --git a/libopie2/opiepim/core/ocontactaccess.cpp b/libopie2/opiepim/core/ocontactaccess.cpp
index 771d855..9bbc820 100644
--- a/libopie2/opiepim/core/ocontactaccess.cpp
+++ b/libopie2/opiepim/core/ocontactaccess.cpp
@@ -69,9 +69,8 @@ OPimContactAccess::OPimContactAccess ( const QString appname, const QString ,
         /* take care of the backend. If there is no one defined, we
 	 * will use the XML-Backend as default (until we have a cute SQL-Backend..).
 	 */
         if( end == 0 ) {
-		owarn << "Using BackendFactory !" << oendl;
 		end = OBackendFactory<OPimContactAccessBackend>::defaultBackend( OPimGlobal::CONTACTLIST, appname );
         }
 	// Set backend locally and in template
         m_backEnd = end;
@@ -127,13 +126,16 @@ const uint OPimContactAccess::querySettings()
 bool OPimContactAccess::hasQuerySettings ( int querySettings ) const
 {
     return ( m_backEnd->hasQuerySettings ( querySettings ) );
 }
+
+#if 0
 OPimRecordList<OPimContact> OPimContactAccess::sorted( bool ascending, int sortOrder, int sortFilter, int cat ) const
 {
     QArray<int> matchingContacts = m_backEnd -> sorted( ascending, sortOrder, sortFilter, cat );
     return ( OPimRecordList<OPimContact>(matchingContacts, this) );
 }
+#endif
 
 
 bool OPimContactAccess::wasChangedExternally()const
 {
@@ -143,15 +145,12 @@ bool OPimContactAccess::wasChangedExternally()const
 
 void OPimContactAccess::copMessage( const QCString &msg, const QByteArray & )
 {
     if ( msg == "addressbookUpdated()" ){
-        owarn << "OPimContactAccess: Received addressbokUpdated()" << oendl;
         emit signalChanged ( this );
     } else if ( msg == "flush()" ) {
-        owarn << "OPimContactAccess: Received flush()" << oendl;
         save ();
     } else if ( msg == "reload()" ) {
-        owarn << "OPimContactAccess: Received reload()" << oendl;
         reload ();
         emit signalChanged ( this );
     }
 }
diff --git a/libopie2/opiepim/core/ocontactaccess.h b/libopie2/opiepim/core/ocontactaccess.h
index 4429b6f..691ece2 100644
--- a/libopie2/opiepim/core/ocontactaccess.h
+++ b/libopie2/opiepim/core/ocontactaccess.h
@@ -59,8 +59,28 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate<OPimContact>
 {
     Q_OBJECT
 
  public:
+    enum SortFilter {
+        DoNotShowNoneChildren      = FilterCustom<<1,
+        DoNotShowNoneAnniversary   = FilterCustom<<2,
+        DoNotShowNoneBirthday      = FilterCustom<<3,
+        DoNotShowNoHomeAddress     = FilterCustom<<4,
+        DoNotShowNoBusinessAddress = FilterCustom<<5
+    };
+
+    enum SortOrder {
+        SortTitle = SortCustom,
+        SortFirstName,
+        SortMiddleName,
+        SortSuffix,
+        SortEmail,
+        SortNickname,
+        SortAnniversary,
+        SortBirthday,
+        SortGender
+    };
+
 	/**
          * Create Database with contacts (addressbook).
 	 * @param appname Name of application which wants access to the database
 	 * (i.e. "todolist")
@@ -74,36 +94,11 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate<OPimContact>
 	 * to react itself, it should be disabled by setting it to <b>false</b>
 	 * @see OPimContactAccessBackend
 	 */
 	OPimContactAccess (const QString appname, const QString filename = 0l,
-                    OPimContactAccessBackend* backend = 0l, bool handlesync = true);
-	~OPimContactAccess ();
+                           OPimContactAccessBackend* backend = 0l, bool handlesync = true);
+        ~OPimContactAccess ();
 
-	/** Constants for query.
-	 * Use this constants to set the query parameters.
-	 * Note: <i>query_IgnoreCase</i> just make sense with one of the other attributes !
-	 * @see queryByExample()
-	 */
-	enum QuerySettings {
-		WildCards  = 0x0001,
-		IgnoreCase = 0x0002,
-		RegExp     = 0x0004,
-		ExactMatch = 0x0008,
-		MatchOne   = 0x0010, // Only one Entry must match
-		DateDiff   = 0x0020, // Find all entries from today until given date
-		DateYear   = 0x0040, // The year matches
-		DateMonth  = 0x0080, // The month matches
-		DateDay    = 0x0100, // The day matches
-	};
-
-
-	/** Return all Contacts in a sorted manner.
-	 *  @param ascending true: Sorted in acending order.
-	 *  @param sortOrder Currently not implemented. Just defined to stay compatible to otodoaccess
-	 *  @param sortFilter Currently not implemented. Just defined to stay compatible to otodoaccess
-	 *  @param cat Currently not implemented. Just defined to stay compatible to otodoaccess
-	 */
-	List sorted( bool ascending, int sortOrder, int sortFilter, int cat ) const;
 
 	/** Return all possible settings.
 	 *  @return All settings provided by the current backend
 	 * (i.e.: query_WildCards & query_IgnoreCase)
@@ -125,11 +120,11 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate<OPimContact>
 	/** Save contacts database.
 	 * Save is more a "commit". After calling this function, all changes are public available.
 	 * @return true if successful
 	 */
-	bool save();
-	
-	/** 
+        bool save();
+
+	/**
 	 * Return identification of used records
 	 */
 	int rtti() const;
 
@@ -143,10 +138,8 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate<OPimContact>
 	void signalChanged ( const OPimContactAccess *which );
 
 
  private:
-	// class OPimContactAccessPrivate;
-	// OPimContactAccessPrivate* d;
         OPimContactAccessBackend *m_backEnd;
         bool m_loading:1;
 
  private slots:
diff --git a/libopie2/opiepim/core/odatebookaccess.cpp b/libopie2/opiepim/core/odatebookaccess.cpp
index 440ee0a..32fbb7d 100644
--- a/libopie2/opiepim/core/odatebookaccess.cpp
+++ b/libopie2/opiepim/core/odatebookaccess.cpp
@@ -38,9 +38,9 @@ namespace Opie {
  * will be used!
  * @param back The backend to be used or 0 for the default backend
  * @param ac What kind of access is intended
  */
-ODateBookAccess::ODateBookAccess( ODateBookAccessBackend* back, enum Access ac )
+ODateBookAccess::ODateBookAccess( ODateBookAccessBackend* back, enum Access  )
     : OPimAccessTemplate<OPimEvent>( back )
 {
     if (!back )
         back = OBackendFactory<ODateBookAccessBackend>::defaultBackend( OPimGlobal::DATEBOOK, QString::null );
@@ -50,17 +50,8 @@ ODateBookAccess::ODateBookAccess( ODateBookAccessBackend* back, enum Access ac )
 }
 ODateBookAccess::~ODateBookAccess() {
 }
 
-/**
- * @return all events available
- */
-ODateBookAccess::List ODateBookAccess::rawEvents()const {
-    QArray<int> ints = m_backEnd->rawEvents();
-
-    List lis( ints, this );
-    return lis;
-}
 
 /**
  * @return all repeating events
  */
@@ -81,36 +72,22 @@ ODateBookAccess::List ODateBookAccess::nonRepeats()const {
     return lis;
 }
 
 /**
- * @return dates in the time span between from and to
- * @param from Include all events from...
- * @param to Include all events to...
- */
-OEffectiveEvent::ValueList ODateBookAccess::effectiveEvents( const QDate& from, const QDate& to ) const {
-    return m_backEnd->effectiveEvents( from, to );
-}
-/**
- * @return all events at a given datetime
- */
-OEffectiveEvent::ValueList ODateBookAccess::effectiveEvents( const QDateTime& start ) const {
-    return m_backEnd->effectiveEvents( start );
-}
-
-/**
  * @return non repeating dates in the time span between from and to
  * @param from Include all events from...
  * @param to Include all events to...
  */
-OEffectiveEvent::ValueList ODateBookAccess::effectiveNonRepeatingEvents( const QDate& from, const QDate& to ) const {
-    return m_backEnd->effectiveNonRepeatingEvents( from, to );
+OPimOccurrence::List ODateBookAccess::effectiveNonRepeatingEvents( const QDate& from, const QDate& to ) const {
+    return OPimBase::convertOccurrenceFromBackend( m_backEnd->effectiveNonRepeatingEvents( from, to ) );
 }
 /**
  * @return all non repeating events at a given datetime
  */
-OEffectiveEvent::ValueList ODateBookAccess::effectiveNonRepeatingEvents( const QDateTime& start ) const {
-    return m_backEnd->effectiveNonRepeatingEvents( start );
+OPimOccurrence::List ODateBookAccess::effectiveNonRepeatingEvents( const QDateTime& start ) const {
+    return OPimBase::convertOccurrenceFromBackend( m_backEnd->effectiveNonRepeatingEvents( start ) );
 }
+
 int ODateBookAccess::rtti() const
 {
 	return OPimResolver::DateBook;
 }
diff --git a/libopie2/opiepim/core/odatebookaccess.h b/libopie2/opiepim/core/odatebookaccess.h
index c6c3598..0be8606 100644
--- a/libopie2/opiepim/core/odatebookaccess.h
+++ b/libopie2/opiepim/core/odatebookaccess.h
@@ -48,24 +48,19 @@ class ODateBookAccess : public OPimAccessTemplate<OPimEvent> {
 public:
     ODateBookAccess( ODateBookAccessBackend* = 0l, enum Access acc = Random );
     ~ODateBookAccess();
 
-    /* return all events */
-    List rawEvents()const;
-
     /* return repeating events */
     List rawRepeats()const;
 
     /* return non repeating events */
     List nonRepeats()const;
 
     /* return non repeating events (from,to) */
-    OEffectiveEvent::ValueList effectiveEvents( const QDate& from, const QDate& to ) const;
-    OEffectiveEvent::ValueList effectiveEvents( const QDateTime& start ) const;
-    OEffectiveEvent::ValueList effectiveNonRepeatingEvents( const QDate& from, const QDate& to ) const;
-    OEffectiveEvent::ValueList effectiveNonRepeatingEvents( const QDateTime& start ) const;
+    OPimOccurrence::List effectiveNonRepeatingEvents( const QDate& from, const QDate& to ) const;
+    OPimOccurrence::List effectiveNonRepeatingEvents( const QDateTime& start ) const;
 
-    /** 
+    /**
      * Return identification of used records
      */
     int rtti() const;
 
diff --git a/libopie2/opiepim/core/opimaccesstemplate.h b/libopie2/opiepim/core/opimaccesstemplate.h
index f936d4e..2deb92a 100644
--- a/libopie2/opiepim/core/opimaccesstemplate.h
+++ b/libopie2/opiepim/core/opimaccesstemplate.h
@@ -1,8 +1,8 @@
 /*
                              This file is part of the Opie Project
                              Copyright (C) Holger Freyther <zecke@handhelds.org>
-                 Copyright (C) Stefan Eilers <eilers.stefan@epost.de>
+                             Copyright (C) Stefan Eilers <eilers.stefan@epost.de>
               =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
@@ -39,8 +39,9 @@
 #include <opie2/odebug.h>
 
 /* QT */
 #include <qarray.h>
+#include <qdatetime.h>
 
 namespace Opie {
 
 class OPimAccessTemplatePrivate;
@@ -55,134 +56,85 @@ class OPimAccessTemplatePrivate;
 
 template <class T = OPimRecord >
 class OPimAccessTemplate : public OTemplateBase<T> {
 public:
+    /**
+     *
+     */
     enum Access {
         Random = 0,
         SortedAccess
     };
     typedef OPimRecordList<T> List;
     typedef OPimAccessBackend<T> BackEnd;
     typedef OPimCache<T> Cache;
 
-    /**
-     * c'tor BackEnd
-     * enum Access a small hint on how to handle the backend
-     */
+    //@{
     OPimAccessTemplate( BackEnd* end);
-
     virtual ~OPimAccessTemplate();
+    //@}
 
-    /**
-     * load from the backend
-     */
+    //@{
     bool load();
-
-    /** Reload database.
-     * You should execute this function if the external database
-     * was changed.
-     * This function will load the external database and afterwards
-     * rejoin the local changes. Therefore the local database will be set consistent.
-     */
     virtual bool reload();
-
-    /** Save contacts database.
-     * Save is more a "commit". After calling this function, all changes are public available.
-     * @return true if successful
-     */
     bool save();
+    void clear() ;
+    //@}
+
 
-    /**
-     * if the resource was changed externally
-     * You should use the signal handling instead of polling possible changes !
-     * zecke: Do you implement a signal for otodoaccess ?
-     */
     bool wasChangedExternally()const;
 
-    /**
-     * return a List of records
-     * you can iterate over them
-     */
+    //@{
     virtual List allRecords()const;
-
-     /**
-     * return a List of records
-     * that match the regex
-     */
     virtual List matchRegexp(  const QRegExp &r ) const;
-
-    /**
-     * queryByExample.
-     * @see otodoaccess, ocontactaccess
-     */
     virtual List queryByExample( const T& t, int querySettings, const QDateTime& d = QDateTime() );
+    virtual T find( UID uid )const;
+    virtual T find( UID uid, const QArray<int>&,
+		    uint current, typename OTemplateBase<T>::CacheDirection dir = OTemplateBase<T>::Forward )const;
+    virtual List sorted( const List&, bool ascending, int sortOrder,
+			 int sortFilter, int cat )const;
+    virtual List sorted( const List&, bool ascending, int sortOrder,
+			 int sortFilter, const QArray<UID>& cats )const;
+    virtual List sorted( bool ascending, int sortOrder, int sortFilter, int cat )const;
+    virtual List sorted( bool ascending, int sortOrder, int sortOrder,
+			 const QArray<UID>& cats )const;
+    //@}
 
     /**
-     * find the OPimRecord uid
-     */
-    T find( int uid )const;
-
-    /**
-     * read ahead cache find method ;)
-     */
-    T find( int uid, const QArray<int>&,
-                    uint current, typename OTemplateBase<T>::CacheDirection dir = OTemplateBase<T>::Forward )const;
-
-
-    /* invalidate cache here */
-    /**
-     * clears the backend and invalidates the backend
+     * (Re)Implementation
      */
-    void clear() ;
-
-    /**
-     * add T to the backend
-     * @param t The item to add.
-     * @return <i>true</i> if added successfully.
-     */
-     virtual bool add( const T& t ) ;
-
+    //@{
+    UIDArray matchRegexpSimple( const QRegExp& r )const;
+    UIDArray queryByExampleSimple( const OPimRecord*, int, const QDateTime& )const;
+    UIDArray sortedSimple( const UIDArray&, bool asc, int sortOrder,
+                           int sortFilter, int cat )const;
+    UIDArray sortedSimple( const UIDArray&, bool asc, int sortOrder,
+                           int sortFilter, const QArray<int>& )const;
+    UIDArray sortedSimple( bool ascending, int sortOrder, int sortFilter,
+                           int cat )const;
+    UIDArray sortedSimple( bool ascending, int sortOrder, int sortFilter,
+                           const QArray<int>& )const;
+    OPimOccurrence::List occurrences( const QDate& start,  const QDate& end )const;
+    OPimOccurrence::List occurrences( const QDateTime& dt )const;
+    //@}
+
+    //@{
+    virtual bool add( const T& t ) ;
     bool add( const OPimRecord& );
-    /** 
-     * Add an Opie PimRecord.
-     * Info: Take this if  you are working with OPimRecords and you need to add it into any database.
-     *       But take care that the accessing database is compatible to the real type of OPimRecord !! 
-     *       Otherwise this access will be rejected !
-     */
     bool add( const OPimRecord* );
-
-
-    /* only the uid matters */
-    /**
-     * remove T from the backend
-     * @param t The item to remove
-     * @return <i>true</i> if successful.
-     */
     virtual bool remove( const T& t );
-
-    /**
-     * remove the OPimRecord with uid
-     * @param uid The ID of the item to remove
-     * @return <i>true</i> if successful.
-     */
-    bool remove( int uid );
+    bool remove( UID uid );
     bool remove( const OPimRecord& );
-
-    /**
-     * replace T from backend
-     * @param t The item to replace
-     * @return <i>true</i> if successful.
-     */
     virtual bool replace( const T& t) ;
 
+    //@}
+
     void setReadAhead( uint count );
-    /**
-     * @internal
-     */
+    virtual T cacheFind( int uid )const;
     void cache( const T& )const;
     void setSaneCacheSize( int );
 
-    QArray<int> records()const;
+    QArray<UID> records()const;
 protected:
     /**
      * invalidate the cache
      */
@@ -201,8 +153,12 @@ private:
     OPimAccessTemplatePrivate *d;
 
 };
 
+/**
+ * c'tor BackEnd
+ * enum Access a small hint on how to handle the backend
+ */
 template <class T>
 OPimAccessTemplate<T>::OPimAccessTemplate( BackEnd* end )
     : OTemplateBase<T>(), m_backEnd( end )
 {
@@ -210,51 +166,89 @@ OPimAccessTemplate<T>::OPimAccessTemplate( BackEnd* end )
         end->setFrontend( this );
 }
 template <class T>
 OPimAccessTemplate<T>::~OPimAccessTemplate() {
-    owarn << "~OPimAccessTemplate<T>" << oendl;
     delete m_backEnd;
 }
+
+/**
+ * load from the backend
+ */
 template <class T>
 bool OPimAccessTemplate<T>::load() {
     invalidateCache();
     return m_backEnd->load();
 }
+
+/** Reload database.
+ * You should execute this function if the external database
+ * was changed.
+ * This function will load the external database and afterwards
+ * rejoin the local changes. Therefore the local database will be set consistent.
+ */
 template <class T>
 bool OPimAccessTemplate<T>::reload() {
     invalidateCache();
     return m_backEnd->reload();
 }
+
+/**
+ * Save contacts database.
+ * Save is more a "commit". After calling this function, all changes are public available.
+ * @return true if successful
+ */
 template <class T>
 bool OPimAccessTemplate<T>::save() {
     return m_backEnd->save();
 }
+
+
+/**
+ * return a List of records
+ * you can iterate over them
+ */
 template <class T>
 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::allRecords()const {
     QArray<int> ints = m_backEnd->allRecords();
     List lis(ints, this );
     return lis;
 }
+
+/**
+ * return a List of records
+ * that match the regex
+ */
 template <class T>
 typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::matchRegexp( const QRegExp &r )const {
     QArray<int> ints = m_backEnd->matchRegexp( r );
     List lis(ints, this );
     return lis;
 }
+
+/**
+ * find the OPimRecord uid
+ */
 template <class T>
 QArray<int> OPimAccessTemplate<T>::records()const {
     return m_backEnd->allRecords();
 }
+
+
+/**
+ * queryByExample.
+ * @see otodoaccess, ocontactaccess
+ */
 template <class T>
 typename OPimAccessTemplate<T>::List
 OPimAccessTemplate<T>::queryByExample( const T& t, int settings, const QDateTime& d ) {
     QArray<int> ints = m_backEnd->queryByExample( t, settings, d );
 
     List lis(ints, this );
     return lis;
 }
+
 template <class T>
-T OPimAccessTemplate<T>::find( int uid ) const{
+T OPimAccessTemplate<T>::find( UID uid ) const{
     // First search in cache..
     if ( m_cache.contains( uid ) )
 	    return m_cache.find( uid );
 
@@ -264,29 +258,48 @@ T OPimAccessTemplate<T>::find( int uid ) const{
     return t;
 }
 
 template <class T>
-T OPimAccessTemplate<T>::find( int uid, const QArray<int>& ar,
+T OPimAccessTemplate<T>::cacheFind( int uid ) const
+{
+	return m_cache.find( uid );
+}
+
+/**
+ * read ahead cache find method ;)
+ */
+template <class T>
+T OPimAccessTemplate<T>::find( UID uid, const QArray<int>& ar,
                                uint current, typename OTemplateBase<T>::CacheDirection dir )const {
     /*
      * better do T.isEmpty()
      * after a find this way we would
      * avoid two finds in QCache...
      */
-    // owarn << "find it now " << uid << oendl;
-    if ( m_cache.contains( uid ) ) {
+    if (m_cache.contains( uid ) )
         return m_cache.find( uid );
-    }
+
 
     T t = m_backEnd->find( uid, ar, current, dir );
     cache( t );
     return t;
 }
+
+/**
+ * clears the backend and invalidates the backend
+ */
 template <class T>
 void OPimAccessTemplate<T>::clear() {
     invalidateCache();
     m_backEnd->clear();
 }
+
+
+/**
+ * add T to the backend
+ * @param t The item to add.
+ * @return <i>true</i> if added successfully.
+ */
 template <class T>
 bool OPimAccessTemplate<T>::add( const T& t ) {
     cache( t );
     return m_backEnd->add( t );
@@ -304,8 +317,14 @@ bool OPimAccessTemplate<T>::add( const OPimRecord& rec ) {
     }
     return false;
 }
 
+/**
+ * Add an Opie PimRecord.
+ * Info: Take this if  you are working with OPimRecords and you need to add it into any database.
+ *       But take care that the accessing database is compatible to the real type of OPimRecord !!
+ *       Otherwise this access will be rejected !
+ */
 template <class T>
 bool OPimAccessTemplate<T>::add( const OPimRecord* rec) {
     /* same type, but pointer  */
     T tempInstance;
@@ -317,34 +336,61 @@ bool OPimAccessTemplate<T>::add( const OPimRecord* rec) {
     }
     return false;
 }
 
+/**
+ * remove T from the backend
+ * @param t The item to remove
+ * @return <i>true</i> if successful.
+ */
 template <class T>
 bool OPimAccessTemplate<T>::remove( const T& t ) {
     return remove( t.uid() );
 }
+
+/**
+ * remove the OPimRecord with uid
+ * @param uid The ID of the item to remove
+ * @return <i>true</i> if successful.
+ */
 template <class T>
-bool OPimAccessTemplate<T>::remove( int uid ) {
+bool OPimAccessTemplate<T>::remove( UID uid ) {
     m_cache.remove( uid );
     return m_backEnd->remove( uid );
 }
 template <class T>
 bool OPimAccessTemplate<T>::remove( const OPimRecord& rec) {
     return remove( rec.uid() );
 }
+
+/**
+ * replace T from backend
+ * @param t The item to replace
+ * @return <i>true</i> if successful.
+ */
 template <class T>
 bool OPimAccessTemplate<T>::replace( const T& t ) {
     m_cache.replace( t );
     return m_backEnd->replace( t );
 }
+
+/**
+ * @internal
+ */
 template <class T>
 void OPimAccessTemplate<T>::invalidateCache() {
     m_cache.invalidate();
 }
 template <class T>
 typename OPimAccessTemplate<T>::BackEnd* OPimAccessTemplate<T>::backEnd() {
     return m_backEnd;
 }
+
+/**
+ * if the resource was changed externally
+ * You should use the signal handling instead of polling possible changes !
+ * zecke: Do you implement a signal for otodoaccess ?
+ */
 template <class T>
 bool OPimAccessTemplate<T>::wasChangedExternally()const {
     return false;
 }
@@ -367,7 +413,110 @@ template <class T>
 void OPimAccessTemplate<T>::setReadAhead( uint count ) {
     m_backEnd->setReadAhead( count );
 }
 
+
+template <class T>
+typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::sorted( const OPimAccessTemplate::List& lst,
+                                                                    bool ascending, int sortOrder,
+                                                                    int sortFilter, int cat )const {
+    QArray<int> cats( 1 );
+    cats[0] = cat;
+    UIDArray ints = m_backEnd->sorted( lst.uids(), ascending, sortOrder,
+                                       sortFilter, cats );
+    return List(ints, this);
+}
+
+template<class T>
+typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::sorted( const OPimAccessTemplate::List& lst,
+                                                                    bool ascending, int sortOrder,
+                                                                    int sortFilter, const QArray<UID>& cats )const {
+    UIDArray ints = m_backEnd->sorted( lst.uids(), ascending, sortOrder,
+                                       sortFilter, cats );
+    return List(ints, this);
+}
+
+template<class T>
+typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::sorted( bool ascending, int sortOrder,
+                                                                    int sortFilter, int cat )const {
+    QArray<int> cats( 1 );
+    cats[0] = cat;
+    UIDArray ints = m_backEnd->sorted( ascending, sortOrder,
+                                       sortFilter, cats );
+    return List(ints, this);
+}
+
+template<class T>
+typename OPimAccessTemplate<T>::List OPimAccessTemplate<T>::sorted( bool ascending, int sortOrder,
+                                                                    int sortFilter, const QArray<UID>& cats )const {
+    UIDArray ints = m_backEnd->sorted( ascending, sortOrder,
+                                       sortFilter, cats );
+    return List(ints, this);
+}
+
+template <class T>
+OPimOccurrence::List OPimAccessTemplate<T>::occurrences( const QDate& start,
+                                                         const QDate& end ) const {
+    /*
+     * Some magic involved to go from single OPimBackendOccurrence
+     * to multiple OPimOccurrence's
+     */
+    return OPimBase::convertOccurrenceFromBackend( m_backEnd->occurrences( start, end ) );
+}
+
+template<class T>
+OPimOccurrence::List OPimAccessTemplate<T>::occurrences( const QDateTime& dt )const {
+    return OPimBase::convertOccurrenceFromBackend(  m_backEnd->occurrences( dt ) );
+}
+
+/*
+ *Implementations!!
+ */
+template <class T>
+UIDArray OPimAccessTemplate<T>::matchRegexpSimple( const QRegExp &r )const {
+    return m_backEnd->matchRegexp( r );
+}
+
+template <class T>
+UIDArray OPimAccessTemplate<T>::queryByExampleSimple( const OPimRecord* rec,
+                                                      int settings,
+                                                      const QDateTime& d )const {
+    return m_backEnd->queryByExample( rec, settings, d );
+}
+
+template <class T>
+UIDArray OPimAccessTemplate<T>::sortedSimple( const UIDArray& lst,
+                                              bool ascending,
+                                              int sortOrder, int sortFilter,
+                                              int cat ) const{
+    QArray<int> cats( 1 );
+    cats[0] = cat;
+    return m_backEnd->sorted( lst, ascending, sortOrder, sortFilter, cats );
+}
+
+template <class T>
+UIDArray OPimAccessTemplate<T>::sortedSimple( const UIDArray& lst,
+                                              bool ascending,
+                                              int sortOrder, int sortFilter,
+                                              const QArray<int>& cats ) const{
+    return m_backEnd->sorted( lst, ascending, sortOrder, sortFilter, cats );
+}
+
+template <class T>
+UIDArray OPimAccessTemplate<T>::sortedSimple( bool ascending,
+                                              int sortOrder, int sortFilter,
+                                              int cat ) const{
+    QArray<int> cats( 1 );
+    cats[0] = cat;
+
+    return m_backEnd->sorted( ascending, sortOrder, sortFilter, cats );
+}
+
+template <class T>
+UIDArray OPimAccessTemplate<T>::sortedSimple( bool ascending,
+                                              int sortOrder, int sortFilter,
+                                              const QArray<int>& cats ) const{
+    return m_backEnd->sorted( ascending, sortOrder, sortFilter, cats );
+}
 }
 
 #endif
diff --git a/libopie2/opiepim/core/opimcontact.cpp b/libopie2/opiepim/core/opimcontact.cpp
index 36e9a93..64f195b 100644
--- a/libopie2/opiepim/core/opimcontact.cpp
+++ b/libopie2/opiepim/core/opimcontact.cpp
@@ -80,9 +80,8 @@ OPimContact::OPimContact( const QMap<int, QString> &fromMap ):OPimRecord(), mMap
     QString uidStr = find( Qtopia::AddressUid );
 
     if ( uidStr.isEmpty() || ( uidStr.toInt() == 0 ) )
     {
-        owarn << "Invalid UID found. Generate new one.." << oendl;
         setUid( uidGen().generate() );
     }
     else
         setUid( uidStr.toInt() );
@@ -1137,9 +1136,8 @@ class QString OPimContact::recordField( int pos ) const
 void OPimContact::setBirthday( const QDate &v )
 {
     if ( v.isNull() )
     {
-        owarn << "Remove Birthday" << oendl;
         replace( Qtopia::Birthday, QString::null );
         return ;
     }
 
@@ -1156,9 +1154,8 @@ void OPimContact::setBirthday( const QDate &v )
 void OPimContact::setAnniversary( const QDate &v )
 {
     if ( v.isNull() )
     {
-        owarn << "Remove Anniversary" << oendl;
         replace( Qtopia::Anniversary, QString::null );
         return ;
     }
 
@@ -1172,9 +1169,8 @@ void OPimContact::setAnniversary( const QDate &v )
 */
 QDate OPimContact::birthday() const
 {
     QString str = find( Qtopia::Birthday );
-    // owarn << "Birthday " << str << oendl;
     if ( !str.isEmpty() )
         return OPimDateConversion::dateFromString ( str );
     else
         return QDate();
@@ -1187,9 +1183,8 @@ QDate OPimContact::birthday() const
 QDate OPimContact::anniversary() const
 {
     QDate empty;
     QString str = find( Qtopia::Anniversary );
-    // owarn << "Anniversary " << str << oendl;
     if ( !str.isEmpty() )
         return OPimDateConversion::dateFromString ( str );
     else
         return empty;
@@ -1281,8 +1276,27 @@ int OPimContact::rtti() const
 {
     return OPimResolver::AddressBook;
 }
 
+/**
+ * \brief Cast to OPimContact or on failure return 0l
+ *
+ * This method tries to cast from a OPimRecord to a
+ * OPimContact it uses. If the OPimRecord is from type
+ * OPimContact the case will suceed and a pointer to
+ * OPimContact is returned otherwise a Null Pointer is returned.
+ *
+ *
+ * @see OPimTodo::safeCast()
+ * @see OPimEvent::safeCast()
+ * @return Return a OPimContact or a Null Pointer
+ */
+OPimContact* OPimContact::safeCast( const OPimRecord* rec ) {
+    return( rec && rec->rtti() == OPimResolver::AddressBook ) ?
+        static_cast<OPimContact*>( const_cast<OPimRecord*>(rec) ) :
+        0l;
+}
+
 
 void OPimContact::setUid( int i )
 {
     OPimRecord::setUid( i );
diff --git a/libopie2/opiepim/core/opimcontact.h b/libopie2/opiepim/core/opimcontact.h
index 6891dd6..6fa2c4b 100644
--- a/libopie2/opiepim/core/opimcontact.h
+++ b/libopie2/opiepim/core/opimcontact.h
@@ -227,9 +227,13 @@ class QPC_EXPORT OPimContact : public OPimRecord
 
     // the emails should be seperated by a comma
     void setEmails( const QString &v );
     QString emails() const { return find( Qtopia::Emails ); }
+
+    //@{
     int rtti() const;
+    static OPimContact* safeCast( const OPimRecord* );
+    //@}
 
   private:
     // The XML Backend needs some access to the private functions
     friend class OPimContactAccessBackend_XML;
diff --git a/libopie2/opiepim/core/opimevent.cpp b/libopie2/opiepim/core/opimevent.cpp
index 7bc6c32..1b553d8 100644
--- a/libopie2/opiepim/core/opimevent.cpp
+++ b/libopie2/opiepim/core/opimevent.cpp
@@ -488,8 +488,27 @@ int OPimEvent::rtti() const
 {
     return OPimResolver::DateBook;
 }
 
+/**
+ * \brief Cast safely to OPimEvent from OPimRecord
+ *
+ * Safely cast from OPimRecord to OPimEvent. If the
+ * OPimRecord is not of type OPimEvent Null will be
+ * returned.
+ *
+ * @param rec The OPimRecord to be casted to OPimEvent
+ *
+ * @see OPimTodo::safeCast
+ * @return OPimEvent or Null Pointer
+ */
+OPimEvent* OPimEvent::safeCast( const OPimRecord* rec) {
+    return ( rec && rec->rtti() == OPimResolver::DateBook ) ?
+        static_cast<OPimEvent*>( const_cast<OPimRecord*>(rec) ) :
+        0l;
+}
+
+
 
 bool OPimEvent::loadFromStream( QDataStream& )
 {
     return true;
diff --git a/libopie2/opiepim/core/opimevent.h b/libopie2/opiepim/core/opimevent.h
index 5553cac..32f648f 100644
--- a/libopie2/opiepim/core/opimevent.h
+++ b/libopie2/opiepim/core/opimevent.h
@@ -117,23 +117,31 @@ class OPimEvent : public OPimRecord
     OPimEvent( const QMap<int, QString> map );
     ~OPimEvent();
     OPimEvent &operator=( const OPimEvent& );
 
+    //@{
     QString description() const;
     void setDescription( const QString& description );
 
     QString location() const;
     void setLocation( const QString& loc );
+    //@}
 
+    //@{
     bool hasNotifiers() const;
     OPimNotifyManager &notifiers() const;
+    //@}
 
+    //@{
     OPimRecurrence recurrence() const;
     void setRecurrence( const OPimRecurrence& );
     bool hasRecurrence() const;
+    //@}
 
+    //@{
     QString note() const;
     void setNote( const QString& note );
+    //@}
 
 
     QDateTime createdDateTime() const;
     void setCreatedDateTime( const QDateTime& dt );
@@ -160,36 +168,42 @@ class OPimEvent : public OPimRecord
     void setTimeZone( const QString& timeZone );
     QString timeZone() const;
 
 
-    virtual bool match( const QRegExp& ) const;
-
+    //@{
     /** For exception to recurrence here is a list of children...  */
     QArray<int> children() const;
     void setChildren( const QArray<int>& );
     void addChild( int uid );
     void removeChild( int uid );
+    //@}
 
     /** return the parent OPimEvent */
     int parent() const;
     void setParent( int uid );
 
 
     /* needed reimp */
+    //@{ Reimplementations
+    virtual bool match( const QRegExp& ) const;
     QString toRichText() const;
     QString toShortText() const;
     QString type() const;
 
     QMap<int, QString> toMap() const;
     void fromMap( const QMap<int, QString>& map );
     QString recordField( int ) const;
 
-    int rtti() const;
-
     bool loadFromStream( QDataStream& );
     bool saveToStream( QDataStream& ) const;
+    //@}
+
+    //@{
+    int rtti() const;
+    static OPimEvent* safeCast( const OPimRecord* );
+    //@}
 
-    /*    bool operator==( const OPimEvent& );
+  /*    bool operator==( const OPimEvent& );
         bool operator!=( const OPimEvent& );
         bool operator<( const OPimEvent& );
         bool operator<=( const OPimEvent& );
         bool operator>( const OPimEvent& );
diff --git a/libopie2/opiepim/core/opimglobal.h b/libopie2/opiepim/core/opimglobal.h
index 3925c89..9d319a1 100644
--- a/libopie2/opiepim/core/opimglobal.h
+++ b/libopie2/opiepim/core/opimglobal.h
@@ -28,14 +28,26 @@
 */
 #ifndef __OPIMGLOBAL_H_
 #define __OPIMGLOBAL_H_
 
+#include <qarray.h>
+
 namespace Opie{
+
+/**
+ * The unique identifier for every
+ * PIM record. For now it is a negative
+ * int but we could change it to long or QUuid
+ * in the future
+ */
+typedef int UID;
+typedef QArray<UID> UIDArray;
+
 namespace Pim{
 
 
-	/** 
-	 * Contains global types and enums for the PIM-API 
+	/**
+	 * Contains global types and enums for the PIM-API
 	 */
 class OPimGlobal{
  public:
 	enum PimType {
@@ -43,9 +55,9 @@ class OPimGlobal{
 		CONTACTLIST,
 		DATEBOOK,
 		_END_PimType
 	};
-	
+
 	enum DatabaseStyle {
 		DEFAULT,      // Use default Database
 		UNKNOWN,      // Unknown database style
 		XML,
diff --git a/libopie2/opiepim/core/opimnotifymanager.cpp b/libopie2/opiepim/core/opimnotifymanager.cpp
index 516dc79..77cd922 100644
--- a/libopie2/opiepim/core/opimnotifymanager.cpp
+++ b/libopie2/opiepim/core/opimnotifymanager.cpp
@@ -163,9 +163,8 @@ void OPimNotifyManager::deregister( const OPimNotify& )
 
 
 bool OPimNotifyManager::isEmpty() const
 {
-    owarn << "is Empty called on OPimNotifyManager " << m_rem.count() << " " << m_al.count() << "" << oendl;
     if ( m_rem.isEmpty() && m_al.isEmpty() ) return true;
     else return false;
 }
 
@@ -191,9 +190,8 @@ QString OPimNotifyManager::alarmsToString() const
                 + ":";
             }
         }
         // now write the list
-        owarn << "als: " << als.join( "____________" ) << "" << oendl;
         str = als.join( ";" );
     }
 
     return str;
@@ -225,11 +223,8 @@ void OPimNotifyManager::alarmsFromString( const QString& str )
     QStringList als = QStringList::split( ";", str );
     for ( QStringList::Iterator it = als.begin(); it != als.end(); ++it )
     {
         QStringList alarm = QStringList::split( ":", ( *it ), TRUE ); // allow empty
-        owarn << "alarm: " << alarm.join( "___" ) << "" << oendl;
-        owarn << "alarm[0]: " << alarm[ 0 ] << " "
-              << OPimDateConversion::dateTimeFromString( alarm[ 0 ] ).toString() << oendl;
         OPimAlarm al( alarm[ 2 ].toInt(), OPimDateConversion::dateTimeFromString( alarm[ 0 ] ),
                       alarm[ 1 ].toInt() );
         add( al );
     }
diff --git a/libopie2/opiepim/core/opimoccurrence.cpp b/libopie2/opiepim/core/opimoccurrence.cpp
new file mode 100644
index 0000000..14ab5cf
--- a/dev/null
+++ b/libopie2/opiepim/core/opimoccurrence.cpp
@@ -0,0 +1,319 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 2003, 2004 Holger Freyther <zecke@handhelds.org>
+              =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
+            .=l.
+           .>+-=
+ _;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
+.="- .-=="i,     .._         License as published by the Free Software
+ - .   .-<_>     .<>         Foundation; either version 2 of the License,
+     ._= =}       :          or (at your option) any later version.
+    .%`+i>       _;_.
+    .i_,=:_.      -<s.       This program is distributed in the hope that
+     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+    : ..    .:,     . . .    without even the implied warranty of
+    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+ :     =  ...= . :.=-
+ -.   .:....=;==+<;          You should have received a copy of the GNU
+  -_. . .   )=.  =           Library General Public License along with
+    --        :-=`           this library; see the file COPYING.LIB.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "opimoccurrence.h"
+#include <opie2/opimtemplatebase.h>
+#include <opie2/private/opimoccurrence_p.h>
+
+
+/* QT */
+#include <qshared.h>
+
+
+namespace Opie {
+
+OPimOccurrence::OPimOccurrence( OPimOccurrence::Data* _data,
+                                enum OPimOccurrence::Position pos )
+    : m_pos( pos ), data( _data )
+{}
+
+/**
+ * \brief Copy constructor
+ */
+OPimOccurrence::OPimOccurrence( const OPimOccurrence& oc )
+    : data( oc.data )
+{
+    /*
+     * Increment the reference count
+     */
+    data->ref();
+
+    /*
+     * copy the other information
+     */
+    m_start = oc.m_start;
+    m_end   = oc.m_end;
+    m_occurrence = oc.m_occurrence;
+    m_isAllDay = oc.m_isAllDay;
+    m_pos = oc.m_pos;
+}
+
+OPimOccurrence::OPimOccurrence()
+    : m_isAllDay( false ), m_pos( StartEnd )
+{
+    /* simple convient c'tor */
+    data = new OPimOccurrence::Data();
+}
+
+OPimOccurrence::~OPimOccurrence() {
+    deref();
+}
+
+/**
+ * \brief Copy Operator
+ */
+OPimOccurrence& OPimOccurrence::operator=( const OPimOccurrence& oc ) {
+    /* guard against self assignment */
+    if ( this == &oc ) return *this;
+
+    oc.data->ref();
+    deref();
+    data = oc.data;
+
+
+    /*
+     * copy the other information
+     */
+    m_start = oc.m_start;
+    m_end   = oc.m_end;
+    m_occurrence = oc.m_occurrence;
+    m_isAllDay = oc.m_isAllDay;
+    m_pos = oc.m_pos;
+
+    return *this;
+}
+
+
+/**
+ * @internal
+ */
+void OPimOccurrence::deref() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0;
+    }
+}
+
+/**
+ * \brief Set the Occurrence to be All Day on a specified QDate
+ *
+ * If no QTime is associated to a OPimOccurrence use this Method
+ * to set the Period of this Occurrence. When using this Method
+ * later calls to \sa isAllDay() will return true.
+ * The Occurrence will be set to occurr on \par from.
+ *
+ * @param from The Day this OPimOccurrence occurs
+ *
+ */
+void OPimOccurrence::setPeriod( const QDate& from ) {
+    m_occurrence = from;
+    m_start = m_end = QTime(); // assign invalid value just in case
+    m_isAllDay = true;
+}
+
+/**
+ * \brief Set the period of this Occurrence with a QTime associated (overloaded)
+ *
+ * Set the period of time for this Occurrence. Each Ocurrence is limited
+ * to one day. Using this Method will make \sa isAllDay() return false.
+ * If \par from and \par to are on two different days the QDate of the
+ * \par from QDateTime will be used.
+ *
+ * @param from The Start Date Time of the Occurrence
+ * @param to   The End Date Time of the Occurrence
+ */
+void OPimOccurrence::setPeriod( const QDateTime& from,  const QDateTime& to ) {
+    m_occurrence = from.date();
+    m_start = from.time();
+    m_end = to.time();
+    m_isAllDay = false;
+}
+
+/**
+ * \brief Set the period of this Occurrence with a QTime associated
+ *
+ * @param from  The QDate of the Occurrence
+ * @param start The Start QTime of the Occurrence
+ * @param end   The End QTime of the Occurrence
+ */
+void OPimOccurrence::setPeriod( const QDate& from, const QTime& start,
+                                const QTime& end ) {
+    m_occurrence = from;
+    m_start = start;
+    m_end = end;
+    m_isAllDay = false;
+}
+
+
+/**
+ * \brief Is a QTime associated to the OPimOccurrence
+ *
+ * @return Return true if no QTime is associated
+ */
+bool OPimOccurrence::isAllDay()const {
+    return m_isAllDay;
+}
+
+
+/**
+ * \brief Return the QDate where this OPimOccurrence takes place
+ * @return the QDate where this OPimOccurrence occurrs.
+ */
+QDate OPimOccurrence::date()const {
+    return m_occurrence;
+}
+
+
+/**
+ * \brief Return the start time of the OPimOccurrence
+ *
+ * @return Return the Start Time of the OPimOccurrence. It is
+ * invalid if \sa isAllDay() returns true.
+ */
+QTime OPimOccurrence::startTime()const {
+    return m_start;
+}
+
+QTime OPimOccurrence::endTime()const {
+    return m_end;
+}
+
+QDateTime OPimOccurrence::startDateTime()const {
+    return QDateTime( m_occurrence, m_start );
+}
+
+QDateTime OPimOccurrence::endDateTime()const {
+    return QDateTime( m_occurrence, m_end );
+}
+
+
+QString OPimOccurrence::summary()const {
+    return data->summary;
+}
+
+QString OPimOccurrence::location()const {
+    return data->location;
+}
+
+QString OPimOccurrence::note()const {
+    return data->note;
+}
+
+
+/**
+ * -1 if no time is associated
+ * otherwise the length of the occurrence in hours
+ */
+int OPimOccurrence::length()const {
+    if ( m_isAllDay )
+        return -1;
+    else
+        return ( m_end.hour() * 60 - m_start.hour() * 60 )
+            + QABS( m_start.minute() - m_end.minute() );
+}
+
+enum OPimOccurrence::Position OPimOccurrence::position()const {
+    return m_pos;
+}
+
+void OPimOccurrence::setPosition( enum OPimOccurrence::Position& pos ) {
+    m_pos = pos;
+}
+
+
+Opie::Core::OSharedPointer<OPimRecord> OPimOccurrence::record()const {
+    if ( !data->record && data->backend )
+        data->record = data->backend->record( data->uid );
+    return data->record;
+}
+
+template<class Record> Record OPimOccurrence::internalToRecord()const {
+    Record target;
+
+    /* If it is not loaded, try to load it using OPimBase */
+    if ( !data->record && data->backend )
+        data->record = data->backend->record( data->uid );
+
+    Record *ta = Record::safeCast( data->record );
+    if ( ta )
+        target = *ta;
+
+
+    return target;
+}
+
+OPimEvent OPimOccurrence::toEvent()const {
+    return internalToRecord<OPimEvent>();
+}
+
+OPimTodo OPimOccurrence::toTodo()const {
+    return internalToRecord<OPimTodo>();
+}
+
+OPimContact OPimOccurrence::toContact()const {
+    return internalToRecord<OPimContact>();
+}
+
+bool OPimOccurrence::operator<( const OPimOccurrence& oc )const {
+    if ( m_occurrence < oc.m_occurrence )
+        return true;
+    if ( m_occurrence == oc.m_occurrence )
+        return m_start < oc.m_start;
+    else
+        return false;
+}
+
+bool OPimOccurrence::operator<=( const OPimOccurrence& oc )const {
+    return ( m_occurrence <= oc.m_occurrence );
+}
+
+bool OPimOccurrence::operator==( const OPimOccurrence& oc )const {
+    if ( data->uid != oc.data->uid )
+        return false;
+    if ( m_occurrence != oc.m_occurrence )
+        return false;
+    if ( m_isAllDay != oc.m_isAllDay )
+        return false;
+    if ( m_isAllDay && oc.m_isAllDay )
+        if ( m_start != oc.m_start ||
+             m_end   != oc.m_end )
+            return false;
+    if ( data->summary != oc.data->summary )
+        return false;
+    if ( data->note != oc.data->note )
+        return false;
+    if ( data->location != oc.data->location )
+        return false;
+
+    return true;
+}
+
+bool OPimOccurrence::operator!=( const OPimOccurrence& oc )const {
+    return !( *this == oc );
+}
+
+bool OPimOccurrence::operator>( const OPimOccurrence& oc )const {
+    return !( *this <= oc );
+}
+
+bool OPimOccurrence::operator>=( const OPimOccurrence& oc )const {
+    return !( *this < oc );
+}
+
+}
diff --git a/libopie2/opiepim/core/opimoccurrence.h b/libopie2/opiepim/core/opimoccurrence.h
new file mode 100644
index 0000000..902638b
--- a/dev/null
+++ b/libopie2/opiepim/core/opimoccurrence.h
@@ -0,0 +1,142 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 2003, 2004 Holger Freyther <zecke@handhelds.org>
+              =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
+            .=l.
+           .>+-=
+ _;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
+.="- .-=="i,     .._         License as published by the Free Software
+ - .   .-<_>     .<>         Foundation; either version 2 of the License,
+     ._= =}       :          or (at your option) any later version.
+    .%`+i>       _;_.
+    .i_,=:_.      -<s.       This program is distributed in the hope that
+     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+    : ..    .:,     . . .    without even the implied warranty of
+    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+ :     =  ...= . :.=-
+ -.   .:....=;==+<;          You should have received a copy of the GNU
+  -_. . .   )=.  =           Library General Public License along with
+    --        :-=`           this library; see the file COPYING.LIB.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#ifndef OPIE_PIM_OCCURRENCE_H
+#define OPIE_PIM_OCCURRENCE_H
+
+#include <opie2/osharedpointer.h>
+#include <opie2/opimrecord.h>
+#include <opie2/opimevent.h>
+#include <opie2/opimtodo.h>
+#include <opie2/opimcontact.h>
+
+#include <qdatetime.h>
+#include <qstringlist.h>
+
+namespace Opie {
+
+template<class T> class OPimAccessTemplate;
+/**
+ * \brief An OPimOccurrence represents a occurence for one day of a OPimRecord
+ *
+ * An OPimOccurrence represents the occurrence of one OPimRecord
+ * for a period of Time for one day. An occurrence can spawn
+ * more then one day and then is splitted into multiple OPimOccurrence.
+ * By attributes you can find if a OPimOccurrence is the beginning and
+ * end, begin, end or is midway of  a multiday occurrence.
+ *
+ */
+class OPimOccurrence {
+    friend class OPimBase;
+public:
+    typedef QValueList<OPimOccurrence> List;
+    /**
+     * The position of the OPimOccurrence in a possible
+     * MultiDay Occurrence.
+     */
+    enum Position {
+        MidWay,  /* This OPimOccurrence is somewhere in between Start and End  */
+        Start,   /* This OPimOccurrence is the Start of a multi day Occurrence */
+        End,     /* This OPimOccurrence is the End of a multi day Occurrence   */
+        StartEnd /* This OPimOccurrence only spans one day                     */
+    };
+
+    //@{
+    OPimOccurrence();
+    OPimOccurrence( const OPimOccurrence& );
+    ~OPimOccurrence();
+    //@}
+
+    //@{
+    void setPeriod( const QDate& from );
+    void setPeriod( const QDateTime& from, const QDateTime& to );
+    void setPeriod( const QDate& from,  const QTime& start, const QTime& end );
+    //@}
+
+    //@{
+    bool isAllDay()const;
+    QDate date()const;
+    QTime startTime()const;
+    QTime endTime()const;
+    QDateTime startDateTime()const;
+    QDateTime endDateTime()const;
+    //@}
+
+    //@{
+    QString summary()const;
+    QString location()const;
+    QString note()const;
+    //@}
+
+    //@{
+    int length()const;
+    Position position()const;
+    void setPosition( enum Position& );
+    //@}
+
+    //@{
+    Opie::Core::OSharedPointer<OPimRecord> record()const;
+    OPimEvent   toEvent()const;
+    OPimTodo    toTodo()const;
+    OPimContact toContact()const;
+    //@}
+
+
+    //@{
+    bool operator< ( const OPimOccurrence& )const;
+    bool operator<=( const OPimOccurrence& )const;
+    bool operator==( const OPimOccurrence& )const;
+    bool operator!=( const OPimOccurrence& )const;
+    bool operator> ( const OPimOccurrence& )const;
+    bool operator>=( const OPimOccurrence& )const;
+    OPimOccurrence &operator=( const OPimOccurrence& );
+    //@}
+
+private:
+    QDate m_occurrence;
+    QTime m_start, m_end;
+    bool m_isAllDay : 1;
+    enum Position m_pos;
+
+    void deref();
+    inline void changeOrModify();
+
+    struct Private;
+    struct Data;
+
+    Data *data;
+    Private *d;
+
+private: // ctor
+    OPimOccurrence( OPimOccurrence::Data *, enum Position );
+    template<class T> T internalToRecord()const;
+};
+}
+
+#endif
diff --git a/libopie2/opiepim/core/opimrecord.cpp b/libopie2/opiepim/core/opimrecord.cpp
index 6546d99..60946e0 100644
--- a/libopie2/opiepim/core/opimrecord.cpp
+++ b/libopie2/opiepim/core/opimrecord.cpp
@@ -99,10 +99,8 @@ void OPimRecord::setCategoryNames( const QStringList& )
 void OPimRecord::addCategoryName( const QString& )
 {
     Categories catDB;
     catDB.load( categoryFileName() );
-
-
 }
 
 
 bool OPimRecord::isEmpty() const
@@ -110,22 +108,8 @@ bool OPimRecord::isEmpty() const
     return ( uid() == 0 );
 }
 
 
-/*QString OPimRecord::crossToString()const {
-    QString str;
-    QMap<QString, QArray<int> >::ConstIterator it;
-    for (it = m_relations.begin(); it != m_relations.end(); ++it ) {
-        QArray<int> id = it.data();
-        for ( uint i = 0; i < id.size(); ++i ) {
-            str += it.key() + "," + QString::number( i ) + ";";
-        }
-    }
-    str = str.remove( str.length()-1, 1); // strip the ;
-    //owarn << "IDS " + str << oendl; 
-
-    return str;
-    }*/
 /* if uid = 1 assign a new one */
 void OPimRecord::setUid( int uid )
 {
     if ( uid == 1 )
@@ -269,5 +253,12 @@ void OPimRecord::setExtraMap( const QMap<QString, QString>& map )
 {
     customMap = map;
 }
 
+#if 0
+QString OPimRecord::recordAttributeTranslated( int field )const
+{
+    return recordAttributeTranslated()[field];
+}
+#endif
+
 }
diff --git a/libopie2/opiepim/core/opimrecord.h b/libopie2/opiepim/core/opimrecord.h
index 127439a..363cc78 100644
--- a/libopie2/opiepim/core/opimrecord.h
+++ b/libopie2/opiepim/core/opimrecord.h
@@ -31,8 +31,10 @@
 #define OPIMRECORD_H
 
 /* OPIE */
 #include <opie2/opimxrefmanager.h>
+#include <opie2/opimglobal.h>
+
 /*
  * we need to get customMap which is private...
  */
 #define private protected
@@ -59,9 +61,9 @@ class OPimRecord : public Qtopia::Record
      * c'tor
      * uid of 0 isEmpty
      * uid of 1 will be assigned a new one
      */
-    OPimRecord( int uid = 0 );
+    OPimRecord( UID uid = 0 );
     ~OPimRecord();
 
     /**
      * copy c'tor
@@ -137,12 +139,17 @@ class OPimRecord : public Qtopia::Record
      */
     QMap<QString, QString> toExtraMap() const;
     void setExtraMap( const QMap<QString, QString>& );
 
+//@{
     /**
      * the name for a recordField
      */
-    virtual QString recordField( int ) const = 0;
+    virtual QString           recordField( int )    const = 0;
+//    virtual QArray<int>       recordAttributes()const = 0;
+//    virtual QMap<int,QString> recordAttributesTranslated() const = 0;
+//    QString                   recordAttributeTranslated(int field)const;
+//@}
 
     /**
      * returns a reference of the
      * Cross Reference Manager
diff --git a/libopie2/opiepim/core/opimrecordlist.h b/libopie2/opiepim/core/opimrecordlist.h
index 1d5027f..0459f41 100644
--- a/libopie2/opiepim/core/opimrecordlist.h
+++ b/libopie2/opiepim/core/opimrecordlist.h
@@ -40,8 +40,9 @@
 
 namespace Opie
 {
 
+template<class T> class OPimAccessTemplate;
 class OPimRecordListIteratorPrivate;
 /**
  * Our List Iterator
  * it behaves like STL or Qt
@@ -119,19 +120,19 @@ class OPimRecordListPrivate;
  */
 template <class T = OPimRecord >
 class OPimRecordList
 {
+   template<class> friend class OPimAccessTemplate;
   public:
     typedef OTemplateBase<T> Base;
     typedef OPimRecordListIterator<T> Iterator;
 
     /**
      * c'tor
      */
-    OPimRecordList ()
-    {}
+    OPimRecordList (){}
     OPimRecordList( const QArray<int>& ids,
-                 const Base* );
+		    const Base* );
     ~OPimRecordList();
 
     /**
      * the first iterator
@@ -159,8 +160,11 @@ class OPimRecordList
     /*
       ConstIterator begin()const;
       ConstIterator end()const;
     */
+  protected:
+    UIDArray uids()const;
+
   private:
     QArray<int> m_ids;
     const Base* m_acc;
     OPimRecordListPrivate *d;
@@ -189,9 +193,8 @@ OPimRecordListIterator<T>::~OPimRecordListIterator()
 
 template <class T>
 OPimRecordListIterator<T>::OPimRecordListIterator( const OPimRecordListIterator<T>& it )
 {
-    //owarn << "OPimRecordListIterator copy c'tor" << oendl;
     m_uids = it.m_uids;
     m_current = it.m_current;
     m_temp = it.m_temp;
     m_end = it.m_end;
@@ -215,9 +218,8 @@ OPimRecordListIterator<T> &OPimRecordListIterator<T>::operator=( const OPimRecor
 
 template <class T>
 T OPimRecordListIterator<T>::operator*()
 {
-    //owarn << "operator* " << m_current << " " << m_uids[m_current] << oendl;
     if ( !m_end )
         m_record = m_temp->find( m_uids[ m_current ], m_uids, m_current,
                                  m_direction ? Base::Forward :
                                  Base::Reverse );
@@ -398,6 +400,11 @@ bool OPimRecordList<T>::remove( int uid )
 
     return ret_val;
 }
 
+template<class T>
+UIDArray OPimRecordList<T>::uids()const {
+    return m_ids;
+}
+
 }
 #endif
diff --git a/libopie2/opiepim/core/opimresolver.h b/libopie2/opiepim/core/opimresolver.h
index 0a6dddf..088474b 100644
--- a/libopie2/opiepim/core/opimresolver.h
+++ b/libopie2/opiepim/core/opimresolver.h
@@ -44,10 +44,8 @@ namespace Opie {
  * 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:
diff --git a/libopie2/opiepim/core/opimstate.h b/libopie2/opiepim/core/opimstate.h
index 8336b3e..ae1e0d2 100644
--- a/libopie2/opiepim/core/opimstate.h
+++ b/libopie2/opiepim/core/opimstate.h
@@ -37,14 +37,8 @@ namespace Opie {
  * The State of a Task
  * This class encapsules the state of a todo
  * and it's shared too
  */
-/*
- * in c a simple struct would be enough ;)
- * g_new_state();
- * g_do_some_thing( state_t*  );
- * ;)
- */
 class OPimState {
 
   public:
     enum State {
diff --git a/libopie2/opiepim/core/opimtemplatebase.cpp b/libopie2/opiepim/core/opimtemplatebase.cpp
new file mode 100644
index 0000000..0a07320
--- a/dev/null
+++ b/libopie2/opiepim/core/opimtemplatebase.cpp
@@ -0,0 +1,112 @@
+/*
+                             This file is part of the Opie Project
+                             Copyright (C) 2004 Holger Freyther <zecke@handhelds.org>
+              =.             Copyright (C) The Opie Team <opie-devel@handhelds.org>
+            .=l.
+           .>+-=
+ _;:,     .>    :=|.         This program is free software; you can
+.> <`_,   >  .   <=          redistribute it and/or  modify it under
+:`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
+.="- .-=="i,     .._         License as published by the Free Software
+ - .   .-<_>     .<>         Foundation; either version 2 of the License,
+     ._= =}       :          or (at your option) any later version.
+    .%`+i>       _;_.
+    .i_,=:_.      -<s.       This program is distributed in the hope that
+     +  .  -:.       =       it will be useful,  but WITHOUT ANY WARRANTY;
+    : ..    .:,     . . .    without even the implied warranty of
+    =_        +     =;=|`    MERCHANTABILITY or FITNESS FOR A
+  _.=:.       :    :=>`:     PARTICULAR PURPOSE. See the GNU
+..}^=.=       =       ;      Library General Public License for more
+++=   -.     .`     .:       details.
+ :     =  ...= . :.=-
+ -.   .:....=;==+<;          You should have received a copy of the GNU
+  -_. . .   )=.  =           Library General Public License along with
+    --        :-=`           this library; see the file COPYING.LIB.
+                             If not, write to the Free Software Foundation,
+                             Inc., 59 Temple Place - Suite 330,
+                             Boston, MA 02111-1307, USA.
+*/
+
+#include "opimtemplatebase.h"
+
+#include <opie2/opimoccurrence.h>
+#include <opie2/private/opimoccurrence_p.h>
+
+namespace Opie {
+
+static void setPeriod( OPimOccurrence& oc, bool period, const QDate& d,
+                       const QTime& s, const QTime& t ) {
+    if ( period )
+        oc.setPeriod( d );
+    else
+        oc.setPeriod( d, s, t );
+}
+
+// namespace Opie {
+OPimBase::OPimBase() {}
+OPimBase::~OPimBase() {}
+
+/**
+ * @internal Convert internal Occurrence representation
+ * to the external
+ */
+OPimOccurrence::List OPimBase::convertOccurrenceFromBackend( const OPimBackendOccurrence::List& lst )const {
+    OPimOccurrence::List oc_lst;
+
+    /*
+     * Split multiday events up. Create the internal data structure
+     * and then iterate over the days and create the OPimOccurrecne.
+     */
+    for ( OPimBackendOccurrence::List::ConstIterator it = lst.begin(); it != lst.end(); ++it ) {
+        OPimBackendOccurrence boc = *it;
+
+        /*
+         * Create the Shared Data Structure
+         */
+        OPimOccurrence::Data *data = new OPimOccurrence::Data();
+        data->summary = boc.summary();
+        data->location = boc.location();
+        data->note = boc.note();
+        data->uid = boc.uid();
+        data->backend = const_cast<OPimBase*>(this);
+
+        QDateTime start = boc.startDateTime();
+        QDateTime end = boc.endDateTime();
+
+        /*
+         * Start and End are on the same day
+         * Start and End are on two different ways.
+         *      - Add Start and End and the days inbetween
+         */
+        int dto = start.daysTo( end );
+        bool allDay = boc.isAllDay();
+
+        if ( dto == 0 ) {
+            OPimOccurrence oc = OPimOccurrence( data, OPimOccurrence::StartEnd );
+            setPeriod( oc, allDay, start.date(), start.time(), end.time() );
+            oc_lst.append( oc );
+        }else {
+
+            OPimOccurrence oc = OPimOccurrence( data, OPimOccurrence::Start );
+            setPeriod( oc, allDay, start.date(), start.time(), QTime(23,59,59));
+            oc_lst.append( oc );
+
+            QDate next = start.addDays( 1 ).date();
+            while ( next != end.date() ) {
+                oc = OPimOccurrence( data, OPimOccurrence::MidWay );
+                setPeriod( oc, allDay, next, QTime(0, 0, 0), QTime(23, 59, 59));
+                oc_lst.append( oc );
+                next = next.addDays( 1 );
+            }
+
+            oc = OPimOccurrence( data, OPimOccurrence::End );
+            setPeriod( oc, allDay, end.date(), QTime(0, 0, 0 ), end.time() );
+            oc_lst.append( oc );
+        }
+    }
+
+    return oc_lst;
+}
+// }
+
+}
diff --git a/libopie2/opiepim/core/opimtemplatebase.h b/libopie2/opiepim/core/opimtemplatebase.h
index 787486c..b238a68 100644
--- a/libopie2/opiepim/core/opimtemplatebase.h
+++ b/libopie2/opiepim/core/opimtemplatebase.h
@@ -31,68 +31,161 @@
 
 /* OPIE */
 #include <opie2/opimrecord.h>
 #include <opie2/opimcache.h>
+#include <opie2/opimoccurrence.h>
+#include <opie2/opimbackendoccurrence.h>
 
 /* QT */
 #include <qarray.h>
+#include <qdatetime.h>
 
 namespace Opie {
+
+class OPimBasePrivate;
+
 /**
- * Templates do not have a base class, This is why
- * we've this class
- * this is here to give us the possibility
- * to have a common base class
- * You may not want to use that interface internaly
- * POOR mans interface
+ * This is the base class for all our Interfaces to the
+ * PIM Records. It is pointer based and can be used
+ * generically for all types of Records.
+ *
  */
-class OPimBasePrivate;
 struct OPimBase {
+    //@{
+    OPimBase();
+    virtual ~OPimBase();
+    //@}
+
+    //@{
     /**
      * return the rtti
      */
     virtual int rtti() const = 0;
     virtual OPimRecord* record()const = 0;
     virtual OPimRecord* record(int uid)const = 0;
+    //@}
+
+    //@{
     virtual bool add( const OPimRecord& ) = 0;
     virtual bool add( const OPimRecord* ) = 0;
+
     virtual bool remove( int uid ) = 0;
     virtual bool remove( const OPimRecord& ) = 0;
+    //@}
+
+    //@{
     virtual void clear() = 0;
     virtual bool load() = 0;
     virtual bool save() = 0;
-    virtual QArray<int> records()const = 0;
-    /*
-     * ADD editing here?
-     * -zecke
+    //@}
+
+    //@{
+    virtual QArray<UID> records()const = 0;
+
+    /** Constants for query.
+     * Use this constants to set the query parameters.
+     * Note: <i>query_IgnoreCase</i> just make sense with one of the other attributes !
+     * @see queryByExample()
      */
-private:
-    OPimBasePrivate* d;     
+    enum QuerySettings {
+        WildCards  = 0x0001, /** Use Wildcards */
+        IgnoreCase = 0x0002, /** Ignore the Case  */
+        RegExp     = 0x0004, /** Do a Regular Expression match */
+        ExactMatch = 0x0008, /** It needs to exactly match     */
+        MatchOne   = 0x0010, /** Only one Entry must match */
+        DateDiff   = 0x0020, /** Find all entries from today until given date */
+        DateYear   = 0x0040, /** The year matches */
+        DateMonth  = 0x0080, /** The month matches */
+        DateDay    = 0x0100, /** The day matches */
+        LastItem   = 0xffff  /** the last possible name */
+    };
 
+    /**
+     * Common Attributes for the Sort Order
+     */
+    enum SortOrderBase {
+        SortSummary = 0,       /** Sort by a Summary of the records */
+        SortByCategory = 1,    /** Sort by Category */
+        SortByDate = 2,        /** Sort by Date */
+        SortCustom  = 10,      /** The First available sort number for the OPimAccessTemplates */
+        LastSortOrderBase = 0xffff /** make this enum 16bit large */
+    };
+
+    /**
+     * Sort with the help of the \sa sorted function
+     * a list of Items.
+     * The Item you provide in SortOrder will be used
+     * for sorting.
+     *
+     * @see sorted
+     */
+    enum SortFilterBase {
+        FilterCategory = 1,
+        FilterCustom = 1024,
+        LastSortFilterBase = 0xffffffff
+    };
+
+    virtual UIDArray matchRegexpSimple( const QRegExp& r )const = 0;
+    virtual UIDArray queryByExampleSimple( const OPimRecord*, int settings,
+                                           const QDateTime& d = QDateTime() )const  = 0;
+    virtual UIDArray sortedSimple( const UIDArray& uid, bool ascending,
+                                   int sortOrder, int sortFilter, int cat)const = 0;
+    virtual UIDArray sortedSimple( const UIDArray& uid, bool ascending,
+                                   int sortOrder, int sortFilter, const QArray<UID>& cats )const = 0;
+    virtual UIDArray sortedSimple( bool ascending, int sortOrder, int sortFilter, int cat)const = 0;
+    virtual UIDArray sortedSimple( bool ascending, int sortOrder, int sortFilter, const QArray<UID>& cats )const = 0;
+    virtual OPimOccurrence::List occurrences( const QDate& start,  const QDate& end )const = 0;
+    virtual OPimOccurrence::List occurrences( const QDateTime& dt )const = 0;
+    //@}
+
+
+protected:
+    OPimOccurrence::List convertOccurrenceFromBackend( const OPimBackendOccurrence::List& )const;
+
+private:
+    OPimBasePrivate* d;
 };
+
+
 /**
  * internal template base
  * Attention: T needs to implement the copy c'tor!!!
  */
 class OTemplateBasePrivate;
 template <class T = OPimRecord>
 class OTemplateBase : public OPimBase {
 public:
-    /** Look ahead direction of cache */ 
-    enum CacheDirection { Forward=0, Reverse };
-
-    OTemplateBase() {
+    /**
+     * The Direction for ReadAhead/ReadBehind which will
+     * be used by the backends to Cache Items in
+     * advance.
+     * For example if you know that you will access the
+     * next ten items you can give the backend a hint
+     * to read ahead or read before.
+     */
+    enum CacheDirection {
+        Forward=0, /** Go forward   when caching (++ to the index) */
+        Reverse    /** Go backward  when caching (-- to the index) */
     };
-    virtual ~OTemplateBase() {
-    }
+
+
+    //@{
+    OTemplateBase() {};
+    virtual ~OTemplateBase() {}
+    //@}
+
+
+    //@{
     virtual T find( int uid )const = 0;
 
     /**
      * read ahead find
      */
     virtual T find( int uid, const QArray<int>& items,
                     uint current, CacheDirection dir = Forward )const = 0;
+    //@}
 
+    //@{
    /**
     * Put element into Cache
     */
     virtual void cache( const T& )const = 0;
@@ -100,12 +193,12 @@ public:
 
     OPimRecord* record()const;
     OPimRecord* record(int uid )const;
     static T* rec();
+    //@}
 
-    
 private:
-    OTemplateBasePrivate *d;    
+    OTemplateBasePrivate *d;
 };
 
 
 template <class T>
@@ -118,13 +211,13 @@ OPimRecord* OTemplateBase<T>::record(int uid )const {
     T  t2 = find(uid );
     T* t1 = new T(t2);
 
     return t1;
-};
+}
+
 template <class T>
 T* OTemplateBase<T>::rec() {
     return new T;
 }
-
 }
 
 #endif
diff --git a/libopie2/opiepim/core/opimtimezone.cpp b/libopie2/opiepim/core/opimtimezone.cpp
index 5b32b1f..1dc36b4 100644
--- a/libopie2/opiepim/core/opimtimezone.cpp
+++ b/libopie2/opiepim/core/opimtimezone.cpp
@@ -39,27 +39,45 @@
 
 namespace Opie
 {
 
-QDateTime utcTime( time_t t )
+/*
+ * Save the old timeZone in a secure way (NULL Pointer check),
+ * set the new timeZone from the parameter, call tzset
+ * and then return the old timezone
+ */
+static QString setTimeZone( const QString& zone) {
+    QString old;
+    char *org = ::getenv( "TZ" );
+    if( org )
+        old = QString::fromLocal8Bit( org );
+
+    ::setenv( "TZ", zone.local8Bit(), true );
+    ::tzset();
+
+    return old;
+}
+
+static void resetTimeZone( const QString& zone ) {
+    ::setenv( "TZ", zone.local8Bit(), true );
+}
+
+static QDateTime utcTime( time_t t )
 {
     tm * broken = ::gmtime( &t );
     QDateTime ret;
     ret.setDate( QDate( broken->tm_year + 1900, broken->tm_mon + 1, broken->tm_mday ) );
     ret.setTime( QTime( broken->tm_hour, broken->tm_min, broken->tm_sec ) );
     return ret;
 }
 
-QDateTime utcTime( time_t t, const QString& zone )
+static QDateTime utcTime( time_t t, const QString& zone )
 {
-    QCString org = ::getenv( "TZ" );
-#ifndef Q_OS_MACX   // Following line causes bus errors on Mac
-
-    ::setenv( "TZ", zone.latin1(), true );
-    ::tzset();
 
+#ifndef Q_OS_MACX   // Following line causes bus errors on Mac
+    QString old = setTimeZone( zone );
     tm* broken = ::localtime( &t );
-    ::setenv( "TZ", org, true );
+    resetTimeZone( old );
 #else
 #warning "Need a replacement for MacOSX!!"
 
     tm* broken = ::localtime( &t );
@@ -72,9 +90,9 @@ QDateTime utcTime( time_t t, const QString& zone )
     return ret;
 }
 
 
-time_t to_Time_t( const QDateTime& utc, const QString& str )
+static time_t to_Time_t( const QDateTime& utc, const QString& str )
 {
     QDate d = utc.date();
     QTime t = utc.time();
 
@@ -85,16 +103,12 @@ time_t to_Time_t( const QDateTime& utc, const QString& str )
     broken.tm_hour = t.hour();
     broken.tm_min = t.minute();
     broken.tm_sec = t.second();
 
-    QCString org = ::getenv( "TZ" );
 #ifndef Q_OS_MACX   // Following line causes bus errors on Mac
-
-    ::setenv( "TZ", str.latin1(), true );
-    ::tzset();
-
+    QString old = setTimeZone( str );
     time_t ti = ::mktime( &broken );
-    ::setenv( "TZ", org, true );
+    resetTimeZone( old );
 #else
 #warning "Need a replacement for MacOSX!!"
 
     time_t ti = ::mktime( &broken );
diff --git a/libopie2/opiepim/core/opimtodo.cpp b/libopie2/opiepim/core/opimtodo.cpp
index 27b36a6..16ca987 100644
--- a/libopie2/opiepim/core/opimtodo.cpp
+++ b/libopie2/opiepim/core/opimtodo.cpp
@@ -63,8 +63,9 @@ struct OPimTodo::OPimTodoData : public QShared
     {
         delete recur;
         delete maintainer;
         delete notifiers;
+        delete state;
     }
 
     QDate date;
     bool isCompleted: 1;
@@ -86,19 +87,16 @@ struct OPimTodo::OPimTodoData : public QShared
 OPimTodo::OPimTodo( const OPimTodo &event )
         : OPimRecord( event ), data( event.data )
 {
     data->ref();
-    //    owarn << "ref up" << oendl;
 }
 
 
 OPimTodo::~OPimTodo()
 {
 
-    //    owarn << "~OPimTodo " << oendl;
     if ( data->deref() )
     {
-        //        owarn << "OPimTodo::dereffing" << oendl;
         delete data;
         data = 0l;
     }
 }
@@ -111,9 +109,8 @@ OPimTodo::OPimTodo( bool completed, int priority,
               ushort progress,
               bool hasDate, QDate date, int uid )
         : OPimRecord( uid )
 {
-    //    owarn << "OPimTodoData " + summary << oendl;
     setCategories( category );
 
     data = new OPimTodoData;
 
@@ -134,9 +131,8 @@ OPimTodo::OPimTodo( bool completed, int priority,
               ushort progress,
               bool hasDate, QDate date, int uid )
         : OPimRecord( uid )
 {
-    //    owarn << "OPimTodoData" + summary << oendl;
     setCategories( idsFromString( category.join( ";" ) ) );
 
     data = new OPimTodoData;
 
@@ -186,15 +182,35 @@ bool OPimTodo::hasDueDate() const
 {
     return data->hasDate;
 }
 
-
+/**
+ * \brief Does this Todo have a start date
+ *
+ * Does this Todo have a start date. The decision
+ * is based on if the internal startDate isValid
+ * in the sense of QDate::isValid.
+ *
+ * @return True if the startDate isValid
+ * @see startDate
+ * @see setStartDate
+ * @see QDate::isValid()
+ */
 bool OPimTodo::hasStartDate() const
 {
     return data->start.isValid();
 }
 
-
+/**
+ * \brief Does this Todo have a Date when it was completed
+ *
+ * As in \sa hasStartDate() it is determined if there
+ * is a completed date by looking if the internal date
+ * isValid \sa QDate::isValid.
+ *
+ * @see hasStartDate
+ * @return True if the completedDate is set and valid.
+ */
 bool OPimTodo::hasCompletedDate() const
 {
     return data->completed.isValid();
 }
@@ -307,9 +323,8 @@ void OPimTodo::setHasDueDate( bool hasDate )
 
 
 void OPimTodo::setDescription( const QString &desc )
 {
-    //    owarn << "desc " + desc << oendl;
     changeOrModify();
     data->desc = Qtopia::simplifyMultiLineSpace( desc );
 }
 
@@ -379,9 +394,9 @@ void OPimTodo::setMaintainer( const OPimMaintainer& pim )
         data->maintainer = new OPimMaintainer( pim );
 }
 
 
-bool OPimTodo::isOverdue( )
+bool OPimTodo::isOverdue( )const
 {
     if ( data->hasDate && !data->isCompleted )
         return QDate::currentDate() > data->date;
     return false;
@@ -592,12 +607,10 @@ bool OPimTodo::operator==( const OPimTodo &toDoEvent ) const
 
 void OPimTodo::deref()
 {
 
-    //    owarn << "deref in ToDoEvent" << oendl;
     if ( data->deref() )
     {
-        //        owarn << "deleting" << oendl;
         delete data;
         data = 0;
     }
 }
@@ -607,9 +620,8 @@ OPimTodo &OPimTodo::operator=( const OPimTodo &item )
 {
     if ( this == &item ) return * this;
 
     OPimRecord::operator=( item );
-    //owarn << "operator= ref " << oendl;
     item.data->ref();
     deref();
     data = item.data;
 
@@ -650,9 +662,8 @@ QMap<int, QString> OPimTodo::toMap() const
 void OPimTodo::changeOrModify()
 {
     if ( data->count != 1 )
     {
-        owarn << "changeOrModify" << oendl;
         data->deref();
         OPimTodoData* d2 = new OPimTodoData();
         copy( data, d2 );
         data = d2;
@@ -698,16 +709,102 @@ QString OPimTodo::type() const
     return QString::fromLatin1( "OPimTodo" );
 }
 
 
-QString OPimTodo::recordField( int /*id*/ ) const
+QString OPimTodo::recordField( int  id) const
 {
-    return QString::null;
+    QString res;
+    Q_UNUSED( id )
+#if 0
+    switch( id ) {
+    case HasDate:
+        res = (hasDueDate() ?
+              QObject::tr( "Has a due-date" )
+              : QObject::tr( "No due-date" ));
+        break;
+    case Completed:
+        res = ( isCompleted() ?
+                QObject::tr( "Completed" ) :
+                QObject::tr( "Not completed" ));
+        break;
+    case Description:
+        res = description();
+        break;
+    case Summary:
+        res = summary();
+        break;
+    case Priority:
+        res = QString::number( priority() );
+        break;
+    case DateDay:
+        res = QString::number( dueDate().day() );
+        break;
+    case DateMonth:
+        res = QString::number( dueDate().month() );
+        break;
+    case DateYear:
+        res = QString::number( dueDate().year() );
+        break;
+    case Progress:
+        res = QString::number( progress() );
+        break;
+    case State:
+        res = QString::number( state().state() );
+        break;
+    case Recurrence:
+        res = ( hasRecurrence() ?
+                QString::null /*recurrence().summary()*/ :
+                QObject::tr("No reccurrence"));
+        break;
+    case Alarms:
+        break;
+    case Reminders:
+        break;
+    case Maintainer:
+        break;
+    case StartDate:
+        res = ( hasStartDate() ?
+                /*TimeString::()*/ QString::null :
+                QObject::tr( "No start-date" ) );
+        break;
+    case CompletedDate:
+        res = ( hasCompletedDate() ?
+                /*TimeString::()*/ QString::null :
+                QObject::tr( "No completed-date" ) );
+        break;
+    case DueDate:
+        res = ( hasDueDate() ?
+                /*TimeString::()*/ QString::null :
+                QObject::tr( "No due-date" );
+                break;
+    default:
+        res = OPimRecord::recordField( id );
+    }
+
+#endif
+    return res;
 }
 
 
 int OPimTodo::rtti() const
 {
     return OPimResolver::TodoList;
 }
 
+/**
+ * \brief Provide a SafeCast to OPimTodo from a OPimRecord
+ *
+ * Provide a safe cast that will return 0 if the record
+ * type is not OPimTodo. In the other case it will
+ * be casted to OPimTodo and returned
+ *
+ * @param rec The OPimRecord to be casted
+ *
+ * @return a pointer to OPimTodo or 0l
+ */
+OPimTodo* OPimTodo::safeCast( const OPimRecord* rec ) {
+    return (rec && rec->rtti() == OPimResolver::TodoList ) ?
+        static_cast<OPimTodo*>( const_cast<OPimRecord*>(rec) ) :
+        0l;
+}
+
 }
diff --git a/libopie2/opiepim/core/opimtodo.h b/libopie2/opiepim/core/opimtodo.h
index e17fe6a..f4f9926 100644
--- a/libopie2/opiepim/core/opimtodo.h
+++ b/libopie2/opiepim/core/opimtodo.h
@@ -69,13 +69,14 @@ class OPimTodo : public OPimRecord
         CrossReference,
         State,
         Recurrence,
         Alarms,
-        Reminders,
-        Notifiers,
+	Reminders,
         Maintainer,
         StartDate,
-        CompletedDate
+	CompletedDate,
+//ADDITIONAL FOR RECORDFIELD
+	DueDate,
     };
   public:
     // priorities from Very low to very high
     enum TaskPriority { VeryHigh = 1, High, Normal, Low, VeryLow };
@@ -281,9 +282,9 @@ class OPimTodo : public OPimRecord
      * set the Maintainer Mode
      */
     void setMaintainer( const OPimMaintainer& );
 
-    bool isOverdue();
+    bool isOverdue()const;
 
 
     virtual bool match( const QRegExp &r ) const;
 
@@ -294,9 +295,13 @@ class OPimTodo : public OPimRecord
     bool operator>=( const OPimTodo &toDoEvent ) const;
     bool operator==( const OPimTodo &toDoEvent ) const;
     OPimTodo &operator=( const OPimTodo &toDoEvent );
 
+    //@{
     int rtti() const;
+    static OPimTodo* safeCast( const OPimRecord* );
+    //@}
+
 
   private:
     class OPimTodoPrivate;
     struct OPimTodoData;
diff --git a/libopie2/opiepim/core/otodoaccess.cpp b/libopie2/opiepim/core/otodoaccess.cpp
index 26a68a0..4ad5950 100644
--- a/libopie2/opiepim/core/otodoaccess.cpp
+++ b/libopie2/opiepim/core/otodoaccess.cpp
@@ -49,50 +49,37 @@ OPimTodoAccess::OPimTodoAccess( OPimTodoAccessBackend* end, enum Access )
 
     setBackEnd( m_todoBackEnd );
 }
 OPimTodoAccess::~OPimTodoAccess() {
-//    owarn << "~OPimTodoAccess" << oendl; 
 }
+
 void OPimTodoAccess::mergeWith( const QValueList<OPimTodo>& list ) {
     QValueList<OPimTodo>::ConstIterator it;
     for ( it = list.begin(); it != list.end(); ++it ) {
         replace( (*it) );
     }
 }
 OPimTodoAccess::List OPimTodoAccess::effectiveToDos( const QDate& start,
                                                const QDate& end,
-                                               bool includeNoDates ) {
+                                               bool includeNoDates )const {
     QArray<int> ints = m_todoBackEnd->effectiveToDos( start, end, includeNoDates );
 
     List lis( ints, this );
     return lis;
 }
 OPimTodoAccess::List OPimTodoAccess::effectiveToDos( const QDate& start,
-                                               bool includeNoDates ) {
+                                               bool includeNoDates )const {
     return effectiveToDos( start, QDate::currentDate(),
                            includeNoDates );
 }
-OPimTodoAccess::List OPimTodoAccess::overDue() {
+OPimTodoAccess::List OPimTodoAccess::overDue()const {
     List lis( m_todoBackEnd->overDue(), this );
     return lis;
 }
-/* sort order */
-OPimTodoAccess::List OPimTodoAccess::sorted( bool ascending, int sort,int filter, int cat ) {
-    QArray<int> ints = m_todoBackEnd->sorted( ascending, sort,
-                                      filter, cat );
-    OPimTodoAccess::List list( ints, this );
-    return list;
-}
+
 void OPimTodoAccess::removeAllCompleted() {
     m_todoBackEnd->removeAllCompleted();
 }
-QBitArray OPimTodoAccess::backendSupport( const QString& ) const{
-    return m_todoBackEnd->supports();
-}
-bool OPimTodoAccess::backendSupports( int attr,  const QString& ar) const{
-    return backendSupport(ar).testBit( attr );
-}
-
 
 int OPimTodoAccess::rtti() const
 {
 	return OPimResolver::TodoList;
diff --git a/libopie2/opiepim/core/otodoaccess.h b/libopie2/opiepim/core/otodoaccess.h
index 3f5af30..8338586 100644
--- a/libopie2/opiepim/core/otodoaccess.h
+++ b/libopie2/opiepim/core/otodoaccess.h
@@ -45,15 +45,13 @@ namespace Opie {
  */
 class OPimTodoAccess : public QObject, public OPimAccessTemplate<OPimTodo> {
     Q_OBJECT
 public:
-    enum SortOrder { Completed = 0,
+    enum SortOrder { Completed = SortCustom,
                      Priority,
-                     Description,
                      Deadline };
-    enum SortFilter{ Category =1,
-                     OnlyOverDue= 2,
-                     DoNotShowCompleted =4  };
+    enum SortFilter{ OnlyOverDue= FilterCustom,
+                     DoNotShowCompleted = FilterCustom<<1  };
     /**
      * if you use 0l
      * the default resource will be
      * picked up
@@ -69,27 +67,22 @@ public:
      * events with no dates
      */
     List effectiveToDos( const QDate& start,
                          const QDate& end,
-                         bool includeNoDates = true );
+                         bool includeNoDates = true )const;
 
     /**
      * start
      * end date taken from the currentDate()
      */
     List effectiveToDos( const QDate& start,
-                         bool includeNoDates = true );
+                         bool includeNoDates = true )const;
 
 
     /**
      * return overdue OPimTodos
      */
-    List overDue();
-
-    /**
-     *
-     */
-    List sorted( bool ascending, int sortOrder, int sortFilter, int cat );
+    List overDue()const;
 
     /**
      * merge a list of OPimTodos into
      * the resource
@@ -101,25 +94,8 @@ public:
      */
     void removeAllCompleted();
 
     /**
-     * request information about what a backend supports.
-     * Supports in the sense of beeing able to store.
-     * This is related to the enum in OPimTodo
-     *
-     * @param backend Will be used in the future when we support multiple backend
-     */
-    QBitArray backendSupport( const QString& backend = QString::null )const;
-
-    /**
-     * see above but for a specefic attribute. This method was added for convience
-     * @param attr The attribute to be queried for
-     * @param backend Will be used in the future when we support multiple backends
-     */
-    bool backendSupports( int attr, const QString& backend = QString::null  )const;
-
-
-    /** 
      * Return identification of used records
      */
     int rtti() const;
 signals: