4 files changed, 184 insertions, 1 deletions

diff --git a/libopie2/opiepim/backend/otodoaccesssql.cpp b/libopie2/opiepim/backend/otodoaccesssql.cpp
index 8c2ea3a..761d7d8 100644
--- a/libopie2/opiepim/backend/otodoaccesssql.cpp
+++ b/libopie2/opiepim/backend/otodoaccesssql.cpp
@@ -376,97 +376,97 @@ QArray<int> OTodoAccessBackendSQL::sorted( bool asc, int sortOrder,
                                            int sortFilter, int cat ) {
     qWarning("sorted %d, %d", asc, sortOrder );
     QString query;
     query = "select uid from todolist WHERE ";
 
     /*
      * Sort Filter stuff
      * not that straight forward
      *
      */
     /* Category */
     if ( sortFilter & 1 ) {
         QString str;
         if (cat != 0 ) str = QString::number( cat );
         query += " categories like '%" +str+"%' AND";
     }
     /* Show only overdue */
     if ( sortFilter & 2 ) {
         QDate date = QDate::currentDate();
         QString due;
         QString base;
         base = QString("DueDate <= '%1-%2-%3' AND completed = 0").arg( date.year() ).arg( date.month() ).arg( date.day() );
         query += " " + base + " AND";
     }
     /* not show completed */
     if ( sortFilter & 4 ) {
         query += " completed = 0 AND";
     }else{
        query += " ( completed = 1 OR  completed = 0) AND";
     }
     /* srtip the end */
     query = query.remove( query.length()-3, 3 );
 
 
     /*
      * sort order stuff
      * quite straight forward
      */
     query += "ORDER BY ";
     switch( sortOrder ) {
         /* completed */
     case 0:
         query += "completed";
         break;
     case 1:
         query += "priority";
         break;
     case 2:
-        query += "description";
+        query += "summary";
         break;
     case 3:
         query += "DueDate";
         break;
     }
 
     if ( !asc ) {
         qWarning("not ascending!");
         query += " DESC";
     }
 
     qWarning( query );
     OSQLRawQuery raw(query );
     return uids( m_driver->query(&raw) );
 }
 bool OTodoAccessBackendSQL::date( QDate& da, const QString& str ) const{
     if ( str == "0-0-0" )
         return false;
     else{
         int day, year, month;
         QStringList list = QStringList::split("-", str );
         year = list[0].toInt();
         month = list[1].toInt();
         day = list[2].toInt();
         da.setYMD( year, month, day );
         return true;
     }
 }
 OTodo OTodoAccessBackendSQL::todo( const OSQLResult& res) const{
     if ( res.state() == OSQLResult::Failure ) {
         OTodo to;
         return to;
     }
 
     OSQLResultItem::ValueList list = res.results();
     OSQLResultItem::ValueList::Iterator it = list.begin();
     qWarning("todo1");
     OTodo to = todo( (*it) );
     cache( to );
     ++it;
 
     for ( ; it != list.end(); ++it ) {
         qWarning("caching");
         cache( todo( (*it) ) );
     }
     return to;
 }
 OTodo OTodoAccessBackendSQL::todo( OSQLResultItem& item )const {
diff --git a/libopie2/opiepim/core/orecur.cpp b/libopie2/opiepim/core/orecur.cpp
new file mode 100644
index 0000000..6c81f8f
--- a/dev/null
+++ b/libopie2/opiepim/core/orecur.cpp
@@ -0,0 +1,127 @@
+#include <qshared.h>
+
+#include <qtopia/timeconversion.h>
+
+#include "orecur.h"
+
+struct ORecur::Data : public QShared {
+    Data() : QShared() {
+        type = ORecur::NoRepeat;
+        freq = -1;
+        days = 0;
+        pos = 0;
+        create = -1;
+        hasEnd = FALSE;
+        end = 0;
+    }
+    char days; // Q_UINT8 for 8 seven days;)
+    ORecur::RepeatType type;
+    int freq;
+    int pos;
+    bool hasEnd : 1;
+    time_t end;
+    time_t create;
+};
+
+
+ORecur::ORecur() {
+    data = new Data;
+}
+ORecur::ORecur( const ORecur& rec)
+    : data( rec.data )
+{
+    data->ref();
+}
+ORecur::~ORecur() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0l;
+    }
+}
+void ORecur::deref() {
+    if ( data->deref() ) {
+        delete data;
+        data = 0l;
+    }
+}
+bool ORecur::operator==( const ORecur& )const {
+    return false;
+}
+ORecur &ORecur::operator=( const ORecur& re) {
+    re.data->ref();
+    deref();
+    data = re.data;
+
+    return *this;
+}
+ORecur::RepeatType ORecur::type()const{
+    return data->type;
+}
+int ORecur::frequency()const {
+    return data->freq;
+}
+int ORecur::position()const {
+    return data->pos;
+}
+char ORecur::days() const{
+    return data->days;
+}
+bool ORecur::hasEndDate()const {
+    return data->hasEnd;
+}
+QDate ORecur::endDate()const {
+    return TimeConversion::fromUTC( data->end ).date();
+}
+time_t ORecur::endDateUTC()const {
+    return data->end;
+}
+time_t ORecur::createTime()const {
+    return data->create;
+}
+void ORecur::setType( const RepeatType& z) {
+    checkOrModify();
+    data->type = z;
+}
+void ORecur::setFrequency( int freq ) {
+    checkOrModify();
+    data->freq = freq;
+}
+void ORecur::setPosition( int pos ) {
+    checkOrModify();
+    data->pos = pos;
+}
+void ORecur::setDays( char c ) {
+    checkOrModify();
+    data->days = c;
+}
+void ORecur::setEndDate( const QDate& dt) {
+    checkOrModify();
+    data->end = TimeConversion::toUTC( dt );
+}
+void ORecur::setEndDateUTC( time_t t) {
+    checkOrModify();
+    data->end = t;
+}
+void ORecur::setCreateTime( time_t t) {
+    checkOrModify();
+    data->create = t;
+}
+void ORecur::setHasEndDate( bool b) {
+    checkOrModify();
+    data->hasEnd = b;
+}
+void ORecur::checkOrModify() {
+    if ( data->count !=  1 ) {
+        data->deref();
+        Data* d2 = new Data;
+        d2->days = data->days;
+        d2->type = data->type;
+        d2->freq = data->freq;
+        d2->pos  = data->pos;
+        d2->hasEnd = data->hasEnd;
+        d2->end  = data->end;
+        d2->create = data->create;
+        data = d2;
+    }
+}
+
diff --git a/libopie2/opiepim/core/orecur.h b/libopie2/opiepim/core/orecur.h
new file mode 100644
index 0000000..89258f8
--- a/dev/null
+++ b/libopie2/opiepim/core/orecur.h
@@ -0,0 +1,54 @@
+/*
+ * GPL from TT
+ */
+
+#ifndef OPIE_RECUR_H
+#define OPIE_RECUR_H
+
+#include <sys/types.h>
+
+#include <qdatetime.h>
+
+
+
+class ORecur {
+public:
+    enum RepeatType{ NoRepeat = -1, Daily, Weekly, MonthlyDay,
+                     MonthlyDate, Yearly };
+    enum Days { MON = 0x01, TUE = 0x02, WED = 0x04, THU = 0x08,
+                FRI = 0x10, SAT = 0x20, SUN = 0x40 };
+    ORecur();
+    ORecur( const ORecur& );
+    ~ORecur();
+
+    ORecur &operator=( const ORecur& );
+    bool operator==(const ORecur& )const;
+    RepeatType type()const;
+    int frequency()const;
+    int position()const;
+    char days()const;
+    bool hasEndDate()const;
+    QDate endDate()const;
+    time_t endDateUTC()const;
+    time_t createTime()const;
+
+    void setType( const RepeatType& );
+    void setFrequency( int freq );
+    void setPosition( int pos );
+    void setDays( char c);
+    void setEndDate( const QDate& dt );
+    void setEndDateUTC( time_t );
+    void setCreateTime( time_t );
+    void setHasEndDate( bool b );
+private:
+    void deref();
+    inline void checkOrModify();
+
+
+    class Data;
+    Data* data;
+    class ORecurPrivate;
+    ORecurPrivate *d;
+};
+
+#endif
diff --git a/libopie2/opiepim/orecordlist.h b/libopie2/opiepim/orecordlist.h
index 5404910..e377447 100644
--- a/libopie2/opiepim/orecordlist.h
+++ b/libopie2/opiepim/orecordlist.h
@@ -215,56 +215,58 @@ ORecordListIterator<T>::ORecordListIterator( const QArray<int> uids,
     : m_uids( uids ), m_current( 0 ),  m_temp( t ), m_end( false ),
       m_direction( false )
 {
 }
 template <class T>
 uint ORecordListIterator<T>::current()const {
     return m_current;
 }
 template <class T>
 void ORecordListIterator<T>::setCurrent( uint cur ) {
     if( cur < m_uids.count() ) {
         m_end = false;
         m_current= cur;
     }
 }
 template <class T>
 uint ORecordListIterator<T>::count()const {
  return m_uids.count();
 }
 template <class T>
 ORecordList<T>::ORecordList( const QArray<int>& ids,
                              const Base* acc )
     : m_ids( ids ), m_acc( acc )
 {
 }
 template <class T>
 ORecordList<T>::~ORecordList() {
 /* nothing to do here */
 }
 template <class T>
 ORecordList<T>::Iterator ORecordList<T>::begin() {
     Iterator it( m_ids, m_acc );
     return it;
 }
 template <class T>
 ORecordList<T>::Iterator ORecordList<T>::end() {
     Iterator it( m_ids, m_acc );
     it.m_end = true;
     it.m_current = m_ids.count();
 
     return it;
 }
 template <class T>
 uint ORecordList<T>::count()const {
 return m_ids.count();
 }
 template <class T>
 T ORecordList<T>::operator[]( uint i ) {
+    if ( i < 0 || (i+1) > m_ids.count() )
+        return T();
     /* forward */
     return m_acc->find( m_ids[i], m_ids, i );
 }
 template <class T>
 int ORecordList<T>::uidAt( uint i ) {
     return m_ids[i];
 }
 #endif