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