summaryrefslogtreecommitdiff
path: root/libopie
Unidiff
Diffstat (limited to 'libopie') (more/less context) (ignore whitespace changes)
-rw-r--r--libopie/pim/ABSTRACT18
-rw-r--r--libopie/pim/ocontact.cpp4
-rw-r--r--libopie/pim/ocontact.h3
-rw-r--r--libopie/pim/opimaccesstemplate.h10
-rw-r--r--libopie/pim/opimmaintainer.cpp6
-rw-r--r--libopie/pim/opimmaintainer.h16
-rw-r--r--libopie/pim/opimmainwindow.cpp71
-rw-r--r--libopie/pim/opimmainwindow.h79
-rw-r--r--libopie/pim/opimnotify.cpp227
-rw-r--r--libopie/pim/opimnotify.h142
-rw-r--r--libopie/pim/opimnotifymanager.cpp69
-rw-r--r--libopie/pim/opimnotifymanager.h51
-rw-r--r--libopie/pim/opimrecord.cpp3
-rw-r--r--libopie/pim/opimrecord.h10
-rw-r--r--libopie/pim/opimresolver.h56
-rw-r--r--libopie/pim/opimxref.cpp4
-rw-r--r--libopie/pim/opimxref.h2
-rw-r--r--libopie/pim/opimxrefmanager.cpp4
-rw-r--r--libopie/pim/opimxrefmanager.h2
-rw-r--r--libopie/pim/opimxrefpartner.cpp4
-rw-r--r--libopie/pim/opimxrefpartner.h6
-rw-r--r--libopie/pim/orecur.cpp315
-rw-r--r--libopie/pim/orecur.h29
-rw-r--r--libopie/pim/otodo.cpp72
-rw-r--r--libopie/pim/otodo.h59
-rw-r--r--libopie/pim/otodoaccess.cpp7
-rw-r--r--libopie/pim/otodoaccess.h17
-rw-r--r--libopie/pim/otodoaccessbackend.h1
-rw-r--r--libopie/pim/otodoaccessvcal.cpp6
-rw-r--r--libopie/pim/otodoaccessvcal.h2
-rw-r--r--libopie/pim/otodoaccessxml.cpp27
-rw-r--r--libopie/pim/otodoaccessxml.h1
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 @@
1What is Opie PIM? Why is it special?
2Why do we need Opie PIM?
3
4The goal of OpiePIM is to be first of all
5extendable, light weight, scalable and fast.
6For the programmer we try to add a nice but
7powerful API to all classes.
8
9Memory is a costy resource on small and embedded
10devices. So we try to keep the memory usage as
11low as possible. Never the less we won't use structs
12and Pointers in the public API.
13The whole pim framework is value based. Internally we try
14to use implicit sharing as found in other Qt classes as well.
15This makes it possible to give 3rd party devels a nice
16API while keeping the memory usage as low as possible.
17
18We 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
@@ -1066,38 +1066,40 @@ void OContact::removeEmail( const QString &v )
1066 1066
1067 // if default, then replace the default email with the first one 1067 // if default, then replace the default email with the first one
1068 if ( def == e ) { 1068 if ( def == e ) {
1069 //qDebug("removeEmail is default; setting new default"); 1069 //qDebug("removeEmail is default; setting new default");
1070 if ( !emails.count() ) 1070 if ( !emails.count() )
1071 clearEmails(); 1071 clearEmails();
1072 else // setDefaultEmail will remove e from the list 1072 else // setDefaultEmail will remove e from the list
1073 setDefaultEmail( emails.first() ); 1073 setDefaultEmail( emails.first() );
1074 } 1074 }
1075} 1075}
1076void OContact::clearEmails() 1076void OContact::clearEmails()
1077{ 1077{
1078 mMap.remove( Qtopia::DefaultEmail ); 1078 mMap.remove( Qtopia::DefaultEmail );
1079 mMap.remove( Qtopia::Emails ); 1079 mMap.remove( Qtopia::Emails );
1080} 1080}
1081void OContact::setDefaultEmail( const QString &v ) 1081void OContact::setDefaultEmail( const QString &v )
1082{ 1082{
1083 QString e = v.simplifyWhiteSpace(); 1083 QString e = v.simplifyWhiteSpace();
1084 1084
1085 //qDebug("OContact::setDefaultEmail %s", e.latin1()); 1085 //qDebug("OContact::setDefaultEmail %s", e.latin1());
1086 replace( Qtopia::DefaultEmail, e ); 1086 replace( Qtopia::DefaultEmail, e );
1087 1087
1088 if ( !e.isEmpty() ) 1088 if ( !e.isEmpty() )
1089 insertEmail( e ); 1089 insertEmail( e );
1090 1090
1091} 1091}
1092 1092
1093void OContact::insertEmails( const QStringList &v ) 1093void OContact::insertEmails( const QStringList &v )
1094{ 1094{
1095 for ( QStringList::ConstIterator it = v.begin(); it != v.end(); ++it ) 1095 for ( QStringList::ConstIterator it = v.begin(); it != v.end(); ++it )
1096 insertEmail( *it ); 1096 insertEmail( *it );
1097} 1097}
1098 1098int OContact::rtti() {
1099 return 2;
1100}
1099void OContact::setUid( int i ) 1101void OContact::setUid( int i )
1100{ 1102{
1101 OPimRecord::setUid(i); 1103 OPimRecord::setUid(i);
1102 replace( Qtopia::AddressUid , QString::number(i)); 1104 replace( Qtopia::AddressUid , QString::number(i));
1103} 1105}
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
@@ -17,65 +17,65 @@
17** Contact info@trolltech.com if any conditions of this licensing are 17** Contact info@trolltech.com if any conditions of this licensing are
18** not clear to you. 18** not clear to you.
19** 19**
20**********************************************************************/ 20**********************************************************************/
21 21
22#ifndef __OCONTACT_H__ 22#ifndef __OCONTACT_H__
23#define __OCONTACT_H__ 23#define __OCONTACT_H__
24 24
25#include <opie/opimrecord.h> 25#include <opie/opimrecord.h>
26#include <qpe/recordfields.h> 26#include <qpe/recordfields.h>
27 27
28#include <qdatetime.h> 28#include <qdatetime.h>
29#include <qstringlist.h> 29#include <qstringlist.h>
30 30
31#if defined(QPC_TEMPLATEDLL) 31#if defined(QPC_TEMPLATEDLL)
32// MOC_SKIP_BEGIN 32// MOC_SKIP_BEGIN
33QPC_TEMPLATEEXTERN template class QPC_EXPORT QMap<int, QString>; 33QPC_TEMPLATEEXTERN template class QPC_EXPORT QMap<int, QString>;
34// MOC_SKIP_END 34// MOC_SKIP_END
35#endif 35#endif
36 36
37class ContactPrivate; 37class ContactPrivate;
38 38
39class QPC_EXPORT OContact : public OPimRecord 39class QPC_EXPORT OContact : public OPimRecord
40{ 40{
41 friend class DataSet; 41 friend class DataSet;
42public: 42public:
43 OContact(); 43 OContact();
44 OContact( const QMap<int, QString> &fromMap ); 44 OContact( const QMap<int, QString> &fromMap );
45 virtual ~OContact(); 45 virtual ~OContact();
46 46
47 enum journal_action { ACTION_ADD, ACTION_REMOVE, ACTION_REPLACE }; 47 enum journal_action { ACTION_ADD, ACTION_REMOVE, ACTION_REPLACE };
48 48
49 /* 49 /*
50 * do we need to inline them 50 * do we need to inline them
51 * if yes do we need to inline them this way? 51 * if yes do we need to inline them this way?
52 * -zecke 52 * -zecke
53 */ 53 */
54 void setTitle( const QString &v ) { replace( Qtopia::Title, v ); } 54 void setTitle( const QString &v ) { replace( Qtopia::Title, v ); }
55 void setFirstName( const QString &v ) { replace( Qtopia::FirstName, v ); } 55 void setFirstName( const QString &v ) { replace( Qtopia::FirstName, v ); }
56 void setMiddleName( const QString &v ) { replace( Qtopia::MiddleName, v ); } 56 void setMiddleName( const QString &v ) { replace( Qtopia::MiddleName, v ); }
57 void setLastName( const QString &v ) { replace( Qtopia::LastName, v ); } 57 void setLastName( const QString &v ) { replace( Qtopia::LastName, v ); }
58 void setSuffix( const QString &v ) { replace( Qtopia::Suffix, v ); } 58 void setSuffix( const QString &v ) { replace( Qtopia::Suffix, v ); }
59 void setFileAs( const QString &v ) { replace( Qtopia::FileAs, v ); } 59 void setFileAs( const QString &v ) { replace( Qtopia::FileAs, v ); }
60 void setFileAs(); 60 void setFileAs();
61 61
62 // default email address 62 // default email address
63 void setDefaultEmail( const QString &v ); 63 void setDefaultEmail( const QString &v );
64 // inserts email to list and ensure's doesn't already exist 64 // inserts email to list and ensure's doesn't already exist
65 void insertEmail( const QString &v ); 65 void insertEmail( const QString &v );
66 void removeEmail( const QString &v ); 66 void removeEmail( const QString &v );
67 void clearEmails(); 67 void clearEmails();
68 void insertEmails( const QStringList &v ); 68 void insertEmails( const QStringList &v );
69 69
70 // home 70 // home
71 void setHomeStreet( const QString &v ) { replace( Qtopia::HomeStreet, v ); } 71 void setHomeStreet( const QString &v ) { replace( Qtopia::HomeStreet, v ); }
72 void setHomeCity( const QString &v ) { replace( Qtopia::HomeCity, v ); } 72 void setHomeCity( const QString &v ) { replace( Qtopia::HomeCity, v ); }
73 void setHomeState( const QString &v ) { replace( Qtopia::HomeState, v ); } 73 void setHomeState( const QString &v ) { replace( Qtopia::HomeState, v ); }
74 void setHomeZip( const QString &v ) { replace( Qtopia::HomeZip, v ); } 74 void setHomeZip( const QString &v ) { replace( Qtopia::HomeZip, v ); }
75 void setHomeCountry( const QString &v ) { replace( Qtopia::HomeCountry, v ); } 75 void setHomeCountry( const QString &v ) { replace( Qtopia::HomeCountry, v ); }
76 void setHomePhone( const QString &v ) { replace( Qtopia::HomePhone, v ); } 76 void setHomePhone( const QString &v ) { replace( Qtopia::HomePhone, v ); }
77 void setHomeFax( const QString &v ) { replace( Qtopia::HomeFax, v ); } 77 void setHomeFax( const QString &v ) { replace( Qtopia::HomeFax, v ); }
78 void setHomeMobile( const QString &v ) { replace( Qtopia::HomeMobile, v ); } 78 void setHomeMobile( const QString &v ) { replace( Qtopia::HomeMobile, v ); }
79 void setHomeWebpage( const QString &v ) { replace( Qtopia::HomeWebPage, v ); } 79 void setHomeWebpage( const QString &v ) { replace( Qtopia::HomeWebPage, v ); }
80 80
81 // business 81 // business
@@ -182,57 +182,58 @@ public:
182 QDate anniversary() const; 182 QDate anniversary() const;
183 QString nickname() const { return find( Qtopia::Nickname ); } 183 QString nickname() const { return find( Qtopia::Nickname ); }
184 QString children() const { return find( Qtopia::Children ); } 184 QString children() const { return find( Qtopia::Children ); }
185 QStringList childrenList() const; 185 QStringList childrenList() const;
186 186
187 // other 187 // other
188 QString notes() const { return find( Qtopia::Notes ); } 188 QString notes() const { return find( Qtopia::Notes ); }
189 QString groups() const { return find( Qtopia::Groups ); } 189 QString groups() const { return find( Qtopia::Groups ); }
190 QStringList groupList() const; 190 QStringList groupList() const;
191 191
192// // custom 192// // custom
193// const QString &customField( const QString &key ) 193// const QString &customField( const QString &key )
194// { return find( Custom- + key ); } 194// { return find( Custom- + key ); }
195 195
196 196
197 QString toRichText() const; 197 QString toRichText() const;
198 QMap<int, QString> toMap() const; 198 QMap<int, QString> toMap() const;
199 QString field( int key ) const { return find( key ); } 199 QString field( int key ) const { return find( key ); }
200 200
201 201
202 void setUid( int i ); 202 void setUid( int i );
203 203
204 QString toShortText()const; 204 QString toShortText()const;
205 QString OContact::type()const; 205 QString OContact::type()const;
206 QMap<QString,QString> OContact::toExtraMap() const; 206 QMap<QString,QString> OContact::toExtraMap() const;
207 class QString OContact::recordField(int) const; 207 class QString OContact::recordField(int) const;
208 208
209 // Why private ? (eilers,se) 209 // Why private ? (eilers,se)
210 QString emailSeparator() const { return " "; } 210 QString emailSeparator() const { return " "; }
211 // the emails should be seperated by a comma 211 // the emails should be seperated by a comma
212 void setEmails( const QString &v ); 212 void setEmails( const QString &v );
213 QString emails() const { return find( Qtopia::Emails ); } 213 QString emails() const { return find( Qtopia::Emails ); }
214 static int rtti();
214 215
215 216
216private: 217private:
217 // The XML-Backend needs some access to the private functions 218 // The XML-Backend needs some access to the private functions
218 friend class OContactAccessBackend_XML; 219 friend class OContactAccessBackend_XML;
219 220
220 void insert( int key, const QString &value ); 221 void insert( int key, const QString &value );
221 void replace( int key, const QString &value ); 222 void replace( int key, const QString &value );
222 QString find( int key ) const; 223 QString find( int key ) const;
223 static QStringList fields(); 224 static QStringList fields();
224 225
225 void save( QString &buf ) const; 226 void save( QString &buf ) const;
226 227
227 QString displayAddress( const QString &street, 228 QString displayAddress( const QString &street,
228 const QString &city, 229 const QString &city,
229 const QString &state, 230 const QString &state,
230 const QString &zip, 231 const QString &zip,
231 const QString &country ) const; 232 const QString &country ) const;
232 233
233 QMap<int, QString> mMap; 234 QMap<int, QString> mMap;
234 ContactPrivate *d; 235 ContactPrivate *d;
235}; 236};
236 237
237 238
238#endif 239#endif
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
@@ -64,64 +64,65 @@ public:
64 */ 64 */
65 virtual List allRecords()const; 65 virtual List allRecords()const;
66 66
67 /** 67 /**
68 * queryByExample. 68 * queryByExample.
69 * @see otodoaccess, ocontactaccess 69 * @see otodoaccess, ocontactaccess
70 */ 70 */
71 virtual List queryByExample( const T& t, int querySettings ); 71 virtual List queryByExample( const T& t, int querySettings );
72 72
73 /** 73 /**
74 * find the OPimRecord uid 74 * find the OPimRecord uid
75 */ 75 */
76 virtual T find( int uid )const; 76 virtual T find( int uid )const;
77 77
78 /** 78 /**
79 * read ahead cache find method ;) 79 * read ahead cache find method ;)
80 */ 80 */
81 virtual T find( int uid, const QArray<int>&, 81 virtual T find( int uid, const QArray<int>&,
82 uint current, typename OTemplateBase<T>::CacheDirection dir = OTemplateBase<T>::Forward )const; 82 uint current, typename OTemplateBase<T>::CacheDirection dir = OTemplateBase<T>::Forward )const;
83 83
84 /* invalidate cache here */ 84 /* invalidate cache here */
85 /** 85 /**
86 * clears the backend and invalidates the backend 86 * clears the backend and invalidates the backend
87 */ 87 */
88 virtual void clear() ; 88 virtual void clear() ;
89 89
90 /** 90 /**
91 * add T to the backend 91 * add T to the backend
92 * @param t The item to add. 92 * @param t The item to add.
93 * @return <i>true</i> if added successfully. 93 * @return <i>true</i> if added successfully.
94 */ 94 */
95 virtual bool add( const T& t ) ; 95 virtual bool add( const T& t ) ;
96 bool add( const OPimRecord& );
96 97
97 /* only the uid matters */ 98 /* only the uid matters */
98 /** 99 /**
99 * remove T from the backend 100 * remove T from the backend
100 * @param t The item to remove 101 * @param t The item to remove
101 * @return <i>true</i> if successful. 102 * @return <i>true</i> if successful.
102 */ 103 */
103 virtual bool remove( const T& t ); 104 virtual bool remove( const T& t );
104 105
105 /** 106 /**
106 * remove the OPimRecord with uid 107 * remove the OPimRecord with uid
107 * @param uid The ID of the item to remove 108 * @param uid The ID of the item to remove
108 * @return <i>true</i> if successful. 109 * @return <i>true</i> if successful.
109 */ 110 */
110 virtual bool remove( int uid ); 111 virtual bool remove( int uid );
111 112
112 /** 113 /**
113 * replace T from backend 114 * replace T from backend
114 * @param t The item to replace 115 * @param t The item to replace
115 * @return <i>true</i> if successful. 116 * @return <i>true</i> if successful.
116 */ 117 */
117 virtual bool replace( const T& t) ; 118 virtual bool replace( const T& t) ;
118 119
119 void setReadAhead( uint count ); 120 void setReadAhead( uint count );
120 /** 121 /**
121 * @internal 122 * @internal
122 */ 123 */
123 void cache( const T& )const; 124 void cache( const T& )const;
124 void setSaneCacheSize( int ); 125 void setSaneCacheSize( int );
125protected: 126protected:
126 /** 127 /**
127 * invalidate the cache 128 * invalidate the cache
@@ -183,64 +184,73 @@ T OPimAccessTemplate<T>::find( int uid ) const{
183 T t = m_backEnd->find( uid ); 184 T t = m_backEnd->find( uid );
184 cache( t ); 185 cache( t );
185 return t; 186 return t;
186} 187}
187template <class T> 188template <class T>
188T OPimAccessTemplate<T>::find( int uid, const QArray<int>& ar, 189T OPimAccessTemplate<T>::find( int uid, const QArray<int>& ar,
189 uint current, typename OTemplateBase<T>::CacheDirection dir )const { 190 uint current, typename OTemplateBase<T>::CacheDirection dir )const {
190 /* 191 /*
191 * better do T.isEmpty() 192 * better do T.isEmpty()
192 * after a find this way we would 193 * after a find this way we would
193 * avoid two finds in QCache... 194 * avoid two finds in QCache...
194 */ 195 */
195 // qWarning("find it now %d", uid ); 196 // qWarning("find it now %d", uid );
196 if (m_cache.contains( uid ) ) { 197 if (m_cache.contains( uid ) ) {
197 return m_cache.find( uid ); 198 return m_cache.find( uid );
198 } 199 }
199 200
200 T t = m_backEnd->find( uid, ar, current, dir ); 201 T t = m_backEnd->find( uid, ar, current, dir );
201 cache( t ); 202 cache( t );
202 return t; 203 return t;
203} 204}
204template <class T> 205template <class T>
205void OPimAccessTemplate<T>::clear() { 206void OPimAccessTemplate<T>::clear() {
206 invalidateCache(); 207 invalidateCache();
207 m_backEnd->clear(); 208 m_backEnd->clear();
208} 209}
209template <class T> 210template <class T>
210bool OPimAccessTemplate<T>::add( const T& t ) { 211bool OPimAccessTemplate<T>::add( const T& t ) {
211 cache( t ); 212 cache( t );
212 return m_backEnd->add( t ); 213 return m_backEnd->add( t );
213} 214}
214template <class T> 215template <class T>
216bool OPimAccessTemplate<T>::add( const OPimRecord& rec) {
217 /* same type */
218 if ( rec.rtti() == T::rtti() ) {
219 const T &t = static_cast<const T&>(rec);
220 return add(t);
221 }
222 return false;
223}
224template <class T>
215bool OPimAccessTemplate<T>::remove( const T& t ) { 225bool OPimAccessTemplate<T>::remove( const T& t ) {
216 return remove( t.uid() ); 226 return remove( t.uid() );
217} 227}
218template <class T> 228template <class T>
219bool OPimAccessTemplate<T>::remove( int uid ) { 229bool OPimAccessTemplate<T>::remove( int uid ) {
220 m_cache.remove( uid ); 230 m_cache.remove( uid );
221 return m_backEnd->remove( uid ); 231 return m_backEnd->remove( uid );
222} 232}
223template <class T> 233template <class T>
224bool OPimAccessTemplate<T>::replace( const T& t ) { 234bool OPimAccessTemplate<T>::replace( const T& t ) {
225 m_cache.replace( t ); 235 m_cache.replace( t );
226 return m_backEnd->replace( t ); 236 return m_backEnd->replace( t );
227} 237}
228template <class T> 238template <class T>
229void OPimAccessTemplate<T>::invalidateCache() { 239void OPimAccessTemplate<T>::invalidateCache() {
230 m_cache.invalidate(); 240 m_cache.invalidate();
231} 241}
232template <class T> 242template <class T>
233typename OPimAccessTemplate<T>::BackEnd* OPimAccessTemplate<T>::backEnd() { 243typename OPimAccessTemplate<T>::BackEnd* OPimAccessTemplate<T>::backEnd() {
234 return m_backEnd; 244 return m_backEnd;
235} 245}
236template <class T> 246template <class T>
237bool OPimAccessTemplate<T>::wasChangedExternally()const { 247bool OPimAccessTemplate<T>::wasChangedExternally()const {
238 return false; 248 return false;
239} 249}
240template <class T> 250template <class T>
241void OPimAccessTemplate<T>::setBackEnd( BackEnd* end ) { 251void OPimAccessTemplate<T>::setBackEnd( BackEnd* end ) {
242 m_backEnd = end; 252 m_backEnd = end;
243 if (m_backEnd ) 253 if (m_backEnd )
244 m_backEnd->setFrontend( this ); 254 m_backEnd->setFrontend( this );
245} 255}
246template <class T> 256template <class T>
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,37 +1,37 @@
1#include "opimmaintainer.h" 1#include "opimmaintainer.h"
2 2
3OPimMaintainer::OPimMaintainer( enum Mode mode, int uid ) 3OPimMaintainer::OPimMaintainer( int mode, int uid )
4 : m_mode(mode), m_uid(uid ) 4 : m_mode(mode), m_uid(uid )
5{} 5{}
6OPimMaintainer::~OPimMaintainer() { 6OPimMaintainer::~OPimMaintainer() {
7} 7}
8OPimMaintainer::OPimMaintainer( const OPimMaintainer& main ) { 8OPimMaintainer::OPimMaintainer( const OPimMaintainer& main ) {
9 *this = main; 9 *this = main;
10} 10}
11OPimMaintainer &OPimMaintainer::operator=( const OPimMaintainer& main ) { 11OPimMaintainer &OPimMaintainer::operator=( const OPimMaintainer& main ) {
12 m_mode = main.m_mode; 12 m_mode = main.m_mode;
13 m_uid = main.m_uid; 13 m_uid = main.m_uid;
14 14
15 return *this; 15 return *this;
16} 16}
17bool OPimMaintainer::operator==( const OPimMaintainer& main ) { 17bool OPimMaintainer::operator==( const OPimMaintainer& main ) {
18 if (m_mode != main.m_mode ) return false; 18 if (m_mode != main.m_mode ) return false;
19 if (m_uid != main.m_uid ) return false; 19 if (m_uid != main.m_uid ) return false;
20 20
21 return true; 21 return true;
22} 22}
23bool OPimMaintainer::operator!=( const OPimMaintainer& main ) { 23bool OPimMaintainer::operator!=( const OPimMaintainer& main ) {
24 return !(*this == main ); 24 return !(*this == main );
25} 25}
26OPimMaintainer::Mode OPimMaintainer::mode()const { 26int OPimMaintainer::mode()const {
27 return m_mode; 27 return m_mode;
28} 28}
29int OPimMaintainer::uid()const { 29int OPimMaintainer::uid()const {
30 return m_uid; 30 return m_uid;
31} 31}
32void OPimMaintainer::setMode( enum Mode mo) { 32void OPimMaintainer::setMode( int mo) {
33 m_mode = mo; 33 m_mode = mo;
34} 34}
35void OPimMaintainer::setUid( int uid ) { 35void OPimMaintainer::setUid( int uid ) {
36 m_uid = uid; 36 m_uid = uid;
37} 37}
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
@@ -1,36 +1,40 @@
1#ifndef OPIE_PIM_MAINTAINER_H 1#ifndef OPIE_PIM_MAINTAINER_H
2#define OPIE_PIM_MAINTAINER_H 2#define OPIE_PIM_MAINTAINER_H
3 3
4#include <qstring.h> 4#include <qstring.h>
5 5
6/** 6/**
7 * Who maintains what? 7 * Who maintains what?
8 */ 8 */
9class OPimMaintainer { 9class OPimMaintainer {
10public: 10public:
11 enum Mode { Undefined = -1, 11 enum Mode { Undefined = -1,
12 Responsible = 0, 12 Nothing = 0,
13 Responsible,
13 DoneBy, 14 DoneBy,
14 Coordinating }; 15 Coordinating,
15 OPimMaintainer( enum Mode mode = Undefined, int uid = 0); 16 };
17 OPimMaintainer( int mode = Undefined, int uid = 0);
16 OPimMaintainer( const OPimMaintainer& ); 18 OPimMaintainer( const OPimMaintainer& );
17 ~OPimMaintainer(); 19 ~OPimMaintainer();
18 20
19 OPimMaintainer &operator=( const OPimMaintainer& ); 21 OPimMaintainer &operator=( const OPimMaintainer& );
20 bool operator==( const OPimMaintainer& ); 22 bool operator==( const OPimMaintainer& );
21 bool operator!=( const OPimMaintainer& ); 23 bool operator!=( const OPimMaintainer& );
22 24
23 25
24 Mode mode()const; 26 int mode()const;
25 int uid()const; 27 int uid()const;
26 28
27 void setMode( enum Mode ); 29 void setMode( int mode );
28 void setUid( int uid ); 30 void setUid( int uid );
29 31
30private: 32private:
31 Mode m_mode; 33 int m_mode;
32 int m_uid; 34 int m_uid;
35 class Private;
36 Private *d;
33 37
34}; 38};
35 39
36#endif 40#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 @@
1#include <qapplication.h>
2#include <qcopchannel_qws.h>
3
4#include <qpe/qcopenvelope_qws.h>
5
6#include "opimmainwindow.h"
7
8OPimMainWindow::OPimMainWindow( const QString& service, QWidget* parent,
9 const char* name, WFlags flag )
10 : QMainWindow( parent, name, flag ), m_service( service ), m_fallBack(0l) {
11
12 /*
13 * let's generate our QCopChannel
14 */
15 m_str = QString("QPE/"+m_service).local8Bit();
16 m_channel= new QCopChannel(m_str, this );
17 connect(m_channel, SIGNAL(received(const QCString&, const QByteArray& ) ),
18 this, SLOT( appMessage( const QCString&, const QByteArray& ) ) );
19
20 /* connect flush and reload */
21 connect(qApp, SIGNAL(flush() ),
22 this, SLOT(flush() ) );
23 connect(qApp, SIGNAL(reload() ),
24 this, SLOT(reload() ) );
25}
26OPimMainWindow::~OPimMainWindow() {
27 delete m_channel;
28}
29QCopChannel* OPimMainWindow::channel() {
30 return m_channel;
31}
32void OPimMainWindow::appMessage( const QCString& cmd, const QByteArray& array ) {
33 /*
34 * create demands to create
35 * a new record...
36 */
37 QDataStream stream(array, IO_ReadOnly);
38 if ( cmd == "create()" ) {
39 int uid = create();
40 QCopEnvelope e(m_str, "created(int)" );
41 e << uid;
42 }else if ( cmd == "remove(int)" ) {
43 int uid;
44 stream >> uid;
45 bool rem = remove( uid );
46 QCopEnvelope e(m_str, "removed(bool)" );
47 e << rem;
48 }else if ( cmd == "beam(int,int)" ) {
49 int uid, trans;
50 stream >> uid;
51 stream >> trans;
52 beam( uid, trans );
53 }else if ( cmd == "show(int)" ) {
54 int uid;
55 stream >> uid;
56 show( uid );
57 }else if ( cmd == "edit(int)" ) {
58 int uid;
59 stream >> uid;
60 edit( uid );
61 }else if ( cmd == "add(int,QByteArray)" ) {
62 int rtti;
63 QByteArray array;
64 stream >> rtti;
65 stream >> array;
66 m_fallBack = record(rtti, array );
67 if (!m_fallBack) return;
68 add( *m_fallBack );
69 delete m_fallBack;
70 }
71}
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 @@
1#ifndef OPIE_PIM_MAINWINDOW_H
2#define OPIE_PIM_MAINWINDOW_H
3
4#include <qmainwindow.h>
5
6#include <opie/opimrecord.h>
7
8/**
9 * This is a common Opie PIM MainWindow
10 * it takes care of the QCOP internals
11 * and implements some functions
12 * for the URL scripting schema
13 */
14/*
15 * due Qt and Templates with signal and slots
16 * do not work that good :(
17 * (Ok how to moc a template ;) )
18 * We will have the mainwindow which calls a struct which
19 * is normally reimplemented as a template ;)
20 */
21
22class QCopChannel;
23class OPimMainWindow : public QMainWindow {
24 Q_OBJECT
25public:
26 enum TransPort { BlueTooth=0,
27 IrDa };
28
29 OPimMainWindow( const QString& service, QWidget *parent = 0, const char* name = 0,
30 WFlags f = WType_TopLevel);
31 virtual ~OPimMainWindow();
32
33
34protected slots:
35 /* for syncing */
36 virtual void flush() = 0;
37 virtual void reload() = 0;
38
39 /** create a new Records and return the uid */
40 virtual int create() = 0;
41 /** remove a record with UID == uid */
42 virtual bool remove( int uid ) = 0;
43 /** beam the record with UID = uid */
44 virtual void beam( int uid , int transport = IrDa) = 0;
45
46 /** show the record with UID == uid */
47 virtual void show( int uid ) = 0;
48 /** edit the record */
49 virtual void edit( int uid ) = 0;
50
51 /** make a copy of it! */
52 virtual void add( const OPimRecord& ) = 0;
53
54 /* I would love to do this as a template
55 * but can't think of a right way
56 * because I need signal and slots -zecke
57 */
58 /*
59 * the only pointer in the whole PIM API :(
60 */
61 virtual OPimRecord* record( int rtti, const QByteArray& ) = 0;
62 QCopChannel* channel();
63
64private slots:
65 void appMessage( const QCString&, const QByteArray& );
66
67
68private:
69 class Private;
70 Private* d;
71
72 QCopChannel* m_channel;
73 QString m_service;
74 QCString m_str;
75 OPimRecord* m_fallBack;
76};
77
78
79#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 @@
1#include <qshared.h>
2
3#include "opimnotify.h"
4
5struct OPimNotify::Data : public QShared {
6 Data() : QShared(),dur(-1),parent(0) {
7
8 }
9 QDateTime start;
10 int dur;
11 QString application;
12 int parent;
13};
14
15OPimNotify::OPimNotify( const QDateTime& start, int duration, int parent ) {
16 data = new Data;
17 data->start = start;
18 data->dur = duration;
19 data->parent = parent;
20}
21OPimNotify::OPimNotify( const OPimNotify& noti)
22 : data( noti.data )
23{
24 data->ref();
25}
26OPimNotify::~OPimNotify() {
27 if ( data->deref() ) {
28 delete data;
29 data = 0l;
30 }
31}
32
33OPimNotify &OPimNotify::operator=( const OPimNotify& noti) {
34 noti.data->ref();
35 deref();
36 data = noti.data;
37
38 return *this;
39}
40bool OPimNotify::operator==( const OPimNotify& noti ) {
41 if ( data == noti.data ) return true;
42 if ( data->dur != noti.data->dur ) return false;
43 if ( data->parent != noti.data->parent ) return false;
44 if ( data->application != noti.data->application ) return false;
45 if ( data->start != noti.data->start ) return false;
46
47 return true;
48}
49QDateTime OPimNotify::dateTime()const {
50 return data->start;
51}
52QString OPimNotify::service()const {
53 return data->application;
54}
55int OPimNotify::parent()const {
56 return data->parent;
57}
58int OPimNotify::duration()const {
59 return data->dur;
60}
61QDateTime OPimNotify::endTime()const {
62 return QDateTime( data->start.date(), data->start.time().addSecs( data->dur) );
63}
64void OPimNotify::setDateTime( const QDateTime& time ) {
65 copyIntern();
66 data->start = time;
67}
68void OPimNotify::setDuration( int dur ) {
69 copyIntern();
70 data->dur = dur;
71}
72void OPimNotify::setParent( int uid ) {
73 copyIntern();
74 data->parent = uid;
75}
76void OPimNotify::setService( const QString& str ) {
77 copyIntern();
78 data->application = str;
79}
80void OPimNotify::copyIntern() {
81 if ( data->count != 1 ) {
82 data->deref();
83 Data* dat = new Data;
84 dat->start = data->start;
85 dat->dur = data->dur;
86 dat->application = data->application;
87 dat->parent = data->parent;
88 data = dat;
89 }
90}
91void OPimNotify::deref() {
92 if ( data->deref() ) {
93 delete data;
94 data = 0;
95 }
96}
97
98/***********************************************************/
99struct OPimAlarm::Data : public QShared {
100 Data() : QShared() {
101 sound = 1;
102 }
103 int sound;
104 QString file;
105};
106OPimAlarm::OPimAlarm( int sound, const QDateTime& start, int duration, int parent )
107 : OPimNotify( start, duration, parent )
108{
109 data = new Data;
110 data->sound = sound;
111}
112OPimAlarm::OPimAlarm( const OPimAlarm& al)
113 : OPimNotify(al), data( al.data )
114{
115 data->ref();
116}
117OPimAlarm::~OPimAlarm() {
118 if ( data->deref() ) {
119 delete data;
120 data = 0l;
121 }
122}
123OPimAlarm &OPimAlarm::operator=( const OPimAlarm& al)
124{
125 OPimNotify::operator=( al );
126 deref();
127 al.data->ref();
128
129 data = al.data;
130
131
132 return *this;
133}
134bool OPimAlarm::operator==( const OPimAlarm& al) {
135 if ( data->sound != al.data->sound ) return false;
136 else if ( data->sound == Custom && data->file != al.data->file )
137 return false;
138
139 return OPimNotify::operator==( al );
140}
141QString OPimAlarm::type()const {
142 return QString::fromLatin1("OPimAlarm");
143}
144int OPimAlarm::sound()const {
145 return data->sound;
146}
147QString OPimAlarm::file()const {
148 return data->file;
149}
150void OPimAlarm::setSound( int snd) {
151 copyIntern();
152 data->sound = snd;
153}
154void OPimAlarm::setFile( const QString& sound ) {
155 copyIntern();
156 data->file = sound;
157}
158void OPimAlarm::deref() {
159 if ( data->deref() ) {
160 delete data;
161 data = 0l;
162 }
163}
164void OPimAlarm::copyIntern() {
165 if ( data->count != 1 ) {
166 data->deref();
167 Data *newDat = new Data;
168 newDat->sound = data->sound;
169 newDat->file = data->file;
170 data = newDat;
171 }
172}
173/************************/
174struct OPimReminder::Data : public QShared {
175 Data() : QShared(), record( 0) {
176 }
177 int record;
178
179};
180OPimReminder::OPimReminder( int uid, const QDateTime& start, int dur, int parent )
181 : OPimNotify( start, dur, parent )
182{
183 data = new Data;
184 data->record = uid;
185}
186OPimReminder::OPimReminder( const OPimReminder& rem )
187 : OPimNotify( rem ), data( rem.data )
188{
189 data->ref();
190}
191OPimReminder& OPimReminder::operator=( const OPimReminder& rem) {
192 OPimNotify::operator=(rem );
193
194 deref();
195 rem.data->ref();
196 data = rem.data;
197
198 return *this;
199}
200bool OPimReminder::operator==( const OPimReminder& rem) {
201 if ( data->record != rem.data->record ) return false;
202
203 return OPimNotify::operator==( rem );
204}
205QString OPimReminder::type()const {
206 return QString::fromLatin1("OPimReminder");
207}
208int OPimReminder::recordUid()const {
209 return data->record;
210}
211void OPimReminder::setRecordUid( int uid ) {
212 copyIntern();
213 data->record = uid;
214}
215void OPimReminder::deref() {
216 if ( data->deref() ) {
217 delete data;
218 data = 0l;
219 }
220}
221void OPimReminder::copyIntern() {
222 if ( data->count != 1 ) {
223 Data* da = new Data;
224 da->record = data->record;
225 data = da;
226 }
227}
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 @@
1#ifndef OPIE_PIM_NOTIFY_H
2#define OPIE_PIM_NOTIFY_H
3
4#include <qdatetime.h>
5#include <qvaluelist.h>
6
7/**
8 * This is the base class of Notifiers. Possible
9 * notifiers would be Alarms, Reminders
10 * What they share is that they have
11 * A DateTime, Type, Duration
12 * This is what this base class takes care of
13 * on top of that it's shared
14 */
15/*
16 * TALK to eilers: have a class OPimDuration which sets the Duration
17 * given on the Due/Start Date? -zecke
18 * discuss: do we need a uid for the notify? -zecke
19 */
20class OPimNotify {
21public:
22 typedef QValueList<OPimNotify> ValueList;
23 OPimNotify( const QDateTime& start = QDateTime(), int duration = 0, int parent = 0 );
24 OPimNotify( const OPimNotify& );
25 virtual ~OPimNotify();
26
27 OPimNotify &operator=(const OPimNotify& );
28 bool operator==( const OPimNotify& );
29
30 virtual QString type()const = 0;
31
32 /** start date */
33 QDateTime dateTime()const;
34 QString service()const;
35
36 /**
37 * RETURN the parent uid
38 */
39 int parent()const;
40
41 /**
42 * in Seconds
43 */
44 int duration()const;
45
46 /**
47 * Start Time + Duration
48 */
49 QDateTime endTime()const;
50
51 void setDateTime( const QDateTime& );
52 void setDuration( int dur );
53 void setParent(int uid );
54 void setService( const QString& );
55
56
57private:
58 inline void copyIntern();
59 void deref();
60 struct Data;
61 Data* data;
62
63 /* d-pointer */
64 class NotifyPrivate;
65 NotifyPrivate* d;
66
67};
68/**
69 * An alarm is a sound/mail/buzzer played/send
70 * at a given time to inform about
71 * an Event
72 */
73class OPimAlarm : public OPimNotify {
74public:
75 enum Sound{Loud=0, Silent, Custom };
76 OPimAlarm( int sound = Silent, const QDateTime& start = QDateTime(), int duration = 0, int parent = 0 );
77 OPimAlarm( const OPimAlarm& );
78 ~OPimAlarm();
79
80 OPimAlarm &operator=( const OPimAlarm& );
81 bool operator==( const OPimAlarm& );
82 QString type()const;
83
84 int sound()const;
85 QString file()const;
86
87 void setSound( int );
88 /* only when sound is custom... */
89 void setFile( const QString& sound );
90
91private:
92 void deref();
93 void copyIntern();
94 struct Data;
95 Data * data;
96
97 class Private;
98 Private* d;
99
100};
101
102/**
103 * A Reminder will be put into the
104 * datebook
105 */
106class OPimReminder : public OPimNotify {
107public:
108
109 /**
110 * c'tor of a reminder
111 * @param uid The uid of the Record inside the Datebook
112 * @param start the StartDate invalid for all day...
113 * @param duration The duration of the event ( -1 for all day )
114 * @param parent The 'parent' record of this reminder
115 */
116 OPimReminder( int uid = 0, const QDateTime& start = QDateTime(),
117 int duration = 0, int parent = 0 );
118 OPimReminder( const OPimReminder& );
119 OPimReminder &operator=(const OPimReminder& );
120
121 QString type()const;
122
123 bool operator==( const OPimReminder& );
124
125 /**
126 * the uid of the alarm
127 * inside the 'datebook' application
128 */
129 int recordUid()const;
130 void setRecordUid( int uid );
131
132private:
133 void deref();
134 void copyIntern();
135
136 struct Data;
137 Data* data;
138 class Private;
139 Private *d;
140};
141
142#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 @@
1#include "opimnotifymanager.h"
2
3OPimNotifyManager::OPimNotifyManager( const Reminders& rem, const Alarms& al)
4 : m_rem( rem ), m_al( al )
5{}
6OPimNotifyManager::~OPimNotifyManager() {
7}
8/* use static_cast and type instead of dynamic... */
9void OPimNotifyManager::add( const OPimNotify& noti) {
10 if ( noti.type() == QString::fromLatin1("OPimReminder") ) {
11 const OPimReminder& rem = static_cast<const OPimReminder&>(noti);
12 m_rem.append( rem );
13 }else if ( noti.type() == QString::fromLatin1("OPimAlarm") ) {
14 const OPimAlarm& al = static_cast<const OPimAlarm&>(noti);
15 m_al.append( al );
16 }
17}
18void OPimNotifyManager::remove( const OPimNotify& noti) {
19 if ( noti.type() == QString::fromLatin1("OPimReminder") ) {
20 const OPimReminder& rem = static_cast<const OPimReminder&>(noti);
21 m_rem.remove( rem );
22 }else if ( noti.type() == QString::fromLatin1("OPimAlarm") ) {
23 const OPimAlarm& al = static_cast<const OPimAlarm&>(noti);
24 m_al.remove( al );
25 }
26}
27void OPimNotifyManager::replace( const OPimNotify& noti) {
28 if ( noti.type() == QString::fromLatin1("OPimReminder") ) {
29 const OPimReminder& rem = static_cast<const OPimReminder&>(noti);
30 m_rem.remove( rem );
31 m_rem.append( rem );
32 }else if ( noti.type() == QString::fromLatin1("OPimAlarm") ) {
33 const OPimAlarm& al = static_cast<const OPimAlarm&>(noti);
34 m_al.remove( al );
35 m_al.append( al );
36 }
37}
38OPimNotifyManager::Reminders OPimNotifyManager::reminders()const {
39 return m_rem;
40}
41OPimNotifyManager::Alarms OPimNotifyManager::alarms()const {
42 return m_al;
43}
44void OPimNotifyManager::setAlarms( const Alarms& al) {
45 m_al = al;
46}
47void OPimNotifyManager::setReminders( const Reminders& rem) {
48 m_rem = rem;
49}
50/* FIXME!!! */
51/**
52 * The idea is to check if the provider for our service
53 * is online
54 * if it is we will use QCOP
55 * if not the Factory to get the backend...
56 * Qtopia1.6 services would be kewl to have here....
57 */
58void OPimNotifyManager::registerNotify( const OPimNotify& ) {
59
60}
61/* FIXME!!! */
62/**
63 * same as above...
64 * Also implement Url model
65 * have a MainWindow....
66 */
67void OPimNotifyManager::deregister( const OPimNotify& ) {
68
69}
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 @@
1#ifndef OPIE_PIM_NOTIFY_MANAGER_H
2#define OPIE_PIM_NOTIFY_MANAGER_H
3
4#include <qvaluelist.h>
5
6#include <opie/opimnotify.h>
7
8/**
9 * The notify manager keeps track of the Notifiers....
10 */
11class OPimNotifyManager {
12public:
13 typedef QValueList<OPimReminder> Reminders;
14 typedef QValueList<OPimAlarm> Alarms;
15 OPimNotifyManager( const Reminders& rems = Reminders(), const Alarms& alarms = Alarms() );
16 ~OPimNotifyManager();
17
18 /* we will cast it for you ;) */
19 void add( const OPimNotify& );
20 void remove( const OPimNotify& );
21 /* replaces all with this one! */
22 void replace( const OPimNotify& );
23
24 Reminders reminders()const;
25 Alarms alarms()const;
26
27 void setAlarms( const Alarms& );
28 void setReminders( const Reminders& );
29
30 /* register is a Ansi C keyword... */
31 /**
32 * This function will register the Notify to the Alarm Server
33 * or datebook depending on the type of the notify
34 */
35 void registerNotify( const OPimNotify& );
36
37 /**
38 * this will do the opposite..
39 */
40 void deregister( const OPimNotify& );
41
42private:
43 Reminders m_rem;
44 Alarms m_al;
45
46 class Private;
47 Private *d;
48
49};
50
51#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
@@ -50,32 +50,35 @@ void OPimRecord::addCategoryName( const QString& ) {
50 50
51} 51}
52bool OPimRecord::isEmpty()const { 52bool OPimRecord::isEmpty()const {
53 return ( uid() == 0 ); 53 return ( uid() == 0 );
54} 54}
55/*QString OPimRecord::crossToString()const { 55/*QString OPimRecord::crossToString()const {
56 QString str; 56 QString str;
57 QMap<QString, QArray<int> >::ConstIterator it; 57 QMap<QString, QArray<int> >::ConstIterator it;
58 for (it = m_relations.begin(); it != m_relations.end(); ++it ) { 58 for (it = m_relations.begin(); it != m_relations.end(); ++it ) {
59 QArray<int> id = it.data(); 59 QArray<int> id = it.data();
60 for ( uint i = 0; i < id.size(); ++i ) { 60 for ( uint i = 0; i < id.size(); ++i ) {
61 str += it.key() + "," + QString::number( i ) + ";"; 61 str += it.key() + "," + QString::number( i ) + ";";
62 } 62 }
63 } 63 }
64 str = str.remove( str.length()-1, 1); // strip the ; 64 str = str.remove( str.length()-1, 1); // strip the ;
65 //qWarning("IDS " + str ); 65 //qWarning("IDS " + str );
66 66
67 return str; 67 return str;
68 }*/ 68 }*/
69/* if uid = 1 assign a new one */ 69/* if uid = 1 assign a new one */
70void OPimRecord::setUid( int uid ) { 70void OPimRecord::setUid( int uid ) {
71 if ( uid == 1) 71 if ( uid == 1)
72 uid = uidGen().generate(); 72 uid = uidGen().generate();
73 73
74 Qtopia::Record::setUid( uid ); 74 Qtopia::Record::setUid( uid );
75}; 75};
76Qtopia::UidGen &OPimRecord::uidGen() { 76Qtopia::UidGen &OPimRecord::uidGen() {
77 return m_uidGen; 77 return m_uidGen;
78} 78}
79OPimXRefManager &OPimRecord::xrefmanager() { 79OPimXRefManager &OPimRecord::xrefmanager() {
80 return m_xrefman; 80 return m_xrefman;
81} 81}
82int OPimRecord::rtti(){
83 return 0;
84}
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
@@ -60,57 +60,63 @@ public:
60 * toRichText summary 60 * toRichText summary
61 */ 61 */
62 virtual QString toRichText()const = 0; 62 virtual QString toRichText()const = 0;
63 63
64 /** 64 /**
65 * a small one line summary 65 * a small one line summary
66 */ 66 */
67 virtual QString toShortText()const = 0; 67 virtual QString toShortText()const = 0;
68 68
69 /** 69 /**
70 * the name of the Record 70 * the name of the Record
71 */ 71 */
72 virtual QString type()const = 0; 72 virtual QString type()const = 0;
73 73
74 /** 74 /**
75 * converts the internal structure to a map 75 * converts the internal structure to a map
76 */ 76 */
77 virtual QMap<int, QString> toMap()const = 0; 77 virtual QMap<int, QString> toMap()const = 0;
78 78
79 /** 79 /**
80 * key value representation of extra items 80 * key value representation of extra items
81 */ 81 */
82 virtual QMap<QString, QString> toExtraMap()const = 0; 82 virtual QMap<QString, QString> toExtraMap()const = 0;
83 83
84 /** 84 /**
85 * the name for a recordField 85 * the name for a recordField
86 */ 86 */
87 virtual QString recordField(int)const = 0; 87 virtual QString recordField(int)const = 0;
88 88
89 /** 89 /**
90 * returns a reference of the 90 * returns a reference of the
91 * Cross Reference Manager 91 * Cross Reference Manager
92 * Partner One is THIS PIM RECORD! 92 * Partner 'One' is THIS PIM RECORD!
93 * Two is the Partner where we link to 93 * 'Two' is the Partner where we link to
94 */ 94 */
95 OPimXRefManager& xrefmanager(); 95 OPimXRefManager& xrefmanager();
96 96
97 /** 97 /**
98 * set the uid 98 * set the uid
99 */ 99 */
100 virtual void setUid( int uid ); 100 virtual void setUid( int uid );
101 101
102 /*
103 * used inside the Templates for casting
104 * REIMPLEMENT in your ....
105 */
106 static int rtti();
107
102protected: 108protected:
103 Qtopia::UidGen &uidGen(); 109 Qtopia::UidGen &uidGen();
104// QString crossToString()const; 110// QString crossToString()const;
105 111
106private: 112private:
107 class OPimRecordPrivate; 113 class OPimRecordPrivate;
108 OPimRecordPrivate *d; 114 OPimRecordPrivate *d;
109 OPimXRefManager m_xrefman; 115 OPimXRefManager m_xrefman;
110 static Qtopia::UidGen m_uidGen; 116 static Qtopia::UidGen m_uidGen;
111 117
112}; 118};
113 119
114 120
115 121
116#endif 122#endif
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 @@
1#ifndef OPIE_PIM_RESOLVER
2#define OPIE_PIM_RESOLVER
3
4#include <qstring.h>
5#include <qvaluelist.h>
6
7/**
8 * OPimResolver is a MetaClass to access
9 * available backends read only.
10 * It will be used to resolve uids + app names
11 * to full informations
12 * to traverse through a list of alarms, reminders
13 * to get access to built in PIM functionality
14 * and to more stuff
15 * THE PERFORMANCE will depend on THE BACKEND
16 * USING XML is a waste of memory!!!!!
17 */
18class OPimResolver : public QObject {
19public:
20 enum BuiltIn { TodoList = 0,
21 DateBook,
22 AddressBook
23 };
24 static OPimResolver* self();
25
26
27 /*
28 * return a record for a uid
29 * and an app
30 */
31 OPimRecord &record( const QString& service, int uid );
32
33 /**
34 * return the QCopChannel for service
35 * When we will use Qtopia Services it will be used here
36 */
37 QString qcopChannel( enum BuiltIn& )const;
38 QString qcopChannel( const QString& service );
39
40 /**
41 * return a list of available services
42 */
43 QStringList services()const;
44
45 /**
46 * add a record to a service... ;)
47 */
48 bool add( const QString& service, const OPimRecord& );
49
50private:
51 OPimResolver();
52 OPimRecord *m_last;
53
54}:
55
56#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
@@ -5,43 +5,43 @@ OPimXRef::OPimXRef( const OPimXRefPartner& one, const OPimXRefPartner& two )
5{ 5{
6 m_partners[0] = one; 6 m_partners[0] = one;
7 m_partners[1] = two; 7 m_partners[1] = two;
8} 8}
9OPimXRef::OPimXRef() 9OPimXRef::OPimXRef()
10 : m_partners(2) 10 : m_partners(2)
11{ 11{
12 12
13} 13}
14OPimXRef::OPimXRef( const OPimXRef& ref) { 14OPimXRef::OPimXRef( const OPimXRef& ref) {
15 *this = ref; 15 *this = ref;
16} 16}
17OPimXRef::~OPimXRef() { 17OPimXRef::~OPimXRef() {
18} 18}
19OPimXRef &OPimXRef::operator=( const OPimXRef& ref) { 19OPimXRef &OPimXRef::operator=( const OPimXRef& ref) {
20 m_partners = ref.m_partners; 20 m_partners = ref.m_partners;
21 m_partners.detach(); 21 m_partners.detach();
22 22
23 return* this; 23 return* this;
24} 24}
25bool OPimXRef::operator==( const OPimXRef& oper ) { 25bool OPimXRef::operator==( const OPimXRef& oper ) {
26 if ( m_partners == oper.m_partners ) return true; 26 if ( m_partners == oper.m_partners ) return true;
27 27
28 return false; 28 return false;
29} 29}
30OPimXRefPartner OPimXRef::partner( enum Partners par) const{ 30OPimXRefPartner OPimXRef::partner( enum Partners par) const{
31 return m_partners[par]; 31 return m_partners[par];
32} 32}
33void OPimXRef::setPartner( enum Partners par, const OPimXRefPartner& part) { 33void OPimXRef::setPartner( enum Partners par, const OPimXRefPartner& part) {
34 m_partners[par] = part; 34 m_partners[par] = part;
35} 35}
36bool OPimXRef::containsString( const QString& string ) const{ 36bool OPimXRef::containsString( const QString& string ) const{
37 if ( m_partners[One].appName() == string || 37 if ( m_partners[One].service() == string ||
38 m_partners[Two].appName() == string ) return true; 38 m_partners[Two].service() == string ) return true;
39 39
40 return false; 40 return false;
41} 41}
42bool OPimXRef::containsUid( int uid ) const{ 42bool OPimXRef::containsUid( int uid ) const{
43 if ( m_partners[One].uid() == uid || 43 if ( m_partners[One].uid() == uid ||
44 m_partners[Two].uid() == uid ) return true; 44 m_partners[Two].uid() == uid ) return true;
45 45
46 return false; 46 return false;
47} 47}
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
@@ -1,39 +1,39 @@
1#ifndef OPIM_XREF_H 1#ifndef OPIM_XREF_H
2#define OPIM_XREF_H 2#define OPIM_XREF_H
3 3
4#include <qarray.h> 4#include <qarray.h>
5#include <qvaluelist.h> 5#include <qvaluelist.h>
6 6
7#include <opie/opimxrefpartner.h> 7#include <opie/opimxrefpartner.h>
8 8
9/** 9/**
10 * this is a Cross Referecne between 10 * this is a Cross Referecne between
11 * two Cross Reference Partners 11 * two Cross Reference Partners
12 */ 12 */
13class OPimXRef { 13class OPimXRef {
14public: 14public:
15 typedef QValueList<OPimXRef> ValueList; 15 typedef QValueList<OPimXRef> ValueList;
16 enum Partners { One, Two }; 16 enum Partners { One, Two };
17 OPimXRef( const OPimXRefPartner& ONE, const OPimXRefPartner& ); 17 OPimXRef( const OPimXRefPartner& ONE, const OPimXRefPartner& );
18 OPimXRef(); 18 OPimXRef();
19 OPimXRef( const OPimXRef& ); 19 OPimXRef( const OPimXRef& );
20 ~OPimXRef(); 20 ~OPimXRef();
21 21
22 OPimXRef &operator=( const OPimXRef& ); 22 OPimXRef &operator=( const OPimXRef& );
23 bool operator==( const OPimXRef& ); 23 bool operator==( const OPimXRef& );
24 24
25 OPimXRefPartner partner( enum Partners )const; 25 OPimXRefPartner partner( enum Partners )const;
26 26
27 void setPartner( enum Partners, const OPimXRefPartner& ); 27 void setPartner( enum Partners, const OPimXRefPartner& );
28 28
29 bool containsString( const QString& appName)const; 29 bool containsString( const QString& service)const;
30 bool containsUid( int uid )const; 30 bool containsUid( int uid )const;
31 31
32private: 32private:
33 QArray<OPimXRefPartner> m_partners; 33 QArray<OPimXRefPartner> m_partners;
34 34
35 class Private; 35 class Private;
36 Private *d; 36 Private *d;
37}; 37};
38 38
39#endif 39#endif
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
@@ -7,65 +7,65 @@ OPimXRefManager::OPimXRefManager( const OPimXRefManager& ref) {
7 m_list = ref.m_list; 7 m_list = ref.m_list;
8} 8}
9OPimXRefManager::~OPimXRefManager() { 9OPimXRefManager::~OPimXRefManager() {
10} 10}
11OPimXRefManager &OPimXRefManager::operator=( const OPimXRefManager& ref) { 11OPimXRefManager &OPimXRefManager::operator=( const OPimXRefManager& ref) {
12 m_list = ref.m_list; 12 m_list = ref.m_list;
13 return *this; 13 return *this;
14} 14}
15bool OPimXRefManager::operator==( const OPimXRefManager& /*ref*/) { 15bool OPimXRefManager::operator==( const OPimXRefManager& /*ref*/) {
16 // if ( m_list == ref.m_list ) return true; 16 // if ( m_list == ref.m_list ) return true;
17 17
18 return false; 18 return false;
19} 19}
20void OPimXRefManager::add( const OPimXRef& ref) { 20void OPimXRefManager::add( const OPimXRef& ref) {
21 m_list.append( ref ); 21 m_list.append( ref );
22} 22}
23void OPimXRefManager::remove( const OPimXRef& ref) { 23void OPimXRefManager::remove( const OPimXRef& ref) {
24 m_list.remove( ref ); 24 m_list.remove( ref );
25} 25}
26void OPimXRefManager::replace( const OPimXRef& ref) { 26void OPimXRefManager::replace( const OPimXRef& ref) {
27 m_list.remove( ref ); 27 m_list.remove( ref );
28 m_list.append( ref ); 28 m_list.append( ref );
29} 29}
30void OPimXRefManager::clear() { 30void OPimXRefManager::clear() {
31 m_list.clear(); 31 m_list.clear();
32} 32}
33QStringList OPimXRefManager::apps()const { 33QStringList OPimXRefManager::apps()const {
34 OPimXRef::ValueList::ConstIterator it; 34 OPimXRef::ValueList::ConstIterator it;
35 QStringList list; 35 QStringList list;
36 36
37 QString str; 37 QString str;
38 for ( it = m_list.begin(); it != m_list.end(); ++it ) { 38 for ( it = m_list.begin(); it != m_list.end(); ++it ) {
39 str = (*it).partner( OPimXRef::One ).appName(); 39 str = (*it).partner( OPimXRef::One ).service();
40 if ( !list.contains( str ) ) list << str; 40 if ( !list.contains( str ) ) list << str;
41 41
42 str = (*it).partner( OPimXRef::Two ).appName(); 42 str = (*it).partner( OPimXRef::Two ).service();
43 if ( !list.contains( str ) ) list << str; 43 if ( !list.contains( str ) ) list << str;
44 } 44 }
45 return list; 45 return list;
46} 46}
47OPimXRef::ValueList OPimXRefManager::list()const { 47OPimXRef::ValueList OPimXRefManager::list()const {
48 return m_list; 48 return m_list;
49} 49}
50OPimXRef::ValueList OPimXRefManager::list( const QString& appName )const{ 50OPimXRef::ValueList OPimXRefManager::list( const QString& appName )const{
51 OPimXRef::ValueList list; 51 OPimXRef::ValueList list;
52 OPimXRef::ValueList::ConstIterator it; 52 OPimXRef::ValueList::ConstIterator it;
53 53
54 for ( it = m_list.begin(); it != m_list.end(); ++it ) { 54 for ( it = m_list.begin(); it != m_list.end(); ++it ) {
55 if ( (*it).containsString( appName ) ) 55 if ( (*it).containsString( appName ) )
56 list.append( (*it) ); 56 list.append( (*it) );
57 } 57 }
58 58
59 return list; 59 return list;
60} 60}
61OPimXRef::ValueList OPimXRefManager::list( int uid )const { 61OPimXRef::ValueList OPimXRefManager::list( int uid )const {
62 OPimXRef::ValueList list; 62 OPimXRef::ValueList list;
63 OPimXRef::ValueList::ConstIterator it; 63 OPimXRef::ValueList::ConstIterator it;
64 64
65 for ( it = m_list.begin(); it != m_list.end(); ++it ) { 65 for ( it = m_list.begin(); it != m_list.end(); ++it ) {
66 if ( (*it).containsUid( uid ) ) 66 if ( (*it).containsUid( uid ) )
67 list.append( (*it) ); 67 list.append( (*it) );
68 } 68 }
69 69
70 return list; 70 return list;
71} 71}
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
@@ -2,40 +2,40 @@
2#define OPIM_XREF_MANAGER_H 2#define OPIM_XREF_MANAGER_H
3 3
4#include <qstringlist.h> 4#include <qstringlist.h>
5 5
6#include <opie/opimxref.h> 6#include <opie/opimxref.h>
7 7
8/** 8/**
9 * This is a simple manager for 9 * This is a simple manager for
10 * OPimXRefs. 10 * OPimXRefs.
11 * It allows addition, removing, replacing 11 * It allows addition, removing, replacing
12 * clearing and 'querying' the XRef... 12 * clearing and 'querying' the XRef...
13 */ 13 */
14class OPimXRefManager { 14class OPimXRefManager {
15public: 15public:
16 OPimXRefManager(); 16 OPimXRefManager();
17 OPimXRefManager( const OPimXRefManager& ); 17 OPimXRefManager( const OPimXRefManager& );
18 ~OPimXRefManager(); 18 ~OPimXRefManager();
19 19
20 OPimXRefManager& operator=( const OPimXRefManager& ); 20 OPimXRefManager& operator=( const OPimXRefManager& );
21 bool operator==( const OPimXRefManager& ); 21 bool operator==( const OPimXRefManager& );
22 22
23 void add( const OPimXRef& ); 23 void add( const OPimXRef& );
24 void remove( const OPimXRef& ); 24 void remove( const OPimXRef& );
25 void replace( const OPimXRef& ); 25 void replace( const OPimXRef& );
26 26
27 void clear(); 27 void clear();
28 28
29 /** 29 /**
30 * apps participating 30 * apps participating
31 */ 31 */
32 QStringList apps()const; 32 QStringList apps()const;
33 OPimXRef::ValueList list()const; 33 OPimXRef::ValueList list()const;
34 OPimXRef::ValueList list( const QString& appName )const; 34 OPimXRef::ValueList list( const QString& service )const;
35 OPimXRef::ValueList list( int uid )const; 35 OPimXRef::ValueList list( int uid )const;
36 36
37private: 37private:
38 OPimXRef::ValueList m_list; 38 OPimXRef::ValueList m_list;
39}; 39};
40 40
41#endif 41#endif
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
@@ -1,43 +1,43 @@
1#include "opimxrefpartner.h" 1#include "opimxrefpartner.h"
2 2
3OPimXRefPartner::OPimXRefPartner( const QString& appName, 3OPimXRefPartner::OPimXRefPartner( const QString& appName,
4 int uid, int field ) 4 int uid, int field )
5 : m_app(appName), m_uid(uid), m_field( field ) { 5 : m_app(appName), m_uid(uid), m_field( field ) {
6} 6}
7OPimXRefPartner::OPimXRefPartner( const OPimXRefPartner& ref ) { 7OPimXRefPartner::OPimXRefPartner( const OPimXRefPartner& ref ) {
8 *this = ref; 8 *this = ref;
9} 9}
10OPimXRefPartner::~OPimXRefPartner() { 10OPimXRefPartner::~OPimXRefPartner() {
11} 11}
12OPimXRefPartner &OPimXRefPartner::operator=( const OPimXRefPartner& par ) { 12OPimXRefPartner &OPimXRefPartner::operator=( const OPimXRefPartner& par ) {
13 m_app = par.m_app; 13 m_app = par.m_app;
14 m_uid = par.m_uid; 14 m_uid = par.m_uid;
15 m_field = par.m_field; 15 m_field = par.m_field;
16 16
17 return *this; 17 return *this;
18} 18}
19bool OPimXRefPartner::operator==( const OPimXRefPartner& par ) { 19bool OPimXRefPartner::operator==( const OPimXRefPartner& par ) {
20 if ( m_app != par.m_app ) return false; 20 if ( m_app != par.m_app ) return false;
21 if ( m_uid != par.m_uid ) return false; 21 if ( m_uid != par.m_uid ) return false;
22 if ( m_field != par.m_field ) return false; 22 if ( m_field != par.m_field ) return false;
23 23
24 return true; 24 return true;
25} 25}
26QString OPimXRefPartner::appName()const { 26QString OPimXRefPartner::service()const {
27 return m_app; 27 return m_app;
28} 28}
29int OPimXRefPartner::uid()const { 29int OPimXRefPartner::uid()const {
30 return m_uid; 30 return m_uid;
31} 31}
32int OPimXRefPartner::field()const { 32int OPimXRefPartner::field()const {
33 return m_field; 33 return m_field;
34} 34}
35void OPimXRefPartner::setAppName( const QString& appName ) { 35void OPimXRefPartner::setService( const QString& appName ) {
36 m_app = appName; 36 m_app = appName;
37} 37}
38void OPimXRefPartner::setUid( int uid ) { 38void OPimXRefPartner::setUid( int uid ) {
39 m_uid = uid; 39 m_uid = uid;
40} 40}
41void OPimXRefPartner::setField( int field ) { 41void OPimXRefPartner::setField( int field ) {
42 m_field = field; 42 m_field = field;
43} 43}
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
@@ -1,40 +1,40 @@
1#ifndef OPIM_XREF_PARTNER_H 1#ifndef OPIM_XREF_PARTNER_H
2#define OPIM_XREF_PARTNER_H 2#define OPIM_XREF_PARTNER_H
3 3
4#include <qstring.h> 4#include <qstring.h>
5 5
6/** 6/**
7 * This class represents one partner 7 * This class represents one partner
8 * of a Cross Reference. 8 * of a Cross Reference.
9 * In Opie one application 9 * In Opie one application
10 * can link one uid 10 * can link one uid
11 * with one tableId( fieldId ) to another. 11 * with one tableId( fieldId ) to another.
12 */ 12 */
13class OPimXRefPartner { 13class OPimXRefPartner {
14public: 14public:
15 OPimXRefPartner( const QString& appName = QString::null, 15 OPimXRefPartner( const QString& service = QString::null,
16 int uid = 0, int field = -1 ); 16 int uid = 0, int field = -1 );
17 OPimXRefPartner( const OPimXRefPartner& ); 17 OPimXRefPartner( const OPimXRefPartner& );
18 OPimXRefPartner& operator=( const OPimXRefPartner& ); 18 OPimXRefPartner& operator=( const OPimXRefPartner& );
19 ~OPimXRefPartner(); 19 ~OPimXRefPartner();
20 20
21 bool operator==(const OPimXRefPartner& ); 21 bool operator==(const OPimXRefPartner& );
22 22
23 QString appName()const; 23 QString service()const;
24 int uid()const; 24 int uid()const;
25 int field()const; 25 int field()const;
26 26
27 void setAppName( const QString& appName ); 27 void setService( const QString& service );
28 void setUid( int uid ); 28 void setUid( int uid );
29 void setField( int field ); 29 void setField( int field );
30private: 30private:
31 QString m_app; 31 QString m_app;
32 int m_uid; 32 int m_uid;
33 int m_field; 33 int m_field;
34 34
35 class Private; 35 class Private;
36 Private* d; 36 Private* d;
37}; 37};
38 38
39 39
40#endif 40#endif
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
@@ -1,136 +1,451 @@
1#include <qshared.h> 1#include <qshared.h>
2 2
3#include <qtopia/timeconversion.h> 3#include <qtopia/timeconversion.h>
4 4
5#include "orecur.h" 5#include "orecur.h"
6 6
7struct ORecur::Data : public QShared { 7struct ORecur::Data : public QShared {
8 Data() : QShared() { 8 Data() : QShared() {
9 type = ORecur::NoRepeat; 9 type = ORecur::NoRepeat;
10 freq = -1; 10 freq = -1;
11 days = 0; 11 days = 0;
12 pos = 0; 12 pos = 0;
13 create = -1; 13 create = -1;
14 hasEnd = FALSE; 14 hasEnd = FALSE;
15 end = 0; 15 end = 0;
16 } 16 }
17 char days; // Q_UINT8 for 8 seven days;) 17 char days; // Q_UINT8 for 8 seven days;)
18 ORecur::RepeatType type; 18 ORecur::RepeatType type;
19 int freq; 19 int freq;
20 int pos; 20 int pos;
21 bool hasEnd : 1; 21 bool hasEnd : 1;
22 time_t end; 22 time_t end;
23 time_t create; 23 time_t create;
24 int rep; 24 int rep;
25 QString app;
26 ExceptionList list;
27 QDate start;
25}; 28};
26 29
27 30
28ORecur::ORecur() { 31ORecur::ORecur() {
29 data = new Data; 32 data = new Data;
30} 33}
31ORecur::ORecur( const ORecur& rec) 34ORecur::ORecur( const ORecur& rec)
32 : data( rec.data ) 35 : data( rec.data )
33{ 36{
34 data->ref(); 37 data->ref();
35} 38}
36ORecur::~ORecur() { 39ORecur::~ORecur() {
37 if ( data->deref() ) { 40 if ( data->deref() ) {
38 delete data; 41 delete data;
39 data = 0l; 42 data = 0l;
40 } 43 }
41} 44}
42void ORecur::deref() { 45void ORecur::deref() {
43 if ( data->deref() ) { 46 if ( data->deref() ) {
44 delete data; 47 delete data;
45 data = 0l; 48 data = 0l;
46 } 49 }
47} 50}
48bool ORecur::operator==( const ORecur& )const { 51bool ORecur::operator==( const ORecur& )const {
49 return false; 52 return false;
50} 53}
51ORecur &ORecur::operator=( const ORecur& re) { 54ORecur &ORecur::operator=( const ORecur& re) {
52 re.data->ref(); 55 re.data->ref();
53 deref(); 56 deref();
54 data = re.data; 57 data = re.data;
55 58
56 return *this; 59 return *this;
57} 60}
61bool ORecur::doesRecur()const {
62 return !( type() == NoRepeat );
63}
64/*
65 * we try to be smart here
66 *
67 */
68bool ORecur::doesRecur( const QDate& date ) {
69 /* the day before the recurrance */
70 QDate da = date.addDays(-1);
71
72 QDate recur;
73 if (!nextOcurrence( da, recur ) )
74 return false;
75
76 return (recur == date);
77}
78// FIXME unuglify!
79// GPL from Datebookdb.cpp
80// FIXME exception list!
81bool ORecur::nextOcurrence( const QDate& from, QDate& next ) {
82
83 // easy checks, first are we too far in the future or too far in the past?
84 QDate tmpDate;
85 int freq = frequency();
86 int diff, diff2, a;
87 int iday, imonth, iyear;
88 int dayOfWeek = 0;
89 int firstOfWeek = 0;
90 int weekOfMonth;
91
92
93 if (hasEndDate() && endDate() < from)
94 return FALSE;
95
96 if (start() >= from) {
97 next = start();
98 return TRUE;
99 }
100
101 switch ( type() ) {
102 case Weekly:
103 /* weekly is just daily by 7 */
104 /* first convert the repeatPattern.Days() mask to the next
105 day of week valid after from */
106 dayOfWeek = from.dayOfWeek();
107 dayOfWeek--; /* we want 0-6, doco for above specs 1-7 */
108
109 /* this is done in case freq > 1 and from in week not
110 for this round */
111 // firstOfWeek = 0; this is already done at decl.
112 while(!((1 << firstOfWeek) & days() ))
113 firstOfWeek++;
114
115 /* there is at least one 'day', or there would be no event */
116 while(!((1 << (dayOfWeek % 7)) & days() ))
117 dayOfWeek++;
118
119 dayOfWeek = dayOfWeek % 7; /* the actual day of week */
120 dayOfWeek -= start().dayOfWeek() -1;
121
122 firstOfWeek = firstOfWeek % 7; /* the actual first of week */
123 firstOfWeek -= start().dayOfWeek() -1;
124
125 // dayOfWeek may be negitive now
126 // day of week is number of days to add to start day
127
128 freq *= 7;
129 // FALL-THROUGH !!!!!
130 case Daily:
131 // the add is for the possible fall through from weekly */
132 if(start().addDays(dayOfWeek) > from) {
133 /* first week exception */
134 next = QDate(start().addDays(dayOfWeek) );
135 if ((next > endDate())
136 && hasEndDate() )
137 return FALSE;
138 return TRUE;
139 }
140 /* if from is middle of a non-week */
141
142 diff = start().addDays(dayOfWeek).daysTo(from) % freq;
143 diff2 = start().addDays(firstOfWeek).daysTo(from) % freq;
144
145 if(diff != 0)
146 diff = freq - diff;
147 if(diff2 != 0)
148 diff2 = freq - diff2;
149 diff = QMIN(diff, diff2);
150
151 next = QDate(from.addDays(diff));
152 if ( (next > endDate())
153 && hasEndDate() )
154 return FALSE;
155 return TRUE;
156 case MonthlyDay:
157 iday = from.day();
158 iyear = from.year();
159 imonth = from.month();
160 /* find equivelent day of month for this month */
161 dayOfWeek = start().dayOfWeek();
162 weekOfMonth = (start().day() - 1) / 7;
163
164 /* work out when the next valid month is */
165 a = from.year() - start().year();
166 a *= 12;
167 a = a + (imonth - start().month());
168 /* a is e.start()monthsFrom(from); */
169 if(a % freq) {
170 a = freq - (a % freq);
171 imonth = from.month() + a;
172 if (imonth > 12) {
173 imonth--;
174 iyear += imonth / 12;
175 imonth = imonth % 12;
176 imonth++;
177 }
178 }
179 /* imonth is now the first month after or on
180 from that matches the frequency given */
181
182 /* find for this month */
183 tmpDate = QDate( iyear, imonth, 1 );
184
185 iday = 1;
186 iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
187 iday += 7 * weekOfMonth;
188 while (iday > tmpDate.daysInMonth()) {
189 imonth += freq;
190 if (imonth > 12) {
191 imonth--;
192 iyear += imonth / 12;
193 imonth = imonth % 12;
194 imonth++;
195 }
196 tmpDate = QDate( iyear, imonth, 1 );
197 /* these loops could go for a while, check end case now */
198 if ((tmpDate > endDate()) && hasEndDate() )
199 return FALSE;
200 iday = 1;
201 iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
202 iday += 7 * weekOfMonth;
203 }
204 tmpDate = QDate(iyear, imonth, iday);
205
206 if (tmpDate >= from) {
207 next = tmpDate;
208 if ((next > endDate() ) && hasEndDate() )
209 return FALSE;
210 return TRUE;
211 }
212
213 /* need to find the next iteration */
214 do {
215 imonth += freq;
216 if (imonth > 12) {
217 imonth--;
218 iyear += imonth / 12;
219 imonth = imonth % 12;
220 imonth++;
221 }
222 tmpDate = QDate( iyear, imonth, 1 );
223 /* these loops could go for a while, check end case now */
224 if ((tmpDate > endDate()) && hasEndDate() )
225 return FALSE;
226 iday = 1;
227 iday += (7 + dayOfWeek - tmpDate.dayOfWeek()) % 7;
228 iday += 7 * weekOfMonth;
229 } while (iday > tmpDate.daysInMonth());
230 tmpDate = QDate(iyear, imonth, iday);
231
232 next = tmpDate;
233 if ((next > endDate()) && hasEndDate() )
234 return FALSE;
235 return TRUE;
236 case MonthlyDate:
237 iday = start().day();
238 iyear = from.year();
239 imonth = from.month();
240
241 a = from.year() - start().year();
242 a *= 12;
243 a = a + (imonth - start().month());
244 /* a is e.start()monthsFrom(from); */
245 if(a % freq) {
246 a = freq - (a % freq);
247 imonth = from.month() + a;
248 if (imonth > 12) {
249 imonth--;
250 iyear += imonth / 12;
251 imonth = imonth % 12;
252 imonth++;
253 }
254 }
255 /* imonth is now the first month after or on
256 from that matches the frequencey given */
257
258 /* this could go for a while, worse case, 4*12 iterations, probably */
259 while(!QDate::isValid(iyear, imonth, iday) ) {
260 imonth += freq;
261 if (imonth > 12) {
262 imonth--;
263 iyear += imonth / 12;
264 imonth = imonth % 12;
265 imonth++;
266 }
267 /* these loops could go for a while, check end case now */
268 if ((QDate(iyear, imonth, 1) > endDate()) && hasEndDate() )
269 return FALSE;
270 }
271
272 if(QDate(iyear, imonth, iday) >= from) {
273 /* done */
274 next = QDate(iyear, imonth, iday);
275 if ((next > endDate()) && hasEndDate() )
276 return FALSE;
277 return TRUE;
278 }
279
280 /* ok, need to cycle */
281 imonth += freq;
282 imonth--;
283 iyear += imonth / 12;
284 imonth = imonth % 12;
285 imonth++;
286
287 while(!QDate::isValid(iyear, imonth, iday) ) {
288 imonth += freq;
289 imonth--;
290 iyear += imonth / 12;
291 imonth = imonth % 12;
292 imonth++;
293 if ((QDate(iyear, imonth, 1) > endDate()) && hasEndDate() )
294 return FALSE;
295 }
296
297 next = QDate(iyear, imonth, iday);
298 if ((next > endDate()) && hasEndDate() )
299 return FALSE;
300 return TRUE;
301 case Yearly:
302 iday = start().day();
303 imonth = start().month();
304 iyear = from.year(); // after all, we want to start in this year
305
306 diff = 1;
307 if(imonth == 2 && iday > 28) {
308 /* leap year, and it counts, calculate actual frequency */
309 if(freq % 4)
310 if (freq % 2)
311 freq = freq * 4;
312 else
313 freq = freq * 2;
314 /* else divides by 4 already, leave freq alone */
315 diff = 4;
316 }
317
318 a = from.year() - start().year();
319 if(a % freq) {
320 a = freq - (a % freq);
321 iyear = iyear + a;
322 }
323
324 /* under the assumption we won't hit one of the special not-leap years twice */
325 if(!QDate::isValid(iyear, imonth, iday)) {
326 /* must have been skipping by leap years and hit one that wasn't, (e.g. 2100) */
327 iyear += freq;
328 }
329
330 if(QDate(iyear, imonth, iday) >= from) {
331 next = QDate(iyear, imonth, iday);
332
333 if ((next > endDate()) && hasEndDate() )
334 return FALSE;
335 return TRUE;
336 }
337 /* iyear == from.year(), need to advance again */
338 iyear += freq;
339 /* under the assumption we won't hit one of the special not-leap years twice */
340 if(!QDate::isValid(iyear, imonth, iday)) {
341 /* must have been skipping by leap years and hit one that wasn't, (e.g. 2100) */
342 iyear += freq;
343 }
344
345 next = QDate(iyear, imonth, iday);
346 if ((next > endDate()) && hasEndDate() )
347 return FALSE;
348 return TRUE;
349 default:
350 return FALSE;
351 }
352}
58ORecur::RepeatType ORecur::type()const{ 353ORecur::RepeatType ORecur::type()const{
59 return data->type; 354 return data->type;
60} 355}
61int ORecur::frequency()const { 356int ORecur::frequency()const {
62 return data->freq; 357 return data->freq;
63} 358}
64int ORecur::position()const { 359int ORecur::position()const {
65 return data->pos; 360 return data->pos;
66} 361}
67char ORecur::days() const{ 362char ORecur::days() const{
68 return data->days; 363 return data->days;
69} 364}
70bool ORecur::hasEndDate()const { 365bool ORecur::hasEndDate()const {
71 return data->hasEnd; 366 return data->hasEnd;
72} 367}
73QDate ORecur::endDate()const { 368QDate ORecur::endDate()const {
74 return TimeConversion::fromUTC( data->end ).date(); 369 return TimeConversion::fromUTC( data->end ).date();
75} 370}
371QDate ORecur::start()const{
372 return data->start;
373}
76time_t ORecur::endDateUTC()const { 374time_t ORecur::endDateUTC()const {
77 return data->end; 375 return data->end;
78} 376}
79time_t ORecur::createTime()const { 377time_t ORecur::createTime()const {
80 return data->create; 378 return data->create;
81} 379}
82int ORecur::repetition()const { 380int ORecur::repetition()const {
83 return data->rep; 381 return data->rep;
84} 382}
383QString ORecur::service()const {
384 return data->app;
385}
386ORecur::ExceptionList& ORecur::exceptions() {
387 return data->list;
388}
85void ORecur::setType( const RepeatType& z) { 389void ORecur::setType( const RepeatType& z) {
86 checkOrModify(); 390 checkOrModify();
87 data->type = z; 391 data->type = z;
88} 392}
89void ORecur::setFrequency( int freq ) { 393void ORecur::setFrequency( int freq ) {
90 checkOrModify(); 394 checkOrModify();
91 data->freq = freq; 395 data->freq = freq;
92} 396}
93void ORecur::setPosition( int pos ) { 397void ORecur::setPosition( int pos ) {
94 checkOrModify(); 398 checkOrModify();
95 data->pos = pos; 399 data->pos = pos;
96} 400}
97void ORecur::setDays( char c ) { 401void ORecur::setDays( char c ) {
98 checkOrModify(); 402 checkOrModify();
99 data->days = c; 403 data->days = c;
100} 404}
101void ORecur::setEndDate( const QDate& dt) { 405void ORecur::setEndDate( const QDate& dt) {
102 checkOrModify(); 406 checkOrModify();
103 data->end = TimeConversion::toUTC( dt ); 407 data->end = TimeConversion::toUTC( dt );
104} 408}
105void ORecur::setEndDateUTC( time_t t) { 409void ORecur::setEndDateUTC( time_t t) {
106 checkOrModify(); 410 checkOrModify();
107 data->end = t; 411 data->end = t;
108} 412}
109void ORecur::setCreateTime( time_t t) { 413void ORecur::setCreateTime( time_t t) {
110 checkOrModify(); 414 checkOrModify();
111 data->create = t; 415 data->create = t;
112} 416}
113void ORecur::setHasEndDate( bool b) { 417void ORecur::setHasEndDate( bool b) {
114 checkOrModify(); 418 checkOrModify();
115 data->hasEnd = b; 419 data->hasEnd = b;
116} 420}
117void ORecur::setRepitition( int rep ) { 421void ORecur::setRepitition( int rep ) {
118 checkOrModify(); 422 checkOrModify();
119 data->rep = rep; 423 data->rep = rep;
120} 424}
425void ORecur::setService( const QString& app ) {
426 checkOrModify();
427 data->app = app;
428}
429void ORecur::setStart( const QDate& dt ) {
430 checkOrModify();
431 data->start = dt;
432}
121void ORecur::checkOrModify() { 433void ORecur::checkOrModify() {
122 if ( data->count != 1 ) { 434 if ( data->count != 1 ) {
123 data->deref(); 435 data->deref();
124 Data* d2 = new Data; 436 Data* d2 = new Data;
125 d2->days = data->days; 437 d2->days = data->days;
126 d2->type = data->type; 438 d2->type = data->type;
127 d2->freq = data->freq; 439 d2->freq = data->freq;
128 d2->pos = data->pos; 440 d2->pos = data->pos;
129 d2->hasEnd = data->hasEnd; 441 d2->hasEnd = data->hasEnd;
130 d2->end = data->end; 442 d2->end = data->end;
131 d2->create = data->create; 443 d2->create = data->create;
132 d2->rep = data->rep; 444 d2->rep = data->rep;
445 d2->app = data->app;
446 d2->list = data->list;
447 d2->start = data->start;
133 data = d2; 448 data = d2;
134 } 449 }
135} 450}
136 451
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
@@ -1,56 +1,83 @@
1/* 1/*
2 * GPL from TT 2 * GPL from TT
3 */ 3 */
4 4
5#ifndef OPIE_RECUR_H 5#ifndef OPIE_RECUR_H
6#define OPIE_RECUR_H 6#define OPIE_RECUR_H
7 7
8#include <sys/types.h> 8#include <sys/types.h>
9 9
10#include <qdatetime.h> 10#include <qdatetime.h>
11 11#include <qvaluelist.h>
12 12
13 13
14class ORecur { 14class ORecur {
15public: 15public:
16 typedef QValueList<QDate> ExceptionList;
16 enum RepeatType{ NoRepeat = -1, Daily, Weekly, MonthlyDay, 17 enum RepeatType{ NoRepeat = -1, Daily, Weekly, MonthlyDay,
17 MonthlyDate, Yearly }; 18 MonthlyDate, Yearly };
18 enum Days { MON = 0x01, TUE = 0x02, WED = 0x04, THU = 0x08, 19 enum Days { MON = 0x01, TUE = 0x02, WED = 0x04, THU = 0x08,
19 FRI = 0x10, SAT = 0x20, SUN = 0x40 }; 20 FRI = 0x10, SAT = 0x20, SUN = 0x40 };
20 ORecur(); 21 ORecur();
21 ORecur( const ORecur& ); 22 ORecur( const ORecur& );
22 ~ORecur(); 23 ~ORecur();
23 24
24 ORecur &operator=( const ORecur& ); 25 ORecur &operator=( const ORecur& );
25 bool operator==(const ORecur& )const; 26 bool operator==(const ORecur& )const;
27
28 bool doesRecur()const;
29 /* if it recurrs on that day */
30 bool doesRecur( const QDate& );
26 RepeatType type()const; 31 RepeatType type()const;
27 int frequency()const; 32 int frequency()const;
28 int position()const; 33 int position()const;
29 char days()const; 34 char days()const;
30 bool hasEndDate()const; 35 bool hasEndDate()const;
36 QDate start()const;
31 QDate endDate()const; 37 QDate endDate()const;
32 time_t endDateUTC()const; 38 time_t endDateUTC()const;
33 time_t createTime()const; 39 time_t createTime()const;
40
41 /**
42 * FromWhereToStart is not included!!!
43 */
44 bool nextOcurrence( const QDate& FromWhereToStart, QDate &recurDate );
45 /**
46 * The module this ORecur belongs to
47 */
48 QString service()const;
49
50 /*
51 * reference to the exception list
52 */
53 ExceptionList &exceptions();
54
55 /**
56 * the current repetition
57 */
34 int repetition()const; 58 int repetition()const;
35 59
36 void setType( const RepeatType& ); 60 void setType( const RepeatType& );
37 void setFrequency( int freq ); 61 void setFrequency( int freq );
38 void setPosition( int pos ); 62 void setPosition( int pos );
39 void setDays( char c); 63 void setDays( char c);
40 void setEndDate( const QDate& dt ); 64 void setEndDate( const QDate& dt );
65 void setStart( const QDate& dt );
41 void setEndDateUTC( time_t ); 66 void setEndDateUTC( time_t );
42 void setCreateTime( time_t ); 67 void setCreateTime( time_t );
43 void setHasEndDate( bool b ); 68 void setHasEndDate( bool b );
44 void setRepitition(int ); 69 void setRepitition(int );
70
71 void setService( const QString& ser );
45private: 72private:
46 void deref(); 73 void deref();
47 inline void checkOrModify(); 74 inline void checkOrModify();
48 75
49 76
50 class Data; 77 class Data;
51 Data* data; 78 Data* data;
52 class ORecurPrivate; 79 class ORecurPrivate;
53 ORecurPrivate *d; 80 ORecurPrivate *d;
54}; 81};
55 82
56#endif 83#endif
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
@@ -1,423 +1,421 @@
1 1
2#include <qobject.h> 2#include <qobject.h>
3#include <qshared.h> 3#include <qshared.h>
4 4
5 5
6 6
7#include <qpe/palmtopuidgen.h> 7#include <qpe/palmtopuidgen.h>
8#include <qpe/stringutil.h> 8#include <qpe/stringutil.h>
9#include <qpe/palmtoprecord.h> 9#include <qpe/palmtoprecord.h>
10#include <qpe/stringutil.h> 10#include <qpe/stringutil.h>
11#include <qpe/categories.h> 11#include <qpe/categories.h>
12#include <qpe/categoryselect.h> 12#include <qpe/categoryselect.h>
13 13
14 14
15#include "opimstate.h" 15#include "opimstate.h"
16#include "orecur.h" 16#include "orecur.h"
17#include "opimmaintainer.h" 17#include "opimmaintainer.h"
18#include "opimnotifymanager.h"
18 19
19#include "otodo.h" 20#include "otodo.h"
20 21
21 22
22struct OTodo::OTodoData : public QShared { 23struct OTodo::OTodoData : public QShared {
23 OTodoData() : QShared() { 24 OTodoData() : QShared() {
24 }; 25 };
25 26
26 QDate date; 27 QDate date;
27 bool isCompleted:1; 28 bool isCompleted:1;
28 bool hasDate:1; 29 bool hasDate:1;
29 int priority; 30 int priority;
30 QString desc; 31 QString desc;
31 QString sum; 32 QString sum;
32 QMap<QString, QString> extra; 33 QMap<QString, QString> extra;
33 ushort prog; 34 ushort prog;
34 bool hasAlarmDateTime :1;
35 QDateTime alarmDateTime;
36 OPimState state; 35 OPimState state;
37 ORecur recur; 36 ORecur recur;
38 OPimMaintainer maintainer; 37 OPimMaintainer maintainer;
38 QDate start;
39 QDate completed;
40 OPimNotifyManager notifiers;
39}; 41};
40 42
41OTodo::OTodo(const OTodo &event ) 43OTodo::OTodo(const OTodo &event )
42 : OPimRecord( event ), data( event.data ) 44 : OPimRecord( event ), data( event.data )
43{ 45{
44 data->ref(); 46 data->ref();
45// qWarning("ref up"); 47// qWarning("ref up");
46} 48}
47OTodo::~OTodo() { 49OTodo::~OTodo() {
48 50
49// qWarning("~OTodo " ); 51// qWarning("~OTodo " );
50 if ( data->deref() ) { 52 if ( data->deref() ) {
51// qWarning("OTodo::dereffing"); 53// qWarning("OTodo::dereffing");
52 delete data; 54 delete data;
53 data = 0l; 55 data = 0l;
54 } 56 }
55} 57}
56OTodo::OTodo(bool completed, int priority, 58OTodo::OTodo(bool completed, int priority,
57 const QArray<int> &category, 59 const QArray<int> &category,
58 const QString& summary, 60 const QString& summary,
59 const QString &description, 61 const QString &description,
60 ushort progress, 62 ushort progress,
61 bool hasDate, QDate date, int uid ) 63 bool hasDate, QDate date, int uid )
62 : OPimRecord( uid ) 64 : OPimRecord( uid )
63{ 65{
64// qWarning("OTodoData " + summary); 66// qWarning("OTodoData " + summary);
65 setCategories( category ); 67 setCategories( category );
66 68
67 data = new OTodoData; 69 data = new OTodoData;
68 70
69 data->date = date; 71 data->date = date;
70 data->isCompleted = completed; 72 data->isCompleted = completed;
71 data->hasDate = hasDate; 73 data->hasDate = hasDate;
72 data->priority = priority; 74 data->priority = priority;
73 data->sum = summary; 75 data->sum = summary;
74 data->prog = progress; 76 data->prog = progress;
75 data->desc = Qtopia::simplifyMultiLineSpace(description ); 77 data->desc = Qtopia::simplifyMultiLineSpace(description );
76 data->hasAlarmDateTime = false;
77
78} 78}
79OTodo::OTodo(bool completed, int priority, 79OTodo::OTodo(bool completed, int priority,
80 const QStringList &category, 80 const QStringList &category,
81 const QString& summary, 81 const QString& summary,
82 const QString &description, 82 const QString &description,
83 ushort progress, 83 ushort progress,
84 bool hasDate, QDate date, int uid ) 84 bool hasDate, QDate date, int uid )
85 : OPimRecord( uid ) 85 : OPimRecord( uid )
86{ 86{
87// qWarning("OTodoData" + summary); 87// qWarning("OTodoData" + summary);
88 setCategories( idsFromString( category.join(";") ) ); 88 setCategories( idsFromString( category.join(";") ) );
89 89
90 data = new OTodoData; 90 data = new OTodoData;
91 91
92 data->date = date; 92 data->date = date;
93 data->isCompleted = completed; 93 data->isCompleted = completed;
94 data->hasDate = hasDate; 94 data->hasDate = hasDate;
95 data->priority = priority; 95 data->priority = priority;
96 data->sum = summary; 96 data->sum = summary;
97 data->prog = progress; 97 data->prog = progress;
98 data->desc = Qtopia::simplifyMultiLineSpace(description ); 98 data->desc = Qtopia::simplifyMultiLineSpace(description );
99 data->hasAlarmDateTime = false;
100
101} 99}
102bool OTodo::match( const QRegExp &regExp )const 100bool OTodo::match( const QRegExp &regExp )const
103{ 101{
104 if( QString::number( data->priority ).find( regExp ) != -1 ){ 102 if( QString::number( data->priority ).find( regExp ) != -1 ){
105 return true; 103 return true;
106 }else if( data->hasDate && data->date.toString().find( regExp) != -1 ){ 104 }else if( data->hasDate && data->date.toString().find( regExp) != -1 ){
107 return true; 105 return true;
108 }else if(data->desc.find( regExp ) != -1 ){ 106 }else if(data->desc.find( regExp ) != -1 ){
109 return true; 107 return true;
110 }else if(data->sum.find( regExp ) != -1 ) { 108 }else if(data->sum.find( regExp ) != -1 ) {
111 return true; 109 return true;
112 } 110 }
113 return false; 111 return false;
114} 112}
115bool OTodo::isCompleted() const 113bool OTodo::isCompleted() const
116{ 114{
117 return data->isCompleted; 115 return data->isCompleted;
118} 116}
119bool OTodo::hasDueDate() const 117bool OTodo::hasDueDate() const
120{ 118{
121 return data->hasDate; 119 return data->hasDate;
122} 120}
123bool OTodo::hasAlarmDateTime() const 121bool OTodo::hasStartDate()const {
124{ 122 return data->start.isValid();
125 return data->hasAlarmDateTime; 123}
124bool OTodo::hasCompletedDate()const {
125 return data->completed.isValid();
126} 126}
127int OTodo::priority()const 127int OTodo::priority()const
128{ 128{
129 return data->priority; 129 return data->priority;
130} 130}
131QString OTodo::summary() const 131QString OTodo::summary() const
132{ 132{
133 return data->sum; 133 return data->sum;
134} 134}
135ushort OTodo::progress() const 135ushort OTodo::progress() const
136{ 136{
137 return data->prog; 137 return data->prog;
138} 138}
139QDate OTodo::dueDate()const 139QDate OTodo::dueDate()const
140{ 140{
141 return data->date; 141 return data->date;
142} 142}
143 143QDate OTodo::startDate()const {
144QDateTime OTodo::alarmDateTime() const 144 return data->start;
145{ 145}
146 return data->alarmDateTime; 146QDate OTodo::completedDate()const {
147 return data->completed;
147} 148}
148
149QString OTodo::description()const 149QString OTodo::description()const
150{ 150{
151 return data->desc; 151 return data->desc;
152} 152}
153OPimState OTodo::state()const { 153OPimState OTodo::state()const {
154 return data->state; 154 return data->state;
155} 155}
156ORecur OTodo::recurrence()const { 156ORecur OTodo::recurrence()const {
157 return data->recur; 157 return data->recur;
158} 158}
159OPimMaintainer OTodo::maintainer()const { 159OPimMaintainer OTodo::maintainer()const {
160 return data->maintainer; 160 return data->maintainer;
161} 161}
162void OTodo::setCompleted( bool completed ) 162void OTodo::setCompleted( bool completed )
163{ 163{
164 changeOrModify(); 164 changeOrModify();
165 data->isCompleted = completed; 165 data->isCompleted = completed;
166} 166}
167void OTodo::setHasDueDate( bool hasDate ) 167void OTodo::setHasDueDate( bool hasDate )
168{ 168{
169 changeOrModify(); 169 changeOrModify();
170 data->hasDate = hasDate; 170 data->hasDate = hasDate;
171} 171}
172void OTodo::setHasAlarmDateTime( bool hasAlarmDateTime )
173{
174 changeOrModify();
175 data->hasAlarmDateTime = hasAlarmDateTime;
176}
177void OTodo::setDescription(const QString &desc ) 172void OTodo::setDescription(const QString &desc )
178{ 173{
179// qWarning( "desc " + desc ); 174// qWarning( "desc " + desc );
180 changeOrModify(); 175 changeOrModify();
181 data->desc = Qtopia::simplifyMultiLineSpace(desc ); 176 data->desc = Qtopia::simplifyMultiLineSpace(desc );
182} 177}
183void OTodo::setSummary( const QString& sum ) 178void OTodo::setSummary( const QString& sum )
184{ 179{
185 changeOrModify(); 180 changeOrModify();
186 data->sum = sum; 181 data->sum = sum;
187} 182}
188void OTodo::setPriority(int prio ) 183void OTodo::setPriority(int prio )
189{ 184{
190 changeOrModify(); 185 changeOrModify();
191 data->priority = prio; 186 data->priority = prio;
192} 187}
193void OTodo::setDueDate( QDate date ) 188void OTodo::setDueDate( const QDate& date )
194{ 189{
195 changeOrModify(); 190 changeOrModify();
196 data->date = date; 191 data->date = date;
197} 192}
198void OTodo::setAlarmDateTime( const QDateTime& alarm ) 193void OTodo::setStartDate( const QDate& date ) {
199{
200 changeOrModify(); 194 changeOrModify();
201 data->alarmDateTime = alarm; 195 data->start = date;
196}
197void OTodo::setCompletedDate( const QDate& date ) {
198 changeOrModify();
199 data->completed = date;
202} 200}
203void OTodo::setState( const OPimState& state ) { 201void OTodo::setState( const OPimState& state ) {
204 changeOrModify(); 202 changeOrModify();
205 data->state = state; 203 data->state = state;
206} 204}
207void OTodo::setRecurrence( const ORecur& rec) { 205void OTodo::setRecurrence( const ORecur& rec) {
208 changeOrModify(); 206 changeOrModify();
209 data->recur = rec; 207 data->recur = rec;
210} 208}
211void OTodo::setMaintainer( const OPimMaintainer& pim ) { 209void OTodo::setMaintainer( const OPimMaintainer& pim ) {
212 changeOrModify(); 210 changeOrModify();
213 data->maintainer = pim; 211 data->maintainer = pim;
214} 212}
215bool OTodo::isOverdue( ) 213bool OTodo::isOverdue( )
216{ 214{
217 if( data->hasDate && !data->isCompleted) 215 if( data->hasDate && !data->isCompleted)
218 return QDate::currentDate() > data->date; 216 return QDate::currentDate() > data->date;
219 return false; 217 return false;
220} 218}
221void OTodo::setProgress(ushort progress ) 219void OTodo::setProgress(ushort progress )
222{ 220{
223 changeOrModify(); 221 changeOrModify();
224 data->prog = progress; 222 data->prog = progress;
225} 223}
226QString OTodo::toShortText() const { 224QString OTodo::toShortText() const {
227 return summary(); 225 return summary();
228} 226}
229/*! 227/*!
230 Returns a richt text string 228 Returns a richt text string
231*/ 229*/
232QString OTodo::toRichText() const 230QString OTodo::toRichText() const
233{ 231{
234 QString text; 232 QString text;
235 QStringList catlist; 233 QStringList catlist;
236 234
237 // Description of the todo 235 // Description of the todo
238 if ( !summary().isEmpty() ) { 236 if ( !summary().isEmpty() ) {
239 text += "<b>" + QObject::tr( "Summary:") + "</b><br>"; 237 text += "<b>" + QObject::tr( "Summary:") + "</b><br>";
240 text += Qtopia::escapeString(summary() ).replace(QRegExp( "[\n]"), "<br>" ) + "<br>"; 238 text += Qtopia::escapeString(summary() ).replace(QRegExp( "[\n]"), "<br>" ) + "<br>";
241 } 239 }
242 if( !description().isEmpty() ){ 240 if( !description().isEmpty() ){
243 text += "<b>" + QObject::tr( "Description:" ) + "</b><br>"; 241 text += "<b>" + QObject::tr( "Description:" ) + "</b><br>";
244 text += Qtopia::escapeString(description() ).replace(QRegExp( "[\n]"), "<br>" ) ; 242 text += Qtopia::escapeString(description() ).replace(QRegExp( "[\n]"), "<br>" ) ;
245 } 243 }
246 text += "<br><br><br>"; 244 text += "<br><br><br>";
247 245
248 text += "<b>" + QObject::tr( "Priority:") +" </b>" 246 text += "<b>" + QObject::tr( "Priority:") +" </b>"
249 + QString::number( priority() ) + " <br>"; 247 + QString::number( priority() ) + " <br>";
250 text += "<b>" + QObject::tr( "Progress:") + " </b>" 248 text += "<b>" + QObject::tr( "Progress:") + " </b>"
251 + QString::number( progress() ) + " %<br>"; 249 + QString::number( progress() ) + " %<br>";
252 if (hasDueDate() ){ 250 if (hasDueDate() ){
253 text += "<b>" + QObject::tr( "Deadline:") + " </b>"; 251 text += "<b>" + QObject::tr( "Deadline:") + " </b>";
254 text += dueDate().toString(); 252 text += dueDate().toString();
255 text += "<br>"; 253 text += "<br>";
256 } 254 }
257 if (hasAlarmDateTime() ){
258 text += "<b>" + QObject::tr( "Alarmed Notification:") + " </b>";
259 text += alarmDateTime().toString();
260 text += "<br>";
261 }
262 255
263 text += "<b>" + QObject::tr( "Category:") + "</b> "; 256 text += "<b>" + QObject::tr( "Category:") + "</b> ";
264 text += categoryNames().join(", "); 257 text += categoryNames().join(", ");
265 text += "<br>"; 258 text += "<br>";
266 259
267 return text; 260 return text;
268} 261}
262OPimNotifyManager& OTodo::notifiers() {
263 return data->notifiers;
264}
269 265
270bool OTodo::operator<( const OTodo &toDoEvent )const{ 266bool OTodo::operator<( const OTodo &toDoEvent )const{
271 if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true; 267 if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true;
272 if( !hasDueDate() && toDoEvent.hasDueDate() ) return false; 268 if( !hasDueDate() && toDoEvent.hasDueDate() ) return false;
273 if( hasDueDate() && toDoEvent.hasDueDate() ){ 269 if( hasDueDate() && toDoEvent.hasDueDate() ){
274 if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide 270 if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide
275 return priority() < toDoEvent.priority(); 271 return priority() < toDoEvent.priority();
276 }else{ 272 }else{
277 return dueDate() < toDoEvent.dueDate(); 273 return dueDate() < toDoEvent.dueDate();
278 } 274 }
279 } 275 }
280 return false; 276 return false;
281} 277}
282bool OTodo::operator<=(const OTodo &toDoEvent )const 278bool OTodo::operator<=(const OTodo &toDoEvent )const
283{ 279{
284 if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true; 280 if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true;
285 if( !hasDueDate() && toDoEvent.hasDueDate() ) return true; 281 if( !hasDueDate() && toDoEvent.hasDueDate() ) return true;
286 if( hasDueDate() && toDoEvent.hasDueDate() ){ 282 if( hasDueDate() && toDoEvent.hasDueDate() ){
287 if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide 283 if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide
288 return priority() <= toDoEvent.priority(); 284 return priority() <= toDoEvent.priority();
289 }else{ 285 }else{
290 return dueDate() <= toDoEvent.dueDate(); 286 return dueDate() <= toDoEvent.dueDate();
291 } 287 }
292 } 288 }
293 return true; 289 return true;
294} 290}
295bool OTodo::operator>(const OTodo &toDoEvent )const 291bool OTodo::operator>(const OTodo &toDoEvent )const
296{ 292{
297 if( !hasDueDate() && !toDoEvent.hasDueDate() ) return false; 293 if( !hasDueDate() && !toDoEvent.hasDueDate() ) return false;
298 if( !hasDueDate() && toDoEvent.hasDueDate() ) return false; 294 if( !hasDueDate() && toDoEvent.hasDueDate() ) return false;
299 if( hasDueDate() && toDoEvent.hasDueDate() ){ 295 if( hasDueDate() && toDoEvent.hasDueDate() ){
300 if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide 296 if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide
301 return priority() > toDoEvent.priority(); 297 return priority() > toDoEvent.priority();
302 }else{ 298 }else{
303 return dueDate() > toDoEvent.dueDate(); 299 return dueDate() > toDoEvent.dueDate();
304 } 300 }
305 } 301 }
306 return false; 302 return false;
307} 303}
308bool OTodo::operator>=(const OTodo &toDoEvent )const 304bool OTodo::operator>=(const OTodo &toDoEvent )const
309{ 305{
310 if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true; 306 if( !hasDueDate() && !toDoEvent.hasDueDate() ) return true;
311 if( !hasDueDate() && toDoEvent.hasDueDate() ) return false; 307 if( !hasDueDate() && toDoEvent.hasDueDate() ) return false;
312 if( hasDueDate() && toDoEvent.hasDueDate() ){ 308 if( hasDueDate() && toDoEvent.hasDueDate() ){
313 if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide 309 if( dueDate() == toDoEvent.dueDate() ){ // let's the priority decide
314 return priority() > toDoEvent.priority(); 310 return priority() > toDoEvent.priority();
315 }else{ 311 }else{
316 return dueDate() > toDoEvent.dueDate(); 312 return dueDate() > toDoEvent.dueDate();
317 } 313 }
318 } 314 }
319 return true; 315 return true;
320} 316}
321bool OTodo::operator==(const OTodo &toDoEvent )const 317bool OTodo::operator==(const OTodo &toDoEvent )const
322{ 318{
323 if ( data->priority != toDoEvent.data->priority ) return false; 319 if ( data->priority != toDoEvent.data->priority ) return false;
324 if ( data->priority != toDoEvent.data->prog ) return false; 320 if ( data->priority != toDoEvent.data->prog ) return false;
325 if ( data->isCompleted != toDoEvent.data->isCompleted ) return false; 321 if ( data->isCompleted != toDoEvent.data->isCompleted ) return false;
326 if ( data->hasDate != toDoEvent.data->hasDate ) return false; 322 if ( data->hasDate != toDoEvent.data->hasDate ) return false;
327 if ( data->date != toDoEvent.data->date ) return false; 323 if ( data->date != toDoEvent.data->date ) return false;
328 if ( data->sum != toDoEvent.data->sum ) return false; 324 if ( data->sum != toDoEvent.data->sum ) return false;
329 if ( data->desc != toDoEvent.data->desc ) return false; 325 if ( data->desc != toDoEvent.data->desc ) return false;
330 if ( data->hasAlarmDateTime != toDoEvent.data->hasAlarmDateTime )
331 return false;
332 if ( data->alarmDateTime != toDoEvent.data->alarmDateTime )
333 return false;
334 if ( data->maintainer != toDoEvent.data->maintainer ) 326 if ( data->maintainer != toDoEvent.data->maintainer )
335 return false; 327 return false;
336 328
337 return OPimRecord::operator==( toDoEvent ); 329 return OPimRecord::operator==( toDoEvent );
338} 330}
339void OTodo::deref() { 331void OTodo::deref() {
340 332
341// qWarning("deref in ToDoEvent"); 333// qWarning("deref in ToDoEvent");
342 if ( data->deref() ) { 334 if ( data->deref() ) {
343// qWarning("deleting"); 335// qWarning("deleting");
344 delete data; 336 delete data;
345 data= 0; 337 data= 0;
346 } 338 }
347} 339}
348OTodo &OTodo::operator=(const OTodo &item ) 340OTodo &OTodo::operator=(const OTodo &item )
349{ 341{
350 OPimRecord::operator=( item ); 342 OPimRecord::operator=( item );
351 //qWarning("operator= ref "); 343 //qWarning("operator= ref ");
352 item.data->ref(); 344 item.data->ref();
353 deref(); 345 deref();
354 data = item.data; 346 data = item.data;
355 347
356 return *this; 348 return *this;
357} 349}
358 350
359QMap<int, QString> OTodo::toMap() const { 351QMap<int, QString> OTodo::toMap() const {
360 QMap<int, QString> map; 352 QMap<int, QString> map;
361 353
362 map.insert( Uid, QString::number( uid() ) ); 354 map.insert( Uid, QString::number( uid() ) );
363 map.insert( Category, idsToString( categories() ) ); 355 map.insert( Category, idsToString( categories() ) );
364 map.insert( HasDate, QString::number( data->hasDate ) ); 356 map.insert( HasDate, QString::number( data->hasDate ) );
365 map.insert( Completed, QString::number( data->isCompleted ) ); 357 map.insert( Completed, QString::number( data->isCompleted ) );
366 map.insert( Description, data->desc ); 358 map.insert( Description, data->desc );
367 map.insert( Summary, data->sum ); 359 map.insert( Summary, data->sum );
368 map.insert( Priority, QString::number( data->priority ) ); 360 map.insert( Priority, QString::number( data->priority ) );
369 map.insert( DateDay, QString::number( data->date.day() ) ); 361 map.insert( DateDay, QString::number( data->date.day() ) );
370 map.insert( DateMonth, QString::number( data->date.month() ) ); 362 map.insert( DateMonth, QString::number( data->date.month() ) );
371 map.insert( DateYear, QString::number( data->date.year() ) ); 363 map.insert( DateYear, QString::number( data->date.year() ) );
372 map.insert( Progress, QString::number( data->prog ) ); 364 map.insert( Progress, QString::number( data->prog ) );
373// map.insert( CrossReference, crossToString() ); 365// map.insert( CrossReference, crossToString() );
374 map.insert( HasAlarmDateTime, QString::number( data->hasAlarmDateTime ) ); 366 /* FIXME!!! map.insert( State, );
375 map.insert( AlarmDateTime, data->alarmDateTime.toString() ); 367 map.insert( Recurrence, );
376 368 map.insert( Reminders, );
369 map.
370 */
377 return map; 371 return map;
378} 372}
379 373
380QMap<QString, QString> OTodo::toExtraMap()const { 374QMap<QString, QString> OTodo::toExtraMap()const {
381 return data->extra; 375 return data->extra;
382} 376}
383/** 377/**
384 * change or modify looks at the ref count and either 378 * change or modify looks at the ref count and either
385 * creates a new QShared Object or it can modify it 379 * creates a new QShared Object or it can modify it
386 * right in place 380 * right in place
387 */ 381 */
388void OTodo::changeOrModify() { 382void OTodo::changeOrModify() {
389 if ( data->count != 1 ) { 383 if ( data->count != 1 ) {
390 qWarning("changeOrModify"); 384 qWarning("changeOrModify");
391 data->deref(); 385 data->deref();
392 OTodoData* d2 = new OTodoData(); 386 OTodoData* d2 = new OTodoData();
393 copy(data, d2 ); 387 copy(data, d2 );
394 data = d2; 388 data = d2;
395 } 389 }
396} 390}
397// WATCHOUT 391// WATCHOUT
398/* 392/*
399 * if you add something to the Data struct 393 * if you add something to the Data struct
400 * be sure to copy it here 394 * be sure to copy it here
401 */ 395 */
402void OTodo::copy( OTodoData* src, OTodoData* dest ) { 396void OTodo::copy( OTodoData* src, OTodoData* dest ) {
403 dest->date = src->date; 397 dest->date = src->date;
404 dest->isCompleted = src->isCompleted; 398 dest->isCompleted = src->isCompleted;
405 dest->hasDate = src->hasDate; 399 dest->hasDate = src->hasDate;
406 dest->priority = src->priority; 400 dest->priority = src->priority;
407 dest->desc = src->desc; 401 dest->desc = src->desc;
408 dest->sum = src->sum; 402 dest->sum = src->sum;
409 dest->extra = src->extra; 403 dest->extra = src->extra;
410 dest->prog = src->prog; 404 dest->prog = src->prog;
411 dest->hasAlarmDateTime = src->hasAlarmDateTime;
412 dest->alarmDateTime = src->alarmDateTime;
413 dest->state = src->state; 405 dest->state = src->state;
414 dest->recur = src->recur; 406 dest->recur = src->recur;
415 dest->maintainer = src->maintainer; 407 dest->maintainer = src->maintainer;
408 dest->start = src->start;
409 dest->completed = src->completed;
410 dest->notifiers = src->notifiers;
416} 411}
417QString OTodo::type() const { 412QString OTodo::type() const {
418 return QString::fromLatin1("OTodo"); 413 return QString::fromLatin1("OTodo");
419} 414}
420QString OTodo::recordField(int /*id*/ )const { 415QString OTodo::recordField(int /*id*/ )const {
421 return QString::null; 416 return QString::null;
422} 417}
423 418
419int OTodo::rtti(){
420 return 1;
421}
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
@@ -1,246 +1,273 @@
1 1
2#ifndef OPIE_TODO_EVENT_H 2#ifndef OPIE_TODO_EVENT_H
3#define OPIE_TODO_EVENT_H 3#define OPIE_TODO_EVENT_H
4 4
5 5
6#include <qarray.h> 6#include <qarray.h>
7#include <qmap.h> 7#include <qmap.h>
8#include <qregexp.h> 8#include <qregexp.h>
9#include <qstringlist.h> 9#include <qstringlist.h>
10#include <qdatetime.h> 10#include <qdatetime.h>
11#include <qvaluelist.h> 11#include <qvaluelist.h>
12 12
13#include <qpe/recordfields.h> 13#include <qpe/recordfields.h>
14#include <qpe/palmtopuidgen.h> 14#include <qpe/palmtopuidgen.h>
15 15
16#include <opie/opimrecord.h> 16#include <opie/opimrecord.h>
17 17
18 18
19class OPimState; 19class OPimState;
20class ORecur; 20class ORecur;
21class OPimMaintainer; 21class OPimMaintainer;
22class OPimNotifyManager;
22class OTodo : public OPimRecord { 23class OTodo : public OPimRecord {
23public: 24public:
24 typedef QValueList<OTodo> ValueList; 25 typedef QValueList<OTodo> ValueList;
25 enum RecordFields { 26 enum RecordFields {
26 Uid = Qtopia::UID_ID, 27 Uid = Qtopia::UID_ID,
27 Category = Qtopia::CATEGORY_ID, 28 Category = Qtopia::CATEGORY_ID,
28 HasDate, 29 HasDate,
29 Completed, 30 Completed,
30 Description, 31 Description,
31 Summary, 32 Summary,
32 Priority, 33 Priority,
33 DateDay, 34 DateDay,
34 DateMonth, 35 DateMonth,
35 DateYear, 36 DateYear,
36 Progress, 37 Progress,
37 CrossReference, 38 CrossReference,
38 HasAlarmDateTime,
39 AlarmDateTime,
40 State, 39 State,
41 Recurrance, 40 Recurrence,
42 Alarms, 41 Alarms,
43 Reminders, 42 Reminders,
44 Notifiers 43 Notifiers,
44 Maintainer,
45 StartDate,
46 CompletedDate
45 }; 47 };
46 public: 48 public:
47 // priorities from Very low to very high 49 // priorities from Very low to very high
48 enum TaskPriority { VeryHigh=1, High, Normal, Low, VeryLow }; 50 enum TaskPriority { VeryHigh=1, High, Normal, Low, VeryLow };
49 51
50 /* Constructs a new ToDoEvent 52 /* Constructs a new ToDoEvent
51 @param completed Is the TodoEvent completed 53 @param completed Is the TodoEvent completed
52 @param priority What is the priority of this ToDoEvent 54 @param priority What is the priority of this ToDoEvent
53 @param category Which category does it belong( uid ) 55 @param category Which category does it belong( uid )
54 @param summary A small summary of the todo 56 @param summary A small summary of the todo
55 @param description What is this ToDoEvent about 57 @param description What is this ToDoEvent about
56 @param hasDate Does this Event got a deadline 58 @param hasDate Does this Event got a deadline
57 @param date what is the deadline? 59 @param date what is the deadline?
58 @param uid what is the UUID of this Event 60 @param uid what is the UUID of this Event
59 **/ 61 **/
60 OTodo( bool completed = false, int priority = Normal, 62 OTodo( bool completed = false, int priority = Normal,
61 const QStringList &category = QStringList(), 63 const QStringList &category = QStringList(),
62 const QString &summary = QString::null , 64 const QString &summary = QString::null ,
63 const QString &description = QString::null, 65 const QString &description = QString::null,
64 ushort progress = 0, 66 ushort progress = 0,
65 bool hasDate = false, QDate date = QDate::currentDate(), 67 bool hasDate = false, QDate date = QDate::currentDate(),
66 int uid = 0 /*empty*/ ); 68 int uid = 0 /*empty*/ );
67 69
68 OTodo( bool completed, int priority, 70 OTodo( bool completed, int priority,
69 const QArray<int>& category, 71 const QArray<int>& category,
70 const QString& summary = QString::null, 72 const QString& summary = QString::null,
71 const QString& description = QString::null, 73 const QString& description = QString::null,
72 ushort progress = 0, 74 ushort progress = 0,
73 bool hasDate = false, QDate date = QDate::currentDate(), 75 bool hasDate = false, QDate date = QDate::currentDate(),
74 int uid = 0 /* empty */ ); 76 int uid = 0 /* empty */ );
75 77
76 /* Copy c'tor 78 /** Copy c'tor
77 79 *
78 **/ 80 */
79 OTodo(const OTodo & ); 81 OTodo(const OTodo & );
80 82
81 /** 83 /**
82 *destructor 84 *destructor
83 */ 85 */
84 ~OTodo(); 86 ~OTodo();
85 87
86 /** 88 /**
87 * Is this event completed? 89 * Is this event completed?
88 */ 90 */
89 bool isCompleted() const; 91 bool isCompleted() const;
90 92
91 /** 93 /**
92 * Does this Event have a deadline 94 * Does this Event have a deadline
93 */ 95 */
94 bool hasDueDate() const; 96 bool hasDueDate() const;
97 bool hasStartDate()const;
98 bool hasCompletedDate()const;
95 99
96 /** 100 /**
97 * Does this Event has an alarm time ? 101 * Does this Event has an alarm time ?
98 */ 102 */
99 bool hasAlarmDateTime() const; 103 bool hasAlarmDateTime() const;
100 104
101 /** 105 /**
102 * What is the priority? 106 * What is the priority?
103 */ 107 */
104 int priority()const ; 108 int priority()const ;
105 109
106 /** 110 /**
107 * progress as ushort 0, 20, 40, 60, 80 or 100% 111 * progress as ushort 0, 20, 40, 60, 80 or 100%
108 */ 112 */
109 ushort progress() const; 113 ushort progress() const;
110 114
111 /** 115 /**
112 * The due Date 116 * The due Date
113 */ 117 */
114 QDate dueDate()const; 118 QDate dueDate()const;
115 119
116 /** 120 /**
117 * Alarm Date and Time 121 * When did it start?
122 */
123 QDate startDate()const;
124
125 /**
126 * When was it completed?
118 */ 127 */
119 QDateTime alarmDateTime()const; 128 QDate completedDate()const;
120 129
121 /** 130 /**
122 * What is the state of this OTodo? 131 * What is the state of this OTodo?
123 */ 132 */
124 OPimState state()const; 133 OPimState state()const;
125 134
126 /** 135 /**
127 * the recurrance of this 136 * the recurrance of this
128 */ 137 */
129 ORecur recurrence()const; 138 ORecur recurrence()const;
130 139
131 /** 140 /**
132 * the Maintainer of this OTodo 141 * the Maintainer of this OTodo
133 */ 142 */
134 OPimMaintainer maintainer()const; 143 OPimMaintainer maintainer()const;
135 144
136 /** 145 /**
137 * The description of the todo 146 * The description of the todo
138 */ 147 */
139 QString description()const; 148 QString description()const;
140 149
141 /** 150 /**
142 * A small summary of the todo 151 * A small summary of the todo
143 */ 152 */
144 QString summary() const; 153 QString summary() const;
145 154
146 /** 155 /**
147 * @reimplemented 156 * @reimplemented
148 * Return this todoevent in a RichText formatted QString 157 * Return this todoevent in a RichText formatted QString
149 */ 158 */
150 QString toRichText() const; 159 QString toRichText() const;
151 160
161 /*
162 * check if the sharing is still fine!! -zecke
163 */
164 /**
165 * return a reference to our notifiers...
166 */
167 OPimNotifyManager &notifiers();
168
152 /** 169 /**
153 * reimplementation 170 * reimplementations
154 */ 171 */
155 QString type()const; 172 QString type()const;
156 QString toShortText()const; 173 QString toShortText()const;
157 QMap<QString, QString> toExtraMap()const; 174 QMap<QString, QString> toExtraMap()const;
158 QString recordField(int id )const; 175 QString recordField(int id )const;
159 176
160 /** 177 /**
161 * toMap puts all data into the map. int relates 178 * toMap puts all data into the map. int relates
162 * to ToDoEvent RecordFields enum 179 * to ToDoEvent RecordFields enum
163 */ 180 */
164 QMap<int, QString> toMap()const; 181 QMap<int, QString> toMap()const;
165 182
166 /** 183 /**
167 * Set if this Todo is completed 184 * Set if this Todo is completed
168 */ 185 */
169 void setCompleted(bool completed ); 186 void setCompleted(bool completed );
170 187
171 /** 188 /**
172 * set if this todo got an end data 189 * set if this todo got an end data
173 */ 190 */
174 void setHasDueDate( bool hasDate ); 191 void setHasDueDate( bool hasDate );
175 192 // FIXME we do not have these for start, completed
176 /** 193 // cause we'll use the isNull() of QDate for figuring
177 * set if this todo has an alarm time and date 194 // out if it's has a date...
178 */ 195 // decide what to do here? -zecke
179 void setHasAlarmDateTime ( bool hasAlarm );
180 196
181 /** 197 /**
182 * Set the priority of the Todo 198 * Set the priority of the Todo
183 */ 199 */
184 void setPriority(int priority ); 200 void setPriority(int priority );
185 201
186 /** 202 /**
187 * Set the progress. 203 * Set the progress.
188 */ 204 */
189 void setProgress( ushort progress ); 205 void setProgress( ushort progress );
190 206
191 /** 207 /**
192 * set the end date 208 * set the end date
193 */ 209 */
194 void setDueDate( QDate date ); 210 void setDueDate( const QDate& date );
195 211
212 /**
213 * set the start date
214 */
215 void setStartDate( const QDate& date );
216
217 /**
218 * set the completed date
219 */
220 void setCompletedDate( const QDate& date );
196 221
197 void setRecurrence( const ORecur& ); 222 void setRecurrence( const ORecur& );
198 /** 223 /**
199 * set the alarm time 224 * set the alarm time
200 */ 225 */
201 void setAlarmDateTime ( const QDateTime& alarm ); 226 void setAlarmDateTime ( const QDateTime& alarm );
202 227
203 void setDescription(const QString& ); 228 void setDescription(const QString& );
204 void setSummary(const QString& ); 229 void setSummary(const QString& );
205 230
206 /** 231 /**
207 * set the state of a Todo 232 * set the state of a Todo
208 * @param state State what the todo should take 233 * @param state State what the todo should take
209 */ 234 */
210 void setState( const OPimState& state); 235 void setState( const OPimState& state);
211 236
212 /** 237 /**
213 * set the Maintainer Mode 238 * set the Maintainer Mode
214 */ 239 */
215 void setMaintainer( const OPimMaintainer& ); 240 void setMaintainer( const OPimMaintainer& );
216 241
217 bool isOverdue(); 242 bool isOverdue();
218 243
219 244
220 bool match( const QRegExp &r )const; 245 bool match( const QRegExp &r )const;
221 246
222 bool operator<(const OTodo &toDoEvent )const; 247 bool operator<(const OTodo &toDoEvent )const;
223 bool operator<=(const OTodo &toDoEvent )const; 248 bool operator<=(const OTodo &toDoEvent )const;
224 bool operator!=(const OTodo &toDoEvent )const; 249 bool operator!=(const OTodo &toDoEvent )const;
225 bool operator>(const OTodo &toDoEvent )const; 250 bool operator>(const OTodo &toDoEvent )const;
226 bool operator>=(const OTodo &toDoEvent)const; 251 bool operator>=(const OTodo &toDoEvent)const;
227 bool operator==(const OTodo &toDoEvent )const; 252 bool operator==(const OTodo &toDoEvent )const;
228 OTodo &operator=(const OTodo &toDoEvent ); 253 OTodo &operator=(const OTodo &toDoEvent );
229 254
255 static int rtti();
256
230 private: 257 private:
231 class OTodoPrivate; 258 class OTodoPrivate;
232 struct OTodoData; 259 struct OTodoData;
233 260
234 void deref(); 261 void deref();
235 inline void changeOrModify(); 262 inline void changeOrModify();
236 void copy( OTodoData* src, OTodoData* dest ); 263 void copy( OTodoData* src, OTodoData* dest );
237 OTodoPrivate *d; 264 OTodoPrivate *d;
238 OTodoData *data; 265 OTodoData *data;
239 266
240}; 267};
241inline bool OTodo::operator!=(const OTodo &toDoEvent )const { 268inline bool OTodo::operator!=(const OTodo &toDoEvent )const {
242 return !(*this == toDoEvent); 269 return !(*this == toDoEvent);
243} 270}
244 271
245 272
246#endif 273#endif
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
@@ -16,66 +16,71 @@ OTodoAccess::OTodoAccess( OTodoAccessBackend* end )
16 if (end == 0l ) 16 if (end == 0l )
17 m_todoBackEnd = OBackendFactory<OTodoAccessBackend>::Default ("todo", QString::null); 17 m_todoBackEnd = OBackendFactory<OTodoAccessBackend>::Default ("todo", QString::null);
18 18
19 setBackEnd( m_todoBackEnd ); 19 setBackEnd( m_todoBackEnd );
20} 20}
21OTodoAccess::~OTodoAccess() { 21OTodoAccess::~OTodoAccess() {
22// qWarning("~OTodoAccess"); 22// qWarning("~OTodoAccess");
23} 23}
24void OTodoAccess::mergeWith( const QValueList<OTodo>& list ) { 24void OTodoAccess::mergeWith( const QValueList<OTodo>& list ) {
25 QValueList<OTodo>::ConstIterator it; 25 QValueList<OTodo>::ConstIterator it;
26 for ( it = list.begin(); it != list.end(); ++it ) { 26 for ( it = list.begin(); it != list.end(); ++it ) {
27 replace( (*it) ); 27 replace( (*it) );
28 } 28 }
29} 29}
30OTodoAccess::List OTodoAccess::effectiveToDos( const QDate& start, 30OTodoAccess::List OTodoAccess::effectiveToDos( const QDate& start,
31 const QDate& end, 31 const QDate& end,
32 bool includeNoDates ) { 32 bool includeNoDates ) {
33 QArray<int> ints = m_todoBackEnd->effectiveToDos( start, end, includeNoDates ); 33 QArray<int> ints = m_todoBackEnd->effectiveToDos( start, end, includeNoDates );
34 34
35 List lis( ints, this ); 35 List lis( ints, this );
36 return lis; 36 return lis;
37} 37}
38OTodoAccess::List OTodoAccess::effectiveToDos( const QDate& start, 38OTodoAccess::List OTodoAccess::effectiveToDos( const QDate& start,
39 bool includeNoDates ) { 39 bool includeNoDates ) {
40 return effectiveToDos( start, QDate::currentDate(), 40 return effectiveToDos( start, QDate::currentDate(),
41 includeNoDates ); 41 includeNoDates );
42} 42}
43OTodoAccess::List OTodoAccess::overDue() { 43OTodoAccess::List OTodoAccess::overDue() {
44 List lis( m_todoBackEnd->overDue(), this ); 44 List lis( m_todoBackEnd->overDue(), this );
45 return lis; 45 return lis;
46} 46}
47void OTodoAccess::addAlarm( const OTodo& event) { 47void OTodoAccess::addAlarm( const OTodo& event) {
48 if (!event.hasAlarmDateTime() ) 48/* FIXME use the new notifier architecture
49 if (!event.hasAlarmDateTime() )
49 return; 50 return;
50 51
51 QDateTime now = QDateTime::currentDateTime(); 52 QDateTime now = QDateTime::currentDateTime();
52 QDateTime schedule = event.alarmDateTime(); 53 QDateTime schedule = event.alarmDateTime();
53 54
54 if ( schedule > now ){ 55 if ( schedule > now ){
55 AlarmServer::addAlarm( schedule, 56 AlarmServer::addAlarm( schedule,
56 "QPE/Application/todolist", 57 "QPE/Application/todolist",
57 "alarm(QDateTime,int)", event.uid() ); 58 "alarm(QDateTime,int)", event.uid() );
58 59
59 } 60 }
61*/
60} 62}
61void OTodoAccess::delAlarm( int uid) { 63void OTodoAccess::delAlarm( int uid) {
62 64
63 QDateTime schedule; // Create null DateTime 65 QDateTime schedule; // Create null DateTime
64 66
65 // I hope this will remove all scheduled alarms 67 // I hope this will remove all scheduled alarms
66 // with the given uid !? 68 // with the given uid !?
67 // If not: I have to rethink how to remove already 69 // If not: I have to rethink how to remove already
68 // scheduled events... (se) 70 // scheduled events... (se)
69 // it should be fine -zecke 71 // it should be fine -zecke
70// qWarning("Removing alarm for event with uid %d", uid ); 72// qWarning("Removing alarm for event with uid %d", uid );
71 AlarmServer::deleteAlarm( schedule , 73 AlarmServer::deleteAlarm( schedule ,
72 "QPE/Application/todolist", 74 "QPE/Application/todolist",
73 "alarm(QDateTime,int)", uid ); 75 "alarm(QDateTime,int)", uid );
74} 76}
75/* sort order */ 77/* sort order */
76OTodoAccess::List OTodoAccess::sorted( bool ascending, int sort,int filter, int cat ) { 78OTodoAccess::List OTodoAccess::sorted( bool ascending, int sort,int filter, int cat ) {
77 QArray<int> ints = m_todoBackEnd->sorted( ascending, sort, 79 QArray<int> ints = m_todoBackEnd->sorted( ascending, sort,
78 filter, cat ); 80 filter, cat );
79 OTodoAccess::List list( ints, this ); 81 OTodoAccess::List list( ints, this );
80 return list; 82 return list;
81} 83}
84void OTodoAccess::removeAllCompleted() {
85 m_todoBackEnd->removeAllCompleted();
86}
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
@@ -39,55 +39,60 @@ public:
39 * includeNoDates whether or not to include 39 * includeNoDates whether or not to include
40 * events with no dates 40 * events with no dates
41 */ 41 */
42 List effectiveToDos( const QDate& start, 42 List effectiveToDos( const QDate& start,
43 const QDate& end, 43 const QDate& end,
44 bool includeNoDates = true ); 44 bool includeNoDates = true );
45 45
46 /** 46 /**
47 * start 47 * start
48 * end date taken from the currentDate() 48 * end date taken from the currentDate()
49 */ 49 */
50 List effectiveToDos( const QDate& start, 50 List effectiveToDos( const QDate& start,
51 bool includeNoDates = true ); 51 bool includeNoDates = true );
52 52
53 53
54 /** 54 /**
55 * return overdue OTodos 55 * return overdue OTodos
56 */ 56 */
57 List overDue(); 57 List overDue();
58 58
59 /** 59 /**
60 * 60 *
61 */ 61 */
62 List sorted( bool ascending, int sortOrder, int sortFilter, int cat ); 62 List sorted( bool ascending, int sortOrder, int sortFilter, int cat );
63 63
64 /** 64 /**
65 * merge a list of OTodos into 65 * merge a list of OTodos into
66 * the resource 66 * the resource
67 */ 67 */
68 void mergeWith( const QValueList<OTodo>& ); 68 void mergeWith( const QValueList<OTodo>& );
69 69
70 /** 70 /**
71 * delete all already completed items
72 */
73 void removeAllCompleted();
74
75signals:
76 /**
77 * if the OTodoAccess was changed
78 */
79 void signalChanged( const OTodoAccess* );
80private:
81 /**
71 * add an Alarm to the AlarmServer 82 * add an Alarm to the AlarmServer
72 */ 83 */
73 void addAlarm( const OTodo& ); 84 void addAlarm( const OTodo& );
74 85
75 /** 86 /**
76 * delete an alarm with the uid from 87 * delete an alarm with the uid from
77 * the alarm server 88 * the alarm server
78 */ 89 */
79 void delAlarm( int uid ); 90 void delAlarm( int uid );
80 91
81signals:
82 /**
83 * if the OTodoAccess was changed
84 */
85 void signalChanged( const OTodoAccess* );
86private:
87 int m_cat; 92 int m_cat;
88 OTodoAccessBackend* m_todoBackEnd; 93 OTodoAccessBackend* m_todoBackEnd;
89 class OTodoAccessPrivate; 94 class OTodoAccessPrivate;
90 OTodoAccessPrivate* d; 95 OTodoAccessPrivate* d;
91}; 96};
92 97
93#endif 98#endif
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
@@ -1,20 +1,21 @@
1#ifndef OPIE_TODO_ACCESS_BACKEND_H 1#ifndef OPIE_TODO_ACCESS_BACKEND_H
2#define OPIE_TODO_ACCESS_BACKEND_H 2#define OPIE_TODO_ACCESS_BACKEND_H
3 3
4#include "otodo.h" 4#include "otodo.h"
5#include "opimaccessbackend.h" 5#include "opimaccessbackend.h"
6 6
7class OTodoAccessBackend : public OPimAccessBackend<OTodo> { 7class OTodoAccessBackend : public OPimAccessBackend<OTodo> {
8public: 8public:
9 OTodoAccessBackend(); 9 OTodoAccessBackend();
10 ~OTodoAccessBackend(); 10 ~OTodoAccessBackend();
11 virtual QArray<int> effectiveToDos( const QDate& start, 11 virtual QArray<int> effectiveToDos( const QDate& start,
12 const QDate& end, 12 const QDate& end,
13 bool includeNoDates ) = 0; 13 bool includeNoDates ) = 0;
14 virtual QArray<int> overDue() = 0; 14 virtual QArray<int> overDue() = 0;
15 virtual QArray<int> sorted( bool asc, int sortOrder, int sortFilter, 15 virtual QArray<int> sorted( bool asc, int sortOrder, int sortFilter,
16 int cat ) = 0; 16 int cat ) = 0;
17 virtual void removeAllCompleted() = 0;
17 18
18}; 19};
19 20
20#endif 21#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
@@ -125,64 +125,70 @@ bool OTodoAccessVCal::save() {
125 if (!file.open(IO_WriteOnly ) ) 125 if (!file.open(IO_WriteOnly ) )
126 return false; 126 return false;
127 127
128 VObject *obj; 128 VObject *obj;
129 obj = newVObject( VCCalProp ); 129 obj = newVObject( VCCalProp );
130 addPropValue( obj, VCVersionProp, "1.0" ); 130 addPropValue( obj, VCVersionProp, "1.0" );
131 VObject *vo; 131 VObject *vo;
132 for(QMap<int, OTodo>::ConstIterator it=m_map.begin(); it !=m_map.end(); ++it ){ 132 for(QMap<int, OTodo>::ConstIterator it=m_map.begin(); it !=m_map.end(); ++it ){
133 vo = vobjByEvent( it.data() ); 133 vo = vobjByEvent( it.data() );
134 addVObjectProp(obj, vo ); 134 addVObjectProp(obj, vo );
135 } 135 }
136 writeVObject( file.directHandle(), obj ); 136 writeVObject( file.directHandle(), obj );
137 cleanVObject( obj ); 137 cleanVObject( obj );
138 cleanStrTbl(); 138 cleanStrTbl();
139 139
140 m_dirty = false; 140 m_dirty = false;
141 return true; 141 return true;
142} 142}
143void OTodoAccessVCal::clear() { 143void OTodoAccessVCal::clear() {
144 m_map.clear(); 144 m_map.clear();
145 m_dirty = true; 145 m_dirty = true;
146} 146}
147bool OTodoAccessVCal::add( const OTodo& to ) { 147bool OTodoAccessVCal::add( const OTodo& to ) {
148 m_map.insert( to.uid(), to ); 148 m_map.insert( to.uid(), to );
149 m_dirty = true; 149 m_dirty = true;
150 return true; 150 return true;
151} 151}
152bool OTodoAccessVCal::remove( int uid ) { 152bool OTodoAccessVCal::remove( int uid ) {
153 m_map.remove( uid ); 153 m_map.remove( uid );
154 m_dirty = true; 154 m_dirty = true;
155 return true; 155 return true;
156} 156}
157void OTodoAccessVCal::removeAllCompleted() {
158 for ( QMap<int, OTodo>::Iterator it = m_map.begin(); it != m_map.end(); ++it ) {
159 if ( (*it).isCompleted() )
160 m_map.remove( it );
161 }
162}
157bool OTodoAccessVCal::replace( const OTodo& to ) { 163bool OTodoAccessVCal::replace( const OTodo& to ) {
158 m_map.replace( to.uid(), to ); 164 m_map.replace( to.uid(), to );
159 m_dirty = true; 165 m_dirty = true;
160 return true; 166 return true;
161} 167}
162OTodo OTodoAccessVCal::find(int uid )const { 168OTodo OTodoAccessVCal::find(int uid )const {
163 return m_map[uid]; 169 return m_map[uid];
164} 170}
165QArray<int> OTodoAccessVCal::sorted( bool, int, int, int ) { 171QArray<int> OTodoAccessVCal::sorted( bool, int, int, int ) {
166 QArray<int> ar(0); 172 QArray<int> ar(0);
167 return ar; 173 return ar;
168} 174}
169QArray<int> OTodoAccessVCal::allRecords()const { 175QArray<int> OTodoAccessVCal::allRecords()const {
170 QArray<int> ar( m_map.count() ); 176 QArray<int> ar( m_map.count() );
171 QMap<int, OTodo>::ConstIterator it; 177 QMap<int, OTodo>::ConstIterator it;
172 int i = 0; 178 int i = 0;
173 for ( it = m_map.begin(); it != m_map.end(); ++it ) { 179 for ( it = m_map.begin(); it != m_map.end(); ++it ) {
174 ar[i] = it.key(); 180 ar[i] = it.key();
175 i++; 181 i++;
176 } 182 }
177 return ar; 183 return ar;
178} 184}
179QArray<int> OTodoAccessVCal::queryByExample( const OTodo&, int ) { 185QArray<int> OTodoAccessVCal::queryByExample( const OTodo&, int ) {
180 QArray<int> ar(0); 186 QArray<int> ar(0);
181 return ar; 187 return ar;
182} 188}
183QArray<int> OTodoAccessVCal::effectiveToDos( const QDate& , 189QArray<int> OTodoAccessVCal::effectiveToDos( const QDate& ,
184 const QDate& , 190 const QDate& ,
185 bool ) { 191 bool ) {
186 QArray<int> ar(0); 192 QArray<int> ar(0);
187 return ar; 193 return ar;
188} 194}
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
@@ -1,35 +1,37 @@
1#ifndef OPIE_OTODO_ACCESS_VCAL_H 1#ifndef OPIE_OTODO_ACCESS_VCAL_H
2#define OPIE_OTODO_ACCESS_VCAL_H 2#define OPIE_OTODO_ACCESS_VCAL_H
3 3
4#include "otodoaccessbackend.h" 4#include "otodoaccessbackend.h"
5 5
6class OTodoAccessVCal : public OTodoAccessBackend { 6class OTodoAccessVCal : public OTodoAccessBackend {
7public: 7public:
8 OTodoAccessVCal(const QString& ); 8 OTodoAccessVCal(const QString& );
9 ~OTodoAccessVCal(); 9 ~OTodoAccessVCal();
10 10
11 bool load(); 11 bool load();
12 bool reload(); 12 bool reload();
13 bool save(); 13 bool save();
14 14
15 QArray<int> allRecords()const; 15 QArray<int> allRecords()const;
16 QArray<int> queryByExample( const OTodo& t, int sort ); 16 QArray<int> queryByExample( const OTodo& t, int sort );
17 QArray<int> effectiveToDos( const QDate& start, 17 QArray<int> effectiveToDos( const QDate& start,
18 const QDate& end, 18 const QDate& end,
19 bool includeNoDates ); 19 bool includeNoDates );
20 QArray<int> overDue(); 20 QArray<int> overDue();
21 QArray<int> sorted( bool asc, int sortOrder, int sortFilter, 21 QArray<int> sorted( bool asc, int sortOrder, int sortFilter,
22 int cat ); 22 int cat );
23 OTodo find(int uid)const; 23 OTodo find(int uid)const;
24 void clear(); 24 void clear();
25 bool add( const OTodo& ); 25 bool add( const OTodo& );
26 bool remove( int uid ); 26 bool remove( int uid );
27 bool replace( const OTodo& ); 27 bool replace( const OTodo& );
28 28
29 void removeAllCompleted();
30
29private: 31private:
30 bool m_dirty : 1; 32 bool m_dirty : 1;
31 QString m_file; 33 QString m_file;
32 QMap<int, OTodo> m_map; 34 QMap<int, OTodo> m_map;
33}; 35};
34 36
35#endif 37#endif
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
@@ -1,82 +1,86 @@
1#include <qfile.h> 1#include <qfile.h>
2#include <qvector.h> 2#include <qvector.h>
3 3
4#include <qpe/global.h> 4#include <qpe/global.h>
5#include <qpe/stringutil.h> 5#include <qpe/stringutil.h>
6#include <qpe/timeconversion.h> 6#include <qpe/timeconversion.h>
7 7
8#include <opie/xmltree.h> 8#include <opie/xmltree.h>
9 9
10#include "otodoaccessxml.h" 10#include "otodoaccessxml.h"
11 11
12OTodoAccessXML::OTodoAccessXML( const QString& appName, 12OTodoAccessXML::OTodoAccessXML( const QString& appName,
13 const QString& fileName ) 13 const QString& fileName )
14 : OTodoAccessBackend(), m_app( appName ), m_opened( false ), m_changed( false ) 14 : OTodoAccessBackend(), m_app( appName ), m_opened( false ), m_changed( false )
15{ 15{
16 if (!fileName.isEmpty() ) 16 if (!fileName.isEmpty() )
17 m_file = fileName; 17 m_file = fileName;
18 else 18 else
19 m_file = Global::applicationFileName( "todolist", "todolist.xml" ); 19 m_file = Global::applicationFileName( "todolist", "todolist.xml" );
20} 20}
21OTodoAccessXML::~OTodoAccessXML() { 21OTodoAccessXML::~OTodoAccessXML() {
22 22
23} 23}
24bool OTodoAccessXML::load() { 24bool OTodoAccessXML::load() {
25 m_opened = true; 25 m_opened = true;
26 m_changed = false; 26 m_changed = false;
27 /* initialize dict */ 27 /* initialize dict */
28 /* 28 /*
29 * UPDATE dict if you change anything!!! 29 * UPDATE dict if you change anything!!!
30 */ 30 */
31 QAsciiDict<int> dict(15); 31 QAsciiDict<int> dict(21);
32 dict.setAutoDelete( TRUE ); 32 dict.setAutoDelete( TRUE );
33 dict.insert("Categories" , new int(OTodo::Category) ); 33 dict.insert("Categories" , new int(OTodo::Category) );
34 dict.insert("Uid" , new int(OTodo::Uid) ); 34 dict.insert("Uid" , new int(OTodo::Uid) );
35 dict.insert("HasDate" , new int(OTodo::HasDate) ); 35 dict.insert("HasDate" , new int(OTodo::HasDate) );
36 dict.insert("Completed" , new int(OTodo::Completed) ); 36 dict.insert("Completed" , new int(OTodo::Completed) );
37 dict.insert("Description" , new int(OTodo::Description) ); 37 dict.insert("Description" , new int(OTodo::Description) );
38 dict.insert("Summary" , new int(OTodo::Summary) ); 38 dict.insert("Summary" , new int(OTodo::Summary) );
39 dict.insert("Priority" , new int(OTodo::Priority) ); 39 dict.insert("Priority" , new int(OTodo::Priority) );
40 dict.insert("DateDay" , new int(OTodo::DateDay) ); 40 dict.insert("DateDay" , new int(OTodo::DateDay) );
41 dict.insert("DateMonth" , new int(OTodo::DateMonth) ); 41 dict.insert("DateMonth" , new int(OTodo::DateMonth) );
42 dict.insert("DateYear" , new int(OTodo::DateYear) ); 42 dict.insert("DateYear" , new int(OTodo::DateYear) );
43 dict.insert("Progress" , new int(OTodo::Progress) ); 43 dict.insert("Progress" , new int(OTodo::Progress) );
44 dict.insert("Completed", new int(OTodo::Completed) ); 44 dict.insert("Completed", new int(OTodo::Completed) );
45 dict.insert("CrossReference", new int(OTodo::CrossReference) ); 45 dict.insert("CrossReference", new int(OTodo::CrossReference) );
46 dict.insert("HasAlarmDateTime",new int(OTodo::HasAlarmDateTime) ); 46 dict.insert("State", new int(OTodo::State) );
47 dict.insert("AlarmDateTime", new int(OTodo::AlarmDateTime) ); 47 dict.insert("Recurrence", new int(OTodo::Recurrence) );
48 dict.insert("Alarms", new int(OTodo::Alarms) );
49 dict.insert("Reminders", new int(OTodo::Reminders) );
50 dict.insert("Notifiers", new int(OTodo::Notifiers) );
51 dict.insert("Maintainer", new int(OTodo::Maintainer) );
48 52
49 // here the custom XML parser from TT it's GPL 53 // here the custom XML parser from TT it's GPL
50 // but we want to push that to TT..... 54 // but we want to push OpiePIM... to TT.....
51 QFile f(m_file ); 55 QFile f(m_file );
52 if (!f.open(IO_ReadOnly) ) 56 if (!f.open(IO_ReadOnly) )
53 return false; 57 return false;
54 58
55 QByteArray ba = f.readAll(); 59 QByteArray ba = f.readAll();
56 f.close(); 60 f.close();
57 char* dt = ba.data(); 61 char* dt = ba.data();
58 int len = ba.size(); 62 int len = ba.size();
59 int i = 0; 63 int i = 0;
60 char *point; 64 char *point;
61 const char* collectionString = "<Task "; 65 const char* collectionString = "<Task ";
62 while ( dt+i != 0 && ( point = strstr( dt+i, collectionString ) ) != 0l ) { 66 while ( dt+i != 0 && ( point = strstr( dt+i, collectionString ) ) != 0l ) {
63 i = point -dt; 67 i = point -dt;
64 i+= strlen(collectionString); 68 i+= strlen(collectionString);
65 OTodo ev; 69 OTodo ev;
66 m_year = m_month = m_day = 0; 70 m_year = m_month = m_day = 0;
67 71
68 while ( TRUE ) { 72 while ( TRUE ) {
69 while ( i < len && (dt[i] == ' ' || dt[i] == '\n' || dt[i] == '\r') ) 73 while ( i < len && (dt[i] == ' ' || dt[i] == '\n' || dt[i] == '\r') )
70 ++i; 74 ++i;
71 if ( i >= len-2 || (dt[i] == '/' && dt[i+1] == '>') ) 75 if ( i >= len-2 || (dt[i] == '/' && dt[i+1] == '>') )
72 break; 76 break;
73 77
74 // we have another attribute, read it. 78 // we have another attribute, read it.
75 int j = i; 79 int j = i;
76 while ( j < len && dt[j] != '=' ) 80 while ( j < len && dt[j] != '=' )
77 ++j; 81 ++j;
78 QCString attr( dt+i, j-i+1); 82 QCString attr( dt+i, j-i+1);
79 83
80 i = ++j; // skip = 84 i = ++j; // skip =
81 85
82 // find the start of quotes 86 // find the start of quotes
@@ -307,112 +311,103 @@ void OTodoAccessXML::todo( QAsciiDict<int>* dict, OTodo& ev,
307 case OTodo::Priority: 311 case OTodo::Priority:
308 ev.setPriority( val.toInt() ); 312 ev.setPriority( val.toInt() );
309 break; 313 break;
310 case OTodo::DateDay: 314 case OTodo::DateDay:
311 m_day = val.toInt(); 315 m_day = val.toInt();
312 break; 316 break;
313 case OTodo::DateMonth: 317 case OTodo::DateMonth:
314 m_month = val.toInt(); 318 m_month = val.toInt();
315 break; 319 break;
316 case OTodo::DateYear: 320 case OTodo::DateYear:
317 m_year = val.toInt(); 321 m_year = val.toInt();
318 break; 322 break;
319 case OTodo::Progress: 323 case OTodo::Progress:
320 ev.setProgress( val.toInt() ); 324 ev.setProgress( val.toInt() );
321 break; 325 break;
322 case OTodo::CrossReference: 326 case OTodo::CrossReference:
323 { 327 {
324 /* 328 /*
325 * A cross refernce looks like 329 * A cross refernce looks like
326 * appname,id;appname,id 330 * appname,id;appname,id
327 * we need to split it up 331 * we need to split it up
328 */ 332 */
329 QStringList refs = QStringList::split(';', val ); 333 QStringList refs = QStringList::split(';', val );
330 QStringList::Iterator strIt; 334 QStringList::Iterator strIt;
331 for (strIt = refs.begin(); strIt != refs.end(); ++strIt ) { 335 for (strIt = refs.begin(); strIt != refs.end(); ++strIt ) {
332 int pos = (*strIt).find(','); 336 int pos = (*strIt).find(',');
333 if ( pos > -1 ) 337 if ( pos > -1 )
334 ; // ev.addRelation( (*strIt).left(pos), (*strIt).mid(pos+1).toInt() ); 338 ; // ev.addRelation( (*strIt).left(pos), (*strIt).mid(pos+1).toInt() );
335 339
336 } 340 }
337 break; 341 break;
338 } 342 }
339 case OTodo::HasAlarmDateTime:
340 ev.setHasAlarmDateTime( val.toInt() );
341 break;
342 case OTodo::AlarmDateTime: {
343 /* this sounds better ;) zecke */
344 ev.setAlarmDateTime( TimeConversion::fromISO8601( val.local8Bit() ) );
345 break;
346 }
347 default: 343 default:
348 break; 344 break;
349 } 345 }
350} 346}
351QString OTodoAccessXML::toString( const OTodo& ev )const { 347QString OTodoAccessXML::toString( const OTodo& ev )const {
352 QString str; 348 QString str;
353 349
354 str += "Completed=\"" + QString::number( ev.isCompleted() ) + "\" "; 350 str += "Completed=\"" + QString::number( ev.isCompleted() ) + "\" ";
355 str += "HasDate=\"" + QString::number( ev.hasDueDate() ) + "\" "; 351 str += "HasDate=\"" + QString::number( ev.hasDueDate() ) + "\" ";
356 str += "Priority=\"" + QString::number( ev.priority() ) + "\" "; 352 str += "Priority=\"" + QString::number( ev.priority() ) + "\" ";
357 str += "Progress=\"" + QString::number(ev.progress() ) + "\" "; 353 str += "Progress=\"" + QString::number(ev.progress() ) + "\" ";
358 354
359 str += "Categories=\"" + toString( ev.categories() ) + "\" "; 355 str += "Categories=\"" + toString( ev.categories() ) + "\" ";
360 str += "Description=\"" + Qtopia::escapeString( ev.description() ) + "\" "; 356 str += "Description=\"" + Qtopia::escapeString( ev.description() ) + "\" ";
361 str += "Summary=\"" + Qtopia::escapeString( ev.summary() ) + "\" "; 357 str += "Summary=\"" + Qtopia::escapeString( ev.summary() ) + "\" ";
362 358
363 if ( ev.hasDueDate() ) { 359 if ( ev.hasDueDate() ) {
364 str += "DateYear=\"" + QString::number( ev.dueDate().year() ) + "\" "; 360 str += "DateYear=\"" + QString::number( ev.dueDate().year() ) + "\" ";
365 str += "DateMonth=\"" + QString::number( ev.dueDate().month() ) + "\" "; 361 str += "DateMonth=\"" + QString::number( ev.dueDate().month() ) + "\" ";
366 str += "DateDay=\"" + QString::number( ev.dueDate().day() ) + "\" "; 362 str += "DateDay=\"" + QString::number( ev.dueDate().day() ) + "\" ";
367 } 363 }
368// qWarning( "Uid %d", ev.uid() ); 364// qWarning( "Uid %d", ev.uid() );
369 str += "Uid=\"" + QString::number( ev.uid() ) + "\" "; 365 str += "Uid=\"" + QString::number( ev.uid() ) + "\" ";
370 366
371// append the extra options 367// append the extra options
372 /* FIXME Qtopia::Record this is currently not 368 /* FIXME Qtopia::Record this is currently not
373 * possible you can set custom fields 369 * possible you can set custom fields
374 * but don' iterate over the list 370 * but don' iterate over the list
375 * I may do #define private protected 371 * I may do #define private protected
376 * for this case - cough --zecke 372 * for this case - cough --zecke
377 */ 373 */
378 /* 374 /*
379 QMap<QString, QString> extras = ev.extras(); 375 QMap<QString, QString> extras = ev.extras();
380 QMap<QString, QString>::Iterator extIt; 376 QMap<QString, QString>::Iterator extIt;
381 for (extIt = extras.begin(); extIt != extras.end(); ++extIt ) 377 for (extIt = extras.begin(); extIt != extras.end(); ++extIt )
382 str += extIt.key() + "=\"" + extIt.data() + "\" "; 378 str += extIt.key() + "=\"" + extIt.data() + "\" ";
383 */ 379 */
384 // cross refernce 380 // cross refernce
385 381
386 str += "AlarmDateTime=\"" + TimeConversion::toISO8601( ev.alarmDateTime() ) + "\" ";
387 382
388 return str; 383 return str;
389} 384}
390QString OTodoAccessXML::toString( const QArray<int>& ints ) const { 385QString OTodoAccessXML::toString( const QArray<int>& ints ) const {
391 return Qtopia::Record::idsToString( ints ); 386 return Qtopia::Record::idsToString( ints );
392} 387}
393 388
394/* internal class for sorting 389/* internal class for sorting
395 * 390 *
396 * Inspired by todoxmlio.cpp from TT 391 * Inspired by todoxmlio.cpp from TT
397 */ 392 */
398 393
399struct OTodoXMLContainer { 394struct OTodoXMLContainer {
400 OTodo todo; 395 OTodo todo;
401}; 396};
402 397
403namespace { 398namespace {
404 inline QString string( const OTodo& todo) { 399 inline QString string( const OTodo& todo) {
405 return todo.summary().isEmpty() ? 400 return todo.summary().isEmpty() ?
406 todo.description().left(20 ) : 401 todo.description().left(20 ) :
407 todo.summary(); 402 todo.summary();
408 } 403 }
409 inline int completed( const OTodo& todo1, const OTodo& todo2) { 404 inline int completed( const OTodo& todo1, const OTodo& todo2) {
410 int ret = 0; 405 int ret = 0;
411 if ( todo1.isCompleted() ) ret++; 406 if ( todo1.isCompleted() ) ret++;
412 if ( todo2.isCompleted() ) ret--; 407 if ( todo2.isCompleted() ) ret--;
413 return ret; 408 return ret;
414 } 409 }
415 inline int priority( const OTodo& t1, const OTodo& t2) { 410 inline int priority( const OTodo& t1, const OTodo& t2) {
416 return ( t1.priority() - t2.priority() ); 411 return ( t1.priority() - t2.priority() );
417 } 412 }
418 inline int description( const OTodo& t1, const OTodo& t2) { 413 inline int description( const OTodo& t1, const OTodo& t2) {
@@ -587,32 +582,38 @@ QArray<int> OTodoAccessXML::sorted( bool asc, int sortOrder,
587 qWarning("item is overdue but !bOnly"); 582 qWarning("item is overdue but !bOnly");
588 continue; 583 continue;
589 } 584 }
590*/ 585*/
591 if ( !(*it).isOverdue() && bOnly ) { 586 if ( !(*it).isOverdue() && bOnly ) {
592 qWarning("item is not overdue but bOnly checked"); 587 qWarning("item is not overdue but bOnly checked");
593 continue; 588 continue;
594 } 589 }
595 590
596 if ((*it).isCompleted() && comp ) { 591 if ((*it).isCompleted() && comp ) {
597 qWarning("completed continue!"); 592 qWarning("completed continue!");
598 continue; 593 continue;
599 } 594 }
600 595
601 596
602 OTodoXMLContainer* con = new OTodoXMLContainer(); 597 OTodoXMLContainer* con = new OTodoXMLContainer();
603 con->todo = (*it); 598 con->todo = (*it);
604 vector.insert(item, con ); 599 vector.insert(item, con );
605 item++; 600 item++;
606 } 601 }
607 qWarning("XXX %d Items added", item); 602 qWarning("XXX %d Items added", item);
608 vector.resize( item ); 603 vector.resize( item );
609 /* sort it now */ 604 /* sort it now */
610 vector.sort(); 605 vector.sort();
611 /* now get the uids */ 606 /* now get the uids */
612 QArray<int> array( vector.count() ); 607 QArray<int> array( vector.count() );
613 for (uint i= 0; i < vector.count(); i++ ) { 608 for (uint i= 0; i < vector.count(); i++ ) {
614 array[i] = ( vector.at(i) )->todo.uid(); 609 array[i] = ( vector.at(i) )->todo.uid();
615 } 610 }
616 qWarning("array count = %d %d", array.count(), vector.count() ); 611 qWarning("array count = %d %d", array.count(), vector.count() );
617 return array; 612 return array;
618}; 613};
614void OTodoAccessXML::removeAllCompleted() {
615 for ( QMap<int, OTodo>::Iterator it = m_events.begin(); it != m_events.end(); ++it ) {
616 if ( (*it).isCompleted() )
617 m_events.remove( it );
618 }
619}
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
@@ -1,56 +1,57 @@
1#ifndef OPIE_TODO_ACCESS_XML_H 1#ifndef OPIE_TODO_ACCESS_XML_H
2#define OPIE_TODO_ACCESS_XML_H 2#define OPIE_TODO_ACCESS_XML_H
3 3
4#include <qasciidict.h> 4#include <qasciidict.h>
5#include <qmap.h> 5#include <qmap.h>
6 6
7#include "otodoaccessbackend.h" 7#include "otodoaccessbackend.h"
8 8
9namespace Opie { 9namespace Opie {
10 class XMLElement; 10 class XMLElement;
11}; 11};
12 12
13class OTodoAccessXML : public OTodoAccessBackend { 13class OTodoAccessXML : public OTodoAccessBackend {
14public: 14public:
15 /** 15 /**
16 * fileName if Empty we will use the default path 16 * fileName if Empty we will use the default path
17 */ 17 */
18 OTodoAccessXML( const QString& appName, 18 OTodoAccessXML( const QString& appName,
19 const QString& fileName = QString::null ); 19 const QString& fileName = QString::null );
20 ~OTodoAccessXML(); 20 ~OTodoAccessXML();
21 21
22 bool load(); 22 bool load();
23 bool reload(); 23 bool reload();
24 bool save(); 24 bool save();
25 25
26 QArray<int> allRecords()const; 26 QArray<int> allRecords()const;
27 QArray<int> queryByExample( const OTodo&, int querysettings ); 27 QArray<int> queryByExample( const OTodo&, int querysettings );
28 OTodo find( int uid )const; 28 OTodo find( int uid )const;
29 void clear(); 29 void clear();
30 bool add( const OTodo& ); 30 bool add( const OTodo& );
31 bool remove( int uid ); 31 bool remove( int uid );
32 void removeAllCompleted();
32 bool replace( const OTodo& ); 33 bool replace( const OTodo& );
33 34
34 /* our functions */ 35 /* our functions */
35 QArray<int> effectiveToDos( const QDate& start, 36 QArray<int> effectiveToDos( const QDate& start,
36 const QDate& end, 37 const QDate& end,
37 bool includeNoDates ); 38 bool includeNoDates );
38 QArray<int> overDue(); 39 QArray<int> overDue();
39 QArray<int> sorted( bool asc, int sortOrder, 40 QArray<int> sorted( bool asc, int sortOrder,
40 int sortFilter, int cat ); 41 int sortFilter, int cat );
41private: 42private:
42 void todo( QAsciiDict<int>*, OTodo&,const QCString&,const QString& ); 43 void todo( QAsciiDict<int>*, OTodo&,const QCString&,const QString& );
43 QString toString( const OTodo& )const; 44 QString toString( const OTodo& )const;
44 QString toString( const QArray<int>& ints ) const; 45 QString toString( const QArray<int>& ints ) const;
45 QMap<int, OTodo> m_events; 46 QMap<int, OTodo> m_events;
46 QString m_file; 47 QString m_file;
47 QString m_app; 48 QString m_app;
48 bool m_opened : 1; 49 bool m_opened : 1;
49 bool m_changed : 1; 50 bool m_changed : 1;
50 class OTodoAccessXMLPrivate; 51 class OTodoAccessXMLPrivate;
51 OTodoAccessXMLPrivate* d; 52 OTodoAccessXMLPrivate* d;
52 int m_year, m_month, m_day; 53 int m_year, m_month, m_day;
53 54
54}; 55};
55 56
56#endif 57#endif