32 files changed, 1225 insertions, 98 deletions
diff --git a/libopie/pim/ABSTRACT b/libopie/pim/ABSTRACT new file mode 100644 index 0000000..5538d19 --- a/dev/null +++ b/libopie/pim/ABSTRACT @@ -0,0 +1,18 @@ +What is Opie PIM? Why is it special? +Why do we need Opie PIM? + +The goal of OpiePIM is to be first of all +extendable, light weight, scalable and fast. +For the programmer we try to add a nice but +powerful API to all classes. + +Memory is a costy resource on small and embedded +devices. So we try to keep the memory usage as +low as possible. Never the less we won't use structs +and Pointers in the public API. +The whole pim framework is value based. Internally we try +to use implicit sharing as found in other Qt classes as well. +This makes it possible to give 3rd party devels a nice +API while keeping the memory usage as low as possible. + +We use C++ Templates diff --git a/libopie/pim/ocontact.cpp b/libopie/pim/ocontact.cpp index 917eb0a..efa2777 100644 --- a/libopie/pim/ocontact.cpp +++ b/libopie/pim/ocontact.cpp @@ -1092,12 +1092,14 @@ void OContact::setDefaultEmail( const QString &v ) void OContact::insertEmails( const QStringList &v ) { for ( QStringList::ConstIterator it = v.begin(); it != v.end(); ++it ) insertEmail( *it ); } - +int OContact::rtti() { + return 2; +} void OContact::setUid( int i ) { OPimRecord::setUid(i); replace( Qtopia::AddressUid , QString::number(i)); } diff --git a/libopie/pim/ocontact.h b/libopie/pim/ocontact.h index d97af1c..65ba43e 100644 --- a/libopie/pim/ocontact.h +++ b/libopie/pim/ocontact.h @@ -43,13 +43,13 @@ public: OContact(); OContact( const QMap<int, QString> &fromMap ); virtual ~OContact(); enum journal_action { ACTION_ADD, ACTION_REMOVE, ACTION_REPLACE }; - /* + /* * do we need to inline them * if yes do we need to inline them this way? * -zecke */ void setTitle( const QString &v ) { replace( Qtopia::Title, v ); } void setFirstName( const QString &v ) { replace( Qtopia::FirstName, v ); } @@ -208,12 +208,13 @@ public: // Why private ? (eilers,se) QString emailSeparator() const { return " "; } // the emails should be seperated by a comma void setEmails( const QString &v ); QString emails() const { return find( Qtopia::Emails ); } + static int rtti(); private: // The XML-Backend needs some access to the private functions friend class OContactAccessBackend_XML; diff --git a/libopie/pim/opimaccesstemplate.h b/libopie/pim/opimaccesstemplate.h index 6de68b1..8cf81c8 100644 --- a/libopie/pim/opimaccesstemplate.h +++ b/libopie/pim/opimaccesstemplate.h @@ -90,12 +90,13 @@ public: /** * add T to the backend * @param t The item to add. * @return <i>true</i> if added successfully. */ virtual bool add( const T& t ) ; + 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. @@ -209,12 +210,21 @@ void OPimAccessTemplate<T>::clear() { template <class T> bool OPimAccessTemplate<T>::add( const T& t ) { cache( 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() ); } template <class T> bool OPimAccessTemplate<T>::remove( int uid ) { m_cache.remove( uid ); diff --git a/libopie/pim/opimmaintainer.cpp b/libopie/pim/opimmaintainer.cpp index e34f035..92cb25a 100644 --- a/libopie/pim/opimmaintainer.cpp +++ b/libopie/pim/opimmaintainer.cpp @@ -1,9 +1,9 @@ #include "opimmaintainer.h" -OPimMaintainer::OPimMaintainer( enum Mode mode, int uid ) +OPimMaintainer::OPimMaintainer( int mode, int uid ) : m_mode(mode), m_uid(uid ) {} OPimMaintainer::~OPimMaintainer() { } OPimMaintainer::OPimMaintainer( const OPimMaintainer& main ) { *this = main; @@ -20,18 +20,18 @@ bool OPimMaintainer::operator==( const OPimMaintainer& main ) { return true; } 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 ) { m_uid = uid; } diff --git a/libopie/pim/opimmaintainer.h b/libopie/pim/opimmaintainer.h index 310e15a..793d066 100644 --- a/libopie/pim/opimmaintainer.h +++ b/libopie/pim/opimmaintainer.h @@ -6,31 +6,35 @@ /** * Who maintains what? */ 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(); OPimMaintainer &operator=( const OPimMaintainer& ); bool operator==( const OPimMaintainer& ); 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; }; #endif diff --git a/libopie/pim/opimmainwindow.cpp b/libopie/pim/opimmainwindow.cpp new file mode 100644 index 0000000..92be2fd --- a/dev/null +++ b/libopie/pim/opimmainwindow.cpp @@ -0,0 +1,71 @@ +#include <qapplication.h> +#include <qcopchannel_qws.h> + +#include <qpe/qcopenvelope_qws.h> + +#include "opimmainwindow.h" + +OPimMainWindow::OPimMainWindow( const QString& service, QWidget* parent, + const char* name, WFlags flag ) + : QMainWindow( parent, name, flag ), m_service( service ), m_fallBack(0l) { + + /* + * let's generate our QCopChannel + */ + m_str = QString("QPE/"+m_service).local8Bit(); + m_channel= new QCopChannel(m_str, this ); + connect(m_channel, SIGNAL(received(const QCString&, const QByteArray& ) ), + this, SLOT( appMessage( const QCString&, const QByteArray& ) ) ); + + /* connect flush and reload */ + connect(qApp, SIGNAL(flush() ), + this, SLOT(flush() ) ); + connect(qApp, SIGNAL(reload() ), + this, SLOT(reload() ) ); +} +OPimMainWindow::~OPimMainWindow() { + delete m_channel; +} +QCopChannel* OPimMainWindow::channel() { + return m_channel; +} +void OPimMainWindow::appMessage( const QCString& cmd, const QByteArray& array ) { + /* + * create demands to create + * a new record... + */ + QDataStream stream(array, IO_ReadOnly); + if ( cmd == "create()" ) { + int uid = create(); + QCopEnvelope e(m_str, "created(int)" ); + e << uid; + }else if ( cmd == "remove(int)" ) { + int uid; + stream >> uid; + bool rem = remove( uid ); + QCopEnvelope e(m_str, "removed(bool)" ); + e << rem; + }else if ( cmd == "beam(int,int)" ) { + int uid, trans; + stream >> uid; + stream >> trans; + beam( uid, trans ); + }else if ( cmd == "show(int)" ) { + int uid; + stream >> uid; + show( uid ); + }else if ( cmd == "edit(int)" ) { + int uid; + stream >> uid; + edit( uid ); + }else if ( cmd == "add(int,QByteArray)" ) { + int rtti; + QByteArray array; + stream >> rtti; + stream >> array; + m_fallBack = record(rtti, array ); + if (!m_fallBack) return; + add( *m_fallBack ); + delete m_fallBack; + } +} diff --git a/libopie/pim/opimmainwindow.h b/libopie/pim/opimmainwindow.h new file mode 100644 index 0000000..94100bd --- a/dev/null +++ b/libopie/pim/opimmainwindow.h @@ -0,0 +1,79 @@ +#ifndef OPIE_PIM_MAINWINDOW_H +#define OPIE_PIM_MAINWINDOW_H + +#include <qmainwindow.h> + +#include <opie/opimrecord.h> + +/** + * This is a common Opie PIM MainWindow + * it takes care of the QCOP internals + * and implements some functions + * for the URL scripting schema + */ +/* + * due Qt and Templates with signal and slots + * do not work that good :( + * (Ok how to moc a template ;) ) + * We will have the mainwindow which calls a struct which + * is normally reimplemented as a template ;) + */ + +class QCopChannel; +class OPimMainWindow : public QMainWindow { + Q_OBJECT +public: + enum TransPort { BlueTooth=0, + IrDa }; + + OPimMainWindow( const QString& service, QWidget *parent = 0, const char* name = 0, + WFlags f = WType_TopLevel); + virtual ~OPimMainWindow(); + + +protected slots: + /* for syncing */ + virtual void flush() = 0; + virtual void reload() = 0; + + /** create a new Records and return the uid */ + virtual int create() = 0; + /** remove a record with UID == uid */ + virtual bool remove( int uid ) = 0; + /** beam the record with UID = uid */ + virtual void beam( int uid , int transport = IrDa) = 0; + + /** show the record with UID == uid */ + virtual void show( int uid ) = 0; + /** edit the record */ + virtual void edit( int uid ) = 0; + + /** make a copy of it! */ + virtual void add( const OPimRecord& ) = 0; + + /* I would love to do this as a template + * but can't think of a right way + * because I need signal and slots -zecke + */ + /* + * the only pointer in the whole PIM API :( + */ + virtual OPimRecord* record( int rtti, const QByteArray& ) = 0; + QCopChannel* channel(); + +private slots: + void appMessage( const QCString&, const QByteArray& ); + + +private: + class Private; + Private* d; + + QCopChannel* m_channel; + QString m_service; + QCString m_str; + OPimRecord* m_fallBack; +}; + + +#endif diff --git a/libopie/pim/opimnotify.cpp b/libopie/pim/opimnotify.cpp new file mode 100644 index 0000000..af5514b --- a/dev/null +++ b/libopie/pim/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/libopie/pim/opimnotify.h b/libopie/pim/opimnotify.h new file mode 100644 index 0000000..3501948 --- a/dev/null +++ b/libopie/pim/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/libopie/pim/opimnotifymanager.cpp b/libopie/pim/opimnotifymanager.cpp new file mode 100644 index 0000000..be4a1c2 --- a/dev/null +++ b/libopie/pim/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/libopie/pim/opimnotifymanager.h b/libopie/pim/opimnotifymanager.h new file mode 100644 index 0000000..0eebc9b --- a/dev/null +++ b/libopie/pim/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/libopie/pim/opimrecord.cpp b/libopie/pim/opimrecord.cpp index 0e3be9d..49b5bf9 100644 --- a/libopie/pim/opimrecord.cpp +++ b/libopie/pim/opimrecord.cpp @@ -76,6 +76,9 @@ void OPimRecord::setUid( int uid ) { Qtopia::UidGen &OPimRecord::uidGen() { return m_uidGen; } OPimXRefManager &OPimRecord::xrefmanager() { return m_xrefman; } +int OPimRecord::rtti(){ + return 0; +} diff --git a/libopie/pim/opimrecord.h b/libopie/pim/opimrecord.h index 1642a5e..ec99a13 100644 --- a/libopie/pim/opimrecord.h +++ b/libopie/pim/opimrecord.h @@ -86,22 +86,28 @@ public: */ virtual QString recordField(int)const = 0; /** * 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(); /** * set the uid */ virtual void setUid( int uid ); + /* + * used inside the Templates for casting + * REIMPLEMENT in your .... + */ + static int rtti(); + protected: Qtopia::UidGen &uidGen(); // QString crossToString()const; private: class OPimRecordPrivate; diff --git a/libopie/pim/opimresolver.h b/libopie/pim/opimresolver.h new file mode 100644 index 0000000..86ae3eb --- a/dev/null +++ b/libopie/pim/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/libopie/pim/opimxref.cpp b/libopie/pim/opimxref.cpp index 5cae871..8eefbd8 100644 --- a/libopie/pim/opimxref.cpp +++ b/libopie/pim/opimxref.cpp @@ -31,14 +31,14 @@ OPimXRefPartner OPimXRef::partner( enum Partners par) const{ return m_partners[par]; } 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; } bool OPimXRef::containsUid( int uid ) const{ if ( m_partners[One].uid() == uid || m_partners[Two].uid() == uid ) return true; diff --git a/libopie/pim/opimxref.h b/libopie/pim/opimxref.h index 354739a..6852651 100644 --- a/libopie/pim/opimxref.h +++ b/libopie/pim/opimxref.h @@ -23,13 +23,13 @@ public: bool operator==( const OPimXRef& ); OPimXRefPartner partner( enum Partners )const; void setPartner( enum Partners, const OPimXRefPartner& ); - bool containsString( const QString& appName)const; + bool containsString( const QString& service)const; bool containsUid( int uid )const; private: QArray<OPimXRefPartner> m_partners; class Private; diff --git a/libopie/pim/opimxrefmanager.cpp b/libopie/pim/opimxrefmanager.cpp index 965f542..58bfd24 100644 --- a/libopie/pim/opimxrefmanager.cpp +++ b/libopie/pim/opimxrefmanager.cpp @@ -33,16 +33,16 @@ void OPimXRefManager::clear() { QStringList OPimXRefManager::apps()const { OPimXRef::ValueList::ConstIterator it; QStringList list; 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; } OPimXRef::ValueList OPimXRefManager::list()const { return m_list; diff --git a/libopie/pim/opimxrefmanager.h b/libopie/pim/opimxrefmanager.h index 9b003a3..39e5eef 100644 --- a/libopie/pim/opimxrefmanager.h +++ b/libopie/pim/opimxrefmanager.h @@ -28,13 +28,13 @@ public: /** * apps participating */ 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: OPimXRef::ValueList m_list; }; diff --git a/libopie/pim/opimxrefpartner.cpp b/libopie/pim/opimxrefpartner.cpp index 028f4e6..6ef3efb 100644 --- a/libopie/pim/opimxrefpartner.cpp +++ b/libopie/pim/opimxrefpartner.cpp @@ -20,22 +20,22 @@ bool OPimXRefPartner::operator==( const OPimXRefPartner& par ) { if ( m_app != par.m_app ) return false; if ( m_uid != par.m_uid ) return false; if ( m_field != par.m_field ) return false; return true; } -QString OPimXRefPartner::appName()const { +QString OPimXRefPartner::service()const { return m_app; } int OPimXRefPartner::uid()const { return m_uid; } 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 ) { m_uid = uid; } void OPimXRefPartner::setField( int field ) { diff --git a/libopie/pim/opimxrefpartner.h b/libopie/pim/opimxrefpartner.h index 808b9ab..d76e384 100644 --- a/libopie/pim/opimxrefpartner.h +++ b/libopie/pim/opimxrefpartner.h @@ -9,25 +9,25 @@ * In Opie one application * can link one uid * with one tableId( fieldId ) to another. */ 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& ); ~OPimXRefPartner(); 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: QString m_app; int m_uid; int m_field; diff --git a/libopie/pim/orecur.cpp b/libopie/pim/orecur.cpp index 257d4fd..daf3506 100644 --- a/libopie/pim/orecur.cpp +++ b/libopie/pim/orecur.cpp @@ -19,12 +19,15 @@ struct ORecur::Data : public QShared { int freq; int pos; bool hasEnd : 1; time_t end; time_t create; int rep; + QString app; + ExceptionList list; + QDate start; }; ORecur::ORecur() { data = new Data; } @@ -52,12 +55,304 @@ ORecur &ORecur::operator=( const ORecur& re) { re.data->ref(); deref(); data = re.data; 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; } int ORecur::frequency()const { return data->freq; } @@ -70,21 +365,30 @@ char ORecur::days() const{ bool ORecur::hasEndDate()const { return data->hasEnd; } 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; } time_t ORecur::createTime()const { return data->create; } 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; } void ORecur::setFrequency( int freq ) { checkOrModify(); @@ -115,22 +419,33 @@ void ORecur::setHasEndDate( bool b) { data->hasEnd = b; } 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(); 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; d2->rep = data->rep; + d2->app = data->app; + d2->list = data->list; + d2->start = data->start; data = d2; } } diff --git a/libopie/pim/orecur.h b/libopie/pim/orecur.h index d24d72d..8713d97 100644 --- a/libopie/pim/orecur.h +++ b/libopie/pim/orecur.h @@ -5,46 +5,73 @@ #ifndef OPIE_RECUR_H #define OPIE_RECUR_H #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, FRI = 0x10, SAT = 0x20, SUN = 0x40 }; ORecur(); ORecur( const ORecur& ); ~ORecur(); 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& ); void setFrequency( int freq ); 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(); class Data; diff --git a/libopie/pim/otodo.cpp b/libopie/pim/otodo.cpp index 6fcf9f6..ece624a 100644 --- a/libopie/pim/otodo.cpp +++ b/libopie/pim/otodo.cpp @@ -12,12 +12,13 @@ #include <qpe/categoryselect.h> #include "opimstate.h" #include "orecur.h" #include "opimmaintainer.h" +#include "opimnotifymanager.h" #include "otodo.h" struct OTodo::OTodoData : public QShared { OTodoData() : QShared() { @@ -28,17 +29,18 @@ struct OTodo::OTodoData : public QShared { bool hasDate:1; int priority; QString desc; QString sum; QMap<QString, QString> extra; ushort prog; - bool hasAlarmDateTime :1; - QDateTime alarmDateTime; OPimState state; ORecur recur; OPimMaintainer maintainer; + QDate start; + QDate completed; + OPimNotifyManager notifiers; }; OTodo::OTodo(const OTodo &event ) : OPimRecord( event ), data( event.data ) { data->ref(); @@ -70,14 +72,12 @@ OTodo::OTodo(bool completed, int priority, data->isCompleted = completed; data->hasDate = hasDate; data->priority = priority; data->sum = summary; data->prog = progress; data->desc = Qtopia::simplifyMultiLineSpace(description ); - data->hasAlarmDateTime = false; - } OTodo::OTodo(bool completed, int priority, const QStringList &category, const QString& summary, const QString &description, ushort progress, @@ -93,14 +93,12 @@ OTodo::OTodo(bool completed, int priority, data->isCompleted = completed; data->hasDate = hasDate; data->priority = priority; data->sum = summary; data->prog = progress; data->desc = Qtopia::simplifyMultiLineSpace(description ); - data->hasAlarmDateTime = false; - } bool OTodo::match( const QRegExp ®Exp )const { if( QString::number( data->priority ).find( regExp ) != -1 ){ return true; }else if( data->hasDate && data->date.toString().find( regExp) != -1 ){ @@ -117,15 +115,17 @@ bool OTodo::isCompleted() const return data->isCompleted; } bool OTodo::hasDueDate() const { return data->hasDate; } -bool OTodo::hasAlarmDateTime() const -{ - return data->hasAlarmDateTime; +bool OTodo::hasStartDate()const { + return data->start.isValid(); +} +bool OTodo::hasCompletedDate()const { + return data->completed.isValid(); } int OTodo::priority()const { return data->priority; } QString OTodo::summary() const @@ -137,18 +137,18 @@ ushort OTodo::progress() const return data->prog; } QDate OTodo::dueDate()const { return data->date; } - -QDateTime OTodo::alarmDateTime() const -{ - return data->alarmDateTime; +QDate OTodo::startDate()const { + return data->start; +} +QDate OTodo::completedDate()const { + return data->completed; } - QString OTodo::description()const { return data->desc; } OPimState OTodo::state()const { return data->state; @@ -166,17 +166,12 @@ void OTodo::setCompleted( bool completed ) } void OTodo::setHasDueDate( bool hasDate ) { changeOrModify(); data->hasDate = hasDate; } -void OTodo::setHasAlarmDateTime( bool hasAlarmDateTime ) -{ - changeOrModify(); - data->hasAlarmDateTime = hasAlarmDateTime; -} void OTodo::setDescription(const QString &desc ) { // qWarning( "desc " + desc ); changeOrModify(); data->desc = Qtopia::simplifyMultiLineSpace(desc ); } @@ -187,21 +182,24 @@ void OTodo::setSummary( const QString& sum ) } void OTodo::setPriority(int prio ) { changeOrModify(); data->priority = prio; } -void OTodo::setDueDate( QDate date ) +void OTodo::setDueDate( const QDate& date ) { changeOrModify(); data->date = date; } -void OTodo::setAlarmDateTime( const QDateTime& alarm ) -{ +void OTodo::setStartDate( const QDate& date ) { changeOrModify(); - data->alarmDateTime = alarm; + data->start = date; +} +void OTodo::setCompletedDate( const QDate& date ) { + changeOrModify(); + data->completed = date; } void OTodo::setState( const OPimState& state ) { changeOrModify(); data->state = state; } void OTodo::setRecurrence( const ORecur& rec) { @@ -251,24 +249,22 @@ QString OTodo::toRichText() const + QString::number( progress() ) + " %<br>"; if (hasDueDate() ){ text += "<b>" + QObject::tr( "Deadline:") + " </b>"; text += dueDate().toString(); text += "<br>"; } - if (hasAlarmDateTime() ){ - text += "<b>" + QObject::tr( "Alarmed Notification:") + " </b>"; - text += alarmDateTime().toString(); - text += "<br>"; - } text += "<b>" + QObject::tr( "Category:") + "</b> "; text += categoryNames().join(", "); text += "<br>"; return text; } +OPimNotifyManager& OTodo::notifiers() { + return data->notifiers; +} bool OTodo::operator<( const OTodo &toDoEvent )const{ if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true; if( !hasDueDate() && toDoEvent.hasDueDate() ) return false; if( hasDueDate() && toDoEvent.hasDueDate() ){ if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide @@ -324,16 +320,12 @@ bool OTodo::operator==(const OTodo &toDoEvent )const if ( data->priority != toDoEvent.data->prog ) return false; if ( data->isCompleted != toDoEvent.data->isCompleted ) return false; if ( data->hasDate != toDoEvent.data->hasDate ) return false; if ( data->date != toDoEvent.data->date ) return false; if ( data->sum != toDoEvent.data->sum ) return false; if ( data->desc != toDoEvent.data->desc ) return false; - if ( data->hasAlarmDateTime != toDoEvent.data->hasAlarmDateTime ) - return false; - if ( data->alarmDateTime != toDoEvent.data->alarmDateTime ) - return false; if ( data->maintainer != toDoEvent.data->maintainer ) return false; return OPimRecord::operator==( toDoEvent ); } void OTodo::deref() { @@ -368,15 +360,17 @@ QMap<int, QString> OTodo::toMap() const { map.insert( Priority, QString::number( data->priority ) ); map.insert( DateDay, QString::number( data->date.day() ) ); map.insert( DateMonth, QString::number( data->date.month() ) ); map.insert( DateYear, QString::number( data->date.year() ) ); map.insert( Progress, QString::number( data->prog ) ); // map.insert( CrossReference, crossToString() ); - map.insert( HasAlarmDateTime, QString::number( data->hasAlarmDateTime ) ); - map.insert( AlarmDateTime, data->alarmDateTime.toString() ); - + /* FIXME!!! map.insert( State, ); + map.insert( Recurrence, ); + map.insert( Reminders, ); + map. + */ return map; } QMap<QString, QString> OTodo::toExtraMap()const { return data->extra; } @@ -405,19 +399,23 @@ void OTodo::copy( OTodoData* src, OTodoData* dest ) { dest->hasDate = src->hasDate; dest->priority = src->priority; dest->desc = src->desc; dest->sum = src->sum; dest->extra = src->extra; dest->prog = src->prog; - dest->hasAlarmDateTime = src->hasAlarmDateTime; - dest->alarmDateTime = src->alarmDateTime; dest->state = src->state; dest->recur = src->recur; dest->maintainer = src->maintainer; + dest->start = src->start; + dest->completed = src->completed; + dest->notifiers = src->notifiers; } QString OTodo::type() const { return QString::fromLatin1("OTodo"); } QString OTodo::recordField(int /*id*/ )const { return QString::null; } +int OTodo::rtti(){ + return 1; +} diff --git a/libopie/pim/otodo.h b/libopie/pim/otodo.h index 70b0253..2f66f55 100644 --- a/libopie/pim/otodo.h +++ b/libopie/pim/otodo.h @@ -16,12 +16,13 @@ #include <opie/opimrecord.h> class OPimState; class ORecur; class OPimMaintainer; +class OPimNotifyManager; class OTodo : public OPimRecord { public: typedef QValueList<OTodo> ValueList; enum RecordFields { Uid = Qtopia::UID_ID, Category = Qtopia::CATEGORY_ID, @@ -32,19 +33,20 @@ public: Priority, DateDay, DateMonth, DateYear, Progress, CrossReference, - HasAlarmDateTime, - AlarmDateTime, State, - Recurrance, + Recurrence, Alarms, Reminders, - Notifiers + Notifiers, + Maintainer, + StartDate, + CompletedDate }; public: // priorities from Very low to very high enum TaskPriority { VeryHigh=1, High, Normal, Low, VeryLow }; /* Constructs a new ToDoEvent @@ -70,15 +72,15 @@ public: const QString& summary = QString::null, const QString& description = QString::null, ushort progress = 0, bool hasDate = false, QDate date = QDate::currentDate(), int uid = 0 /* empty */ ); - /* Copy c'tor - - **/ + /** Copy c'tor + * + */ OTodo(const OTodo & ); /** *destructor */ ~OTodo(); @@ -89,12 +91,14 @@ public: bool isCompleted() const; /** * Does this Event have a deadline */ bool hasDueDate() const; + bool hasStartDate()const; + bool hasCompletedDate()const; /** * Does this Event has an alarm time ? */ bool hasAlarmDateTime() const; @@ -111,15 +115,20 @@ public: /** * The due Date */ QDate dueDate()const; /** - * Alarm Date and Time + * When did it start? + */ + QDate startDate()const; + + /** + * When was it completed? */ - QDateTime alarmDateTime()const; + QDate completedDate()const; /** * What is the state of this OTodo? */ OPimState state()const; @@ -146,14 +155,22 @@ public: /** * @reimplemented * Return this todoevent in a RichText formatted QString */ QString toRichText() const; + /* + * check if the sharing is still fine!! -zecke + */ + /** + * return a reference to our notifiers... + */ + OPimNotifyManager ¬ifiers(); + /** - * reimplementation + * reimplementations */ QString type()const; QString toShortText()const; QMap<QString, QString> toExtraMap()const; QString recordField(int id )const; @@ -169,17 +186,16 @@ public: void setCompleted(bool completed ); /** * set if this todo got an end data */ void setHasDueDate( bool hasDate ); - - /** - * set if this todo has an alarm time and date - */ - void setHasAlarmDateTime ( bool hasAlarm ); + // FIXME we do not have these for start, completed + // cause we'll use the isNull() of QDate for figuring + // out if it's has a date... + // decide what to do here? -zecke /** * Set the priority of the Todo */ void setPriority(int priority ); @@ -188,14 +204,23 @@ public: */ void setProgress( ushort progress ); /** * set the end date */ - void setDueDate( QDate date ); + void setDueDate( const QDate& date ); + /** + * set the start date + */ + void setStartDate( const QDate& date ); + + /** + * set the completed date + */ + void setCompletedDate( const QDate& date ); void setRecurrence( const ORecur& ); /** * set the alarm time */ void setAlarmDateTime ( const QDateTime& alarm ); @@ -224,12 +249,14 @@ public: bool operator!=(const OTodo &toDoEvent )const; bool operator>(const OTodo &toDoEvent )const; bool operator>=(const OTodo &toDoEvent)const; bool operator==(const OTodo &toDoEvent )const; OTodo &operator=(const OTodo &toDoEvent ); + static int rtti(); + private: class OTodoPrivate; struct OTodoData; void deref(); inline void changeOrModify(); diff --git a/libopie/pim/otodoaccess.cpp b/libopie/pim/otodoaccess.cpp index c258de6..d860411 100644 --- a/libopie/pim/otodoaccess.cpp +++ b/libopie/pim/otodoaccess.cpp @@ -42,24 +42,26 @@ OTodoAccess::List OTodoAccess::effectiveToDos( const QDate& start, } OTodoAccess::List OTodoAccess::overDue() { List lis( m_todoBackEnd->overDue(), this ); return lis; } void OTodoAccess::addAlarm( const OTodo& event) { - if (!event.hasAlarmDateTime() ) +/* FIXME use the new notifier architecture + if (!event.hasAlarmDateTime() ) return; QDateTime now = QDateTime::currentDateTime(); QDateTime schedule = event.alarmDateTime(); if ( schedule > now ){ AlarmServer::addAlarm( schedule, "QPE/Application/todolist", "alarm(QDateTime,int)", event.uid() ); } +*/ } void OTodoAccess::delAlarm( int uid) { QDateTime schedule; // Create null DateTime // I hope this will remove all scheduled alarms @@ -76,6 +78,9 @@ void OTodoAccess::delAlarm( int uid) { OTodoAccess::List OTodoAccess::sorted( bool ascending, int sort,int filter, int cat ) { QArray<int> ints = m_todoBackEnd->sorted( ascending, sort, filter, cat ); OTodoAccess::List list( ints, this ); return list; } +void OTodoAccess::removeAllCompleted() { + m_todoBackEnd->removeAllCompleted(); +} diff --git a/libopie/pim/otodoaccess.h b/libopie/pim/otodoaccess.h index 390ab0e..c079155 100644 --- a/libopie/pim/otodoaccess.h +++ b/libopie/pim/otodoaccess.h @@ -65,28 +65,33 @@ public: * merge a list of OTodos into * the resource */ 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& ); /** * delete an alarm with the uid from * the alarm server */ void delAlarm( int uid ); -signals: - /** - * if the OTodoAccess was changed - */ - void signalChanged( const OTodoAccess* ); -private: int m_cat; OTodoAccessBackend* m_todoBackEnd; class OTodoAccessPrivate; OTodoAccessPrivate* d; }; diff --git a/libopie/pim/otodoaccessbackend.h b/libopie/pim/otodoaccessbackend.h index 3bad6b7..7944a2c 100644 --- a/libopie/pim/otodoaccessbackend.h +++ b/libopie/pim/otodoaccessbackend.h @@ -11,10 +11,11 @@ public: virtual QArray<int> effectiveToDos( const QDate& start, const QDate& end, bool includeNoDates ) = 0; virtual QArray<int> overDue() = 0; virtual QArray<int> sorted( bool asc, int sortOrder, int sortFilter, int cat ) = 0; + virtual void removeAllCompleted() = 0; }; #endif diff --git a/libopie/pim/otodoaccessvcal.cpp b/libopie/pim/otodoaccessvcal.cpp index ac70ea0..e96cc3c 100644 --- a/libopie/pim/otodoaccessvcal.cpp +++ b/libopie/pim/otodoaccessvcal.cpp @@ -151,12 +151,18 @@ bool OTodoAccessVCal::add( const OTodo& to ) { } bool OTodoAccessVCal::remove( int uid ) { m_map.remove( uid ); m_dirty = true; return true; } +void OTodoAccessVCal::removeAllCompleted() { + for ( QMap<int, OTodo>::Iterator it = m_map.begin(); it != m_map.end(); ++it ) { + if ( (*it).isCompleted() ) + m_map.remove( it ); + } +} bool OTodoAccessVCal::replace( const OTodo& to ) { m_map.replace( to.uid(), to ); m_dirty = true; return true; } OTodo OTodoAccessVCal::find(int uid )const { diff --git a/libopie/pim/otodoaccessvcal.h b/libopie/pim/otodoaccessvcal.h index 4499a7e..452f602 100644 --- a/libopie/pim/otodoaccessvcal.h +++ b/libopie/pim/otodoaccessvcal.h @@ -23,12 +23,14 @@ public: OTodo find(int uid)const; void clear(); bool add( const OTodo& ); bool remove( int uid ); bool replace( const OTodo& ); + void removeAllCompleted(); + private: bool m_dirty : 1; QString m_file; QMap<int, OTodo> m_map; }; diff --git a/libopie/pim/otodoaccessxml.cpp b/libopie/pim/otodoaccessxml.cpp index c1682c6..b2dfe80 100644 --- a/libopie/pim/otodoaccessxml.cpp +++ b/libopie/pim/otodoaccessxml.cpp @@ -25,13 +25,13 @@ bool OTodoAccessXML::load() { m_opened = true; m_changed = false; /* initialize dict */ /* * UPDATE dict if you change anything!!! */ - QAsciiDict<int> dict(15); + QAsciiDict<int> dict(21); dict.setAutoDelete( TRUE ); dict.insert("Categories" , new int(OTodo::Category) ); dict.insert("Uid" , new int(OTodo::Uid) ); dict.insert("HasDate" , new int(OTodo::HasDate) ); dict.insert("Completed" , new int(OTodo::Completed) ); dict.insert("Description" , new int(OTodo::Description) ); @@ -40,17 +40,21 @@ bool OTodoAccessXML::load() { dict.insert("DateDay" , new int(OTodo::DateDay) ); dict.insert("DateMonth" , new int(OTodo::DateMonth) ); dict.insert("DateYear" , new int(OTodo::DateYear) ); dict.insert("Progress" , new int(OTodo::Progress) ); dict.insert("Completed", new int(OTodo::Completed) ); dict.insert("CrossReference", new int(OTodo::CrossReference) ); - dict.insert("HasAlarmDateTime",new int(OTodo::HasAlarmDateTime) ); - dict.insert("AlarmDateTime", new int(OTodo::AlarmDateTime) ); + dict.insert("State", new int(OTodo::State) ); + dict.insert("Recurrence", new int(OTodo::Recurrence) ); + dict.insert("Alarms", new int(OTodo::Alarms) ); + dict.insert("Reminders", new int(OTodo::Reminders) ); + dict.insert("Notifiers", new int(OTodo::Notifiers) ); + dict.insert("Maintainer", new int(OTodo::Maintainer) ); // here the custom XML parser from TT it's GPL - // but we want to push that to TT..... + // but we want to push OpiePIM... to TT..... QFile f(m_file ); if (!f.open(IO_ReadOnly) ) return false; QByteArray ba = f.readAll(); f.close(); @@ -333,20 +337,12 @@ void OTodoAccessXML::todo( QAsciiDict<int>* dict, OTodo& ev, if ( pos > -1 ) ; // ev.addRelation( (*strIt).left(pos), (*strIt).mid(pos+1).toInt() ); } break; } - case OTodo::HasAlarmDateTime: - ev.setHasAlarmDateTime( val.toInt() ); - break; - case OTodo::AlarmDateTime: { - /* this sounds better ;) zecke */ - ev.setAlarmDateTime( TimeConversion::fromISO8601( val.local8Bit() ) ); - break; - } default: break; } } QString OTodoAccessXML::toString( const OTodo& ev )const { QString str; @@ -380,13 +376,12 @@ QString OTodoAccessXML::toString( const OTodo& ev )const { QMap<QString, QString>::Iterator extIt; for (extIt = extras.begin(); extIt != extras.end(); ++extIt ) str += extIt.key() + "=\"" + extIt.data() + "\" "; */ // cross refernce - str += "AlarmDateTime=\"" + TimeConversion::toISO8601( ev.alarmDateTime() ) + "\" "; return str; } QString OTodoAccessXML::toString( const QArray<int>& ints ) const { return Qtopia::Record::idsToString( ints ); } @@ -613,6 +608,12 @@ QArray<int> OTodoAccessXML::sorted( bool asc, int sortOrder, for (uint i= 0; i < vector.count(); i++ ) { array[i] = ( vector.at(i) )->todo.uid(); } qWarning("array count = %d %d", array.count(), vector.count() ); return array; }; +void OTodoAccessXML::removeAllCompleted() { + for ( QMap<int, OTodo>::Iterator it = m_events.begin(); it != m_events.end(); ++it ) { + if ( (*it).isCompleted() ) + m_events.remove( it ); + } +} diff --git a/libopie/pim/otodoaccessxml.h b/libopie/pim/otodoaccessxml.h index dc41c32..93609fe 100644 --- a/libopie/pim/otodoaccessxml.h +++ b/libopie/pim/otodoaccessxml.h @@ -26,12 +26,13 @@ public: QArray<int> allRecords()const; QArray<int> queryByExample( const OTodo&, int querysettings ); OTodo find( int uid )const; void clear(); bool add( const OTodo& ); bool remove( int uid ); + void removeAllCompleted(); bool replace( const OTodo& ); /* our functions */ QArray<int> effectiveToDos( const QDate& start, const QDate& end, bool includeNoDates ); |