From 7484344ff5be1f7c54e51715776d0e3cadeb1ed0 Mon Sep 17 00:00:00 2001 From: zecke Date: Thu, 18 Nov 2004 21:45:49 +0000 Subject: Big PIM API Update Core Part (1/2 of what should be implemented): OPimRecords: -Add a so called safeCast using the rtti value OPimTodo: -Fix memleak with OPimState OPimOccurrence: -New class. Every 'Access' can give occurrences for a period of time Move Documentation --- 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 @@ -12,6 +12,7 @@ HEADERS += \ core/opimmaintainer.h \ core/opimnotify.h \ core/opimnotifymanager.h \ + core/opimoccurrence.h \ core/opimrecord.h \ core/opimrecordlist.h \ core/opimrecurrence.h \ @@ -35,10 +36,12 @@ SOURCES += \ 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 \ 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 @@ -70,7 +70,6 @@ OPimContactAccess::OPimContactAccess ( const QString appname, const QString , * will use the XML-Backend as default (until we have a cute SQL-Backend..). */ if( end == 0 ) { - owarn << "Using BackendFactory !" << oendl; end = OBackendFactory::defaultBackend( OPimGlobal::CONTACTLIST, appname ); } // Set backend locally and in template @@ -128,11 +127,14 @@ bool OPimContactAccess::hasQuerySettings ( int querySettings ) const { return ( m_backEnd->hasQuerySettings ( querySettings ) ); } + +#if 0 OPimRecordList OPimContactAccess::sorted( bool ascending, int sortOrder, int sortFilter, int cat ) const { QArray matchingContacts = m_backEnd -> sorted( ascending, sortOrder, sortFilter, cat ); return ( OPimRecordList(matchingContacts, this) ); } +#endif bool OPimContactAccess::wasChangedExternally()const @@ -144,13 +146,10 @@ bool OPimContactAccess::wasChangedExternally()const void OPimContactAccess::copMessage( const QCString &msg, const QByteArray & ) { if ( msg == "addressbookUpdated()" ){ - owarn << "OPimContactAccess: Received addressbokUpdated()" << oendl; emit signalChanged ( this ); } else if ( msg == "flush()" ) { - owarn << "OPimContactAccess: Received flush()" << oendl; save (); } else if ( msg == "reload()" ) { - owarn << "OPimContactAccess: Received reload()" << oendl; reload (); emit signalChanged ( this ); } diff --git a/libopie2/opiepim/core/ocontactaccess.h b/libopie2/opiepim/core/ocontactaccess.h index 4429b6f..691ece2 100644 --- a/libopie2/opiepim/core/ocontactaccess.h +++ b/libopie2/opiepim/core/ocontactaccess.h @@ -60,6 +60,26 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate 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 @@ -75,34 +95,9 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate * @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: query_IgnoreCase 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 @@ -126,9 +121,9 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate * 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; @@ -144,8 +139,6 @@ class OPimContactAccess: public QObject, public OPimAccessTemplate private: - // class OPimContactAccessPrivate; - // OPimContactAccessPrivate* d; OPimContactAccessBackend *m_backEnd; bool m_loading:1; 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 @@ -39,7 +39,7 @@ namespace Opie { * @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( back ) { if (!back ) @@ -51,15 +51,6 @@ ODateBookAccess::ODateBookAccess( ODateBookAccessBackend* back, enum Access ac ) ODateBookAccess::~ODateBookAccess() { } -/** - * @return all events available - */ -ODateBookAccess::List ODateBookAccess::rawEvents()const { - QArray ints = m_backEnd->rawEvents(); - - List lis( ints, this ); - return lis; -} /** * @return all repeating events @@ -82,34 +73,20 @@ ODateBookAccess::List ODateBookAccess::nonRepeats()const { } /** - * @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 @@ -49,9 +49,6 @@ public: ODateBookAccess( ODateBookAccessBackend* = 0l, enum Access acc = Random ); ~ODateBookAccess(); - /* return all events */ - List rawEvents()const; - /* return repeating events */ List rawRepeats()const; @@ -59,12 +56,10 @@ public: List nonRepeats()const; /* return non repeating events (from,to) */ - OEffectiveEvent::ValueList effectiveEvents( const QDate& from, const QDate& to ) const; - OEffectiveEvent::ValueList effectiveEvents( const QDateTime& start ) const; - OEffectiveEvent::ValueList effectiveNonRepeatingEvents( const QDate& from, const QDate& to ) const; - OEffectiveEvent::ValueList effectiveNonRepeatingEvents( const QDateTime& start ) const; + OPimOccurrence::List effectiveNonRepeatingEvents( const QDate& from, const QDate& to ) const; + OPimOccurrence::List effectiveNonRepeatingEvents( const QDateTime& start ) const; - /** + /** * Return identification of used records */ int rtti() const; diff --git a/libopie2/opiepim/core/opimaccesstemplate.h b/libopie2/opiepim/core/opimaccesstemplate.h index f936d4e..2deb92a 100644 --- a/libopie2/opiepim/core/opimaccesstemplate.h +++ b/libopie2/opiepim/core/opimaccesstemplate.h @@ -1,7 +1,7 @@ /* This file is part of the Opie Project Copyright (C) Holger Freyther - Copyright (C) Stefan Eilers + Copyright (C) Stefan Eilers =. Copyright (C) The Opie Team .=l. .>+-= @@ -40,6 +40,7 @@ /* QT */ #include +#include namespace Opie { @@ -56,6 +57,9 @@ class OPimAccessTemplatePrivate; template class OPimAccessTemplate : public OTemplateBase { public: + /** + * + */ enum Access { Random = 0, SortedAccess @@ -64,124 +68,72 @@ public: typedef OPimAccessBackend BackEnd; typedef OPimCache 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&, + uint current, typename OTemplateBase::CacheDirection dir = OTemplateBase::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& 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& cats )const; + //@} /** - * find the OPimRecord uid - */ - T find( int uid )const; - - /** - * read ahead cache find method ;) - */ - T find( int uid, const QArray&, - uint current, typename OTemplateBase::CacheDirection dir = OTemplateBase::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 true 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& )const; + UIDArray sortedSimple( bool ascending, int sortOrder, int sortFilter, + int cat )const; + UIDArray sortedSimple( bool ascending, int sortOrder, int sortFilter, + const QArray& )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 true if successful. - */ virtual bool remove( const T& t ); - - /** - * remove the OPimRecord with uid - * @param uid The ID of the item to remove - * @return true 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 true 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 records()const; + QArray records()const; protected: /** * invalidate the cache @@ -202,6 +154,10 @@ private: }; +/** + * c'tor BackEnd + * enum Access a small hint on how to handle the backend + */ template OPimAccessTemplate::OPimAccessTemplate( BackEnd* end ) : OTemplateBase(), m_backEnd( end ) @@ -211,39 +167,76 @@ OPimAccessTemplate::OPimAccessTemplate( BackEnd* end ) } template OPimAccessTemplate::~OPimAccessTemplate() { - owarn << "~OPimAccessTemplate" << oendl; delete m_backEnd; } + +/** + * load from the backend + */ template bool OPimAccessTemplate::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 bool OPimAccessTemplate::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 bool OPimAccessTemplate::save() { return m_backEnd->save(); } + + +/** + * return a List of records + * you can iterate over them + */ template typename OPimAccessTemplate::List OPimAccessTemplate::allRecords()const { QArray ints = m_backEnd->allRecords(); List lis(ints, this ); return lis; } + +/** + * return a List of records + * that match the regex + */ template typename OPimAccessTemplate::List OPimAccessTemplate::matchRegexp( const QRegExp &r )const { QArray ints = m_backEnd->matchRegexp( r ); List lis(ints, this ); return lis; } + +/** + * find the OPimRecord uid + */ template QArray OPimAccessTemplate::records()const { return m_backEnd->allRecords(); } + + +/** + * queryByExample. + * @see otodoaccess, ocontactaccess + */ template typename OPimAccessTemplate::List OPimAccessTemplate::queryByExample( const T& t, int settings, const QDateTime& d ) { @@ -252,8 +245,9 @@ OPimAccessTemplate::queryByExample( const T& t, int settings, const QDateTime List lis(ints, this ); return lis; } + template -T OPimAccessTemplate::find( int uid ) const{ +T OPimAccessTemplate::find( UID uid ) const{ // First search in cache.. if ( m_cache.contains( uid ) ) return m_cache.find( uid ); @@ -265,27 +259,46 @@ T OPimAccessTemplate::find( int uid ) const{ } template -T OPimAccessTemplate::find( int uid, const QArray& ar, +T OPimAccessTemplate::cacheFind( int uid ) const +{ + return m_cache.find( uid ); +} + +/** + * read ahead cache find method ;) + */ +template +T OPimAccessTemplate::find( UID uid, const QArray& ar, uint current, typename OTemplateBase::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 void OPimAccessTemplate::clear() { invalidateCache(); m_backEnd->clear(); } + + +/** + * add T to the backend + * @param t The item to add. + * @return true if added successfully. + */ template bool OPimAccessTemplate::add( const T& t ) { cache( t ); @@ -305,6 +318,12 @@ bool OPimAccessTemplate::add( const OPimRecord& rec ) { return false; } +/** + * Add an Opie PimRecord. + * Info: Take this if you are working with OPimRecords and you need to add it into any database. + * But take care that the accessing database is compatible to the real type of OPimRecord !! + * Otherwise this access will be rejected ! + */ template bool OPimAccessTemplate::add( const OPimRecord* rec) { /* same type, but pointer */ @@ -318,12 +337,23 @@ bool OPimAccessTemplate::add( const OPimRecord* rec) { return false; } +/** + * remove T from the backend + * @param t The item to remove + * @return true if successful. + */ template bool OPimAccessTemplate::remove( const T& t ) { return remove( t.uid() ); } + +/** + * remove the OPimRecord with uid + * @param uid The ID of the item to remove + * @return true if successful. + */ template -bool OPimAccessTemplate::remove( int uid ) { +bool OPimAccessTemplate::remove( UID uid ) { m_cache.remove( uid ); return m_backEnd->remove( uid ); } @@ -331,11 +361,21 @@ template bool OPimAccessTemplate::remove( const OPimRecord& rec) { return remove( rec.uid() ); } + +/** + * replace T from backend + * @param t The item to replace + * @return true if successful. + */ template bool OPimAccessTemplate::replace( const T& t ) { m_cache.replace( t ); return m_backEnd->replace( t ); } + +/** + * @internal + */ template void OPimAccessTemplate::invalidateCache() { m_cache.invalidate(); @@ -344,6 +384,12 @@ template typename OPimAccessTemplate::BackEnd* OPimAccessTemplate::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 bool OPimAccessTemplate::wasChangedExternally()const { return false; @@ -368,6 +414,109 @@ void OPimAccessTemplate::setReadAhead( uint count ) { m_backEnd->setReadAhead( count ); } + +template +typename OPimAccessTemplate::List OPimAccessTemplate::sorted( const OPimAccessTemplate::List& lst, + bool ascending, int sortOrder, + int sortFilter, int cat )const { + QArray cats( 1 ); + cats[0] = cat; + UIDArray ints = m_backEnd->sorted( lst.uids(), ascending, sortOrder, + sortFilter, cats ); + return List(ints, this); +} + +template +typename OPimAccessTemplate::List OPimAccessTemplate::sorted( const OPimAccessTemplate::List& lst, + bool ascending, int sortOrder, + int sortFilter, const QArray& cats )const { + UIDArray ints = m_backEnd->sorted( lst.uids(), ascending, sortOrder, + sortFilter, cats ); + return List(ints, this); +} + +template +typename OPimAccessTemplate::List OPimAccessTemplate::sorted( bool ascending, int sortOrder, + int sortFilter, int cat )const { + QArray cats( 1 ); + cats[0] = cat; + UIDArray ints = m_backEnd->sorted( ascending, sortOrder, + sortFilter, cats ); + return List(ints, this); +} + +template +typename OPimAccessTemplate::List OPimAccessTemplate::sorted( bool ascending, int sortOrder, + int sortFilter, const QArray& cats )const { + UIDArray ints = m_backEnd->sorted( ascending, sortOrder, + sortFilter, cats ); + return List(ints, this); +} + +template +OPimOccurrence::List OPimAccessTemplate::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 +OPimOccurrence::List OPimAccessTemplate::occurrences( const QDateTime& dt )const { + return OPimBase::convertOccurrenceFromBackend( m_backEnd->occurrences( dt ) ); +} + +/* + *Implementations!! + */ +template +UIDArray OPimAccessTemplate::matchRegexpSimple( const QRegExp &r )const { + return m_backEnd->matchRegexp( r ); +} + +template +UIDArray OPimAccessTemplate::queryByExampleSimple( const OPimRecord* rec, + int settings, + const QDateTime& d )const { + return m_backEnd->queryByExample( rec, settings, d ); +} + +template +UIDArray OPimAccessTemplate::sortedSimple( const UIDArray& lst, + bool ascending, + int sortOrder, int sortFilter, + int cat ) const{ + QArray cats( 1 ); + cats[0] = cat; + return m_backEnd->sorted( lst, ascending, sortOrder, sortFilter, cats ); +} + +template +UIDArray OPimAccessTemplate::sortedSimple( const UIDArray& lst, + bool ascending, + int sortOrder, int sortFilter, + const QArray& cats ) const{ + return m_backEnd->sorted( lst, ascending, sortOrder, sortFilter, cats ); +} + +template +UIDArray OPimAccessTemplate::sortedSimple( bool ascending, + int sortOrder, int sortFilter, + int cat ) const{ + QArray cats( 1 ); + cats[0] = cat; + + return m_backEnd->sorted( ascending, sortOrder, sortFilter, cats ); +} + +template +UIDArray OPimAccessTemplate::sortedSimple( bool ascending, + int sortOrder, int sortFilter, + const QArray& 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 @@ -81,7 +81,6 @@ OPimContact::OPimContact( const QMap &fromMap ):OPimRecord(), mMap if ( uidStr.isEmpty() || ( uidStr.toInt() == 0 ) ) { - owarn << "Invalid UID found. Generate new one.." << oendl; setUid( uidGen().generate() ); } else @@ -1138,7 +1137,6 @@ void OPimContact::setBirthday( const QDate &v ) { if ( v.isNull() ) { - owarn << "Remove Birthday" << oendl; replace( Qtopia::Birthday, QString::null ); return ; } @@ -1157,7 +1155,6 @@ void OPimContact::setAnniversary( const QDate &v ) { if ( v.isNull() ) { - owarn << "Remove Anniversary" << oendl; replace( Qtopia::Anniversary, QString::null ); return ; } @@ -1173,7 +1170,6 @@ void OPimContact::setAnniversary( const QDate &v ) QDate OPimContact::birthday() const { QString str = find( Qtopia::Birthday ); - // owarn << "Birthday " << str << oendl; if ( !str.isEmpty() ) return OPimDateConversion::dateFromString ( str ); else @@ -1188,7 +1184,6 @@ QDate OPimContact::anniversary() const { QDate empty; QString str = find( Qtopia::Anniversary ); - // owarn << "Anniversary " << str << oendl; if ( !str.isEmpty() ) return OPimDateConversion::dateFromString ( str ); else @@ -1282,6 +1277,25 @@ 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( const_cast(rec) ) : + 0l; +} + void OPimContact::setUid( int 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 @@ -228,7 +228,11 @@ class QPC_EXPORT OPimContact : public OPimRecord // the emails should be seperated by a comma void setEmails( const QString &v ); QString emails() const { return find( Qtopia::Emails ); } + + //@{ int rtti() const; + static OPimContact* safeCast( const OPimRecord* ); + //@} private: // The XML Backend needs some access to the private functions 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 @@ -489,6 +489,25 @@ 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( const_cast(rec) ) : + 0l; +} + + bool OPimEvent::loadFromStream( QDataStream& ) { 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 @@ -118,21 +118,29 @@ class OPimEvent : public OPimRecord ~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; @@ -161,13 +169,13 @@ class OPimEvent : public OPimRecord QString timeZone() const; - virtual bool match( const QRegExp& ) const; - + //@{ /** For exception to recurrence here is a list of children... */ QArray children() const; void setChildren( const QArray& ); void addChild( int uid ); void removeChild( int uid ); + //@} /** return the parent OPimEvent */ int parent() const; @@ -175,6 +183,8 @@ class OPimEvent : public OPimRecord /* needed reimp */ + //@{ Reimplementations + virtual bool match( const QRegExp& ) const; QString toRichText() const; QString toShortText() const; QString type() const; @@ -183,12 +193,16 @@ class OPimEvent : public OPimRecord void fromMap( const QMap& 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& ); 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 @@ -29,12 +29,24 @@ #ifndef __OPIMGLOBAL_H_ #define __OPIMGLOBAL_H_ +#include + 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 UIDArray; + namespace Pim{ - /** - * Contains global types and enums for the PIM-API + /** + * Contains global types and enums for the PIM-API */ class OPimGlobal{ public: @@ -44,7 +56,7 @@ class OPimGlobal{ DATEBOOK, _END_PimType }; - + enum DatabaseStyle { DEFAULT, // Use default Database UNKNOWN, // Unknown database style 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 @@ -164,7 +164,6 @@ 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; } @@ -192,7 +191,6 @@ QString OPimNotifyManager::alarmsToString() const } } // now write the list - owarn << "als: " << als.join( "____________" ) << "" << oendl; str = als.join( ";" ); } @@ -226,9 +224,6 @@ void OPimNotifyManager::alarmsFromString( const QString& str ) for ( QStringList::Iterator it = als.begin(); it != als.end(); ++it ) { QStringList alarm = QStringList::split( ":", ( *it ), TRUE ); // allow empty - owarn << "alarm: " << alarm.join( "___" ) << "" << oendl; - owarn << "alarm[0]: " << alarm[ 0 ] << " " - << OPimDateConversion::dateTimeFromString( alarm[ 0 ] ).toString() << oendl; OPimAlarm al( alarm[ 2 ].toInt(), OPimDateConversion::dateTimeFromString( alarm[ 0 ] ), alarm[ 1 ].toInt() ); add( al ); diff --git a/libopie2/opiepim/core/opimoccurrence.cpp b/libopie2/opiepim/core/opimoccurrence.cpp new file mode 100644 index 0000000..14ab5cf --- a/dev/null +++ b/libopie2/opiepim/core/opimoccurrence.cpp @@ -0,0 +1,319 @@ +/* + This file is part of the Opie Project + Copyright (C) 2003, 2004 Holger Freyther + =. Copyright (C) The Opie Team + .=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_,=:_. -`: 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 +#include + + +/* QT */ +#include + + +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 OPimOccurrence::record()const { + if ( !data->record && data->backend ) + data->record = data->backend->record( data->uid ); + return data->record; +} + +template 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(); +} + +OPimTodo OPimOccurrence::toTodo()const { + return internalToRecord(); +} + +OPimContact OPimOccurrence::toContact()const { + return internalToRecord(); +} + +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 + =. Copyright (C) The Opie Team + .=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_,=:_. -`: 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 +#include +#include +#include +#include + +#include +#include + +namespace Opie { + +template 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 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 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 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 @@ -100,8 +100,6 @@ void OPimRecord::addCategoryName( const QString& ) { Categories catDB; catDB.load( categoryFileName() ); - - } @@ -111,20 +109,6 @@ bool OPimRecord::isEmpty() const } -/*QString OPimRecord::crossToString()const { - QString str; - QMap >::ConstIterator it; - for (it = m_relations.begin(); it != m_relations.end(); ++it ) { - QArray 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 ) { @@ -270,4 +254,11 @@ void OPimRecord::setExtraMap( const QMap& 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 @@ -32,6 +32,8 @@ /* OPIE */ #include +#include + /* * we need to get customMap which is private... */ @@ -60,7 +62,7 @@ class OPimRecord : public Qtopia::Record * uid of 0 isEmpty * uid of 1 will be assigned a new one */ - OPimRecord( int uid = 0 ); + OPimRecord( UID uid = 0 ); ~OPimRecord(); /** @@ -138,10 +140,15 @@ class OPimRecord : public Qtopia::Record QMap toExtraMap() const; void setExtraMap( const QMap& ); +//@{ /** * the name for a recordField */ - virtual QString recordField( int ) const = 0; + virtual QString recordField( int ) const = 0; +// virtual QArray recordAttributes()const = 0; +// virtual QMap recordAttributesTranslated() const = 0; +// QString recordAttributeTranslated(int field)const; +//@} /** * returns a reference of the 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 @@ -41,6 +41,7 @@ namespace Opie { +template class OPimAccessTemplate; class OPimRecordListIteratorPrivate; /** * Our List Iterator @@ -120,6 +121,7 @@ class OPimRecordListPrivate; template class OPimRecordList { + template friend class OPimAccessTemplate; public: typedef OTemplateBase Base; typedef OPimRecordListIterator Iterator; @@ -127,10 +129,9 @@ class OPimRecordList /** * c'tor */ - OPimRecordList () - {} + OPimRecordList (){} OPimRecordList( const QArray& ids, - const Base* ); + const Base* ); ~OPimRecordList(); /** @@ -160,6 +161,9 @@ class OPimRecordList ConstIterator begin()const; ConstIterator end()const; */ + protected: + UIDArray uids()const; + private: QArray m_ids; const Base* m_acc; @@ -190,7 +194,6 @@ OPimRecordListIterator::~OPimRecordListIterator() template OPimRecordListIterator::OPimRecordListIterator( const OPimRecordListIterator& it ) { - //owarn << "OPimRecordListIterator copy c'tor" << oendl; m_uids = it.m_uids; m_current = it.m_current; m_temp = it.m_temp; @@ -216,7 +219,6 @@ OPimRecordListIterator &OPimRecordListIterator::operator=( const OPimRecor template T OPimRecordListIterator::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 : @@ -399,5 +401,10 @@ bool OPimRecordList::remove( int uid ) return ret_val; } +template +UIDArray OPimRecordList::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 @@ -45,8 +45,6 @@ namespace Opie { * 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 { 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 @@ -38,12 +38,6 @@ namespace Opie { * 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: 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 + =. Copyright (C) The Opie Team + .=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_,=:_. -`: 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 +#include + +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(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 @@ -32,43 +32,120 @@ /* OPIE */ #include #include +#include +#include /* QT */ #include +#include 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 records()const = 0; - /* - * ADD editing here? - * -zecke + //@} + + //@{ + virtual QArray records()const = 0; + + /** Constants for query. + * Use this constants to set the query parameters. + * Note: query_IgnoreCase 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& 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& 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!!! @@ -77,13 +154,27 @@ class OTemplateBasePrivate; template 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; /** @@ -91,7 +182,9 @@ public: */ virtual T find( int uid, const QArray& items, uint current, CacheDirection dir = Forward )const = 0; + //@} + //@{ /** * Put element into Cache */ @@ -101,10 +194,10 @@ public: OPimRecord* record()const; OPimRecord* record(int uid )const; static T* rec(); + //@} - private: - OTemplateBasePrivate *d; + OTemplateBasePrivate *d; }; @@ -119,12 +212,12 @@ OPimRecord* OTemplateBase::record(int uid )const { T* t1 = new T(t2); return t1; -}; +} + template T* OTemplateBase::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 @@ -40,7 +40,28 @@ 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; @@ -49,16 +70,13 @@ QDateTime utcTime( time_t t ) 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!!" @@ -73,7 +91,7 @@ QDateTime utcTime( time_t t, const QString& zone ) } -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(); @@ -86,14 +104,10 @@ time_t to_Time_t( const QDateTime& utc, const QString& str ) 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!!" 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 @@ -64,6 +64,7 @@ struct OPimTodo::OPimTodoData : public QShared delete recur; delete maintainer; delete notifiers; + delete state; } QDate date; @@ -87,17 +88,14 @@ 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; } @@ -112,7 +110,6 @@ OPimTodo::OPimTodo( bool completed, int priority, bool hasDate, QDate date, int uid ) : OPimRecord( uid ) { - // owarn << "OPimTodoData " + summary << oendl; setCategories( category ); data = new OPimTodoData; @@ -135,7 +132,6 @@ OPimTodo::OPimTodo( bool completed, int priority, bool hasDate, QDate date, int uid ) : OPimRecord( uid ) { - // owarn << "OPimTodoData" + summary << oendl; setCategories( idsFromString( category.join( ";" ) ) ); data = new OPimTodoData; @@ -187,13 +183,33 @@ 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(); @@ -308,7 +324,6 @@ void OPimTodo::setHasDueDate( bool hasDate ) void OPimTodo::setDescription( const QString &desc ) { - // owarn << "desc " + desc << oendl; changeOrModify(); data->desc = Qtopia::simplifyMultiLineSpace( desc ); } @@ -380,7 +395,7 @@ void OPimTodo::setMaintainer( const OPimMaintainer& pim ) } -bool OPimTodo::isOverdue( ) +bool OPimTodo::isOverdue( )const { if ( data->hasDate && !data->isCompleted ) return QDate::currentDate() > data->date; @@ -593,10 +608,8 @@ bool OPimTodo::operator==( const OPimTodo &toDoEvent ) const void OPimTodo::deref() { - // owarn << "deref in ToDoEvent" << oendl; if ( data->deref() ) { - // owarn << "deleting" << oendl; delete data; data = 0; } @@ -608,7 +621,6 @@ 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; @@ -651,7 +663,6 @@ void OPimTodo::changeOrModify() { if ( data->count != 1 ) { - owarn << "changeOrModify" << oendl; data->deref(); OPimTodoData* d2 = new OPimTodoData(); copy( data, d2 ); @@ -699,9 +710,78 @@ QString OPimTodo::type() const } -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; } @@ -710,4 +790,21 @@ 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( const_cast(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 @@ -70,11 +70,12 @@ class OPimTodo : public OPimRecord State, Recurrence, Alarms, - Reminders, - Notifiers, + Reminders, Maintainer, StartDate, - CompletedDate + CompletedDate, +//ADDITIONAL FOR RECORDFIELD + DueDate, }; public: // priorities from Very low to very high @@ -282,7 +283,7 @@ class OPimTodo : public OPimRecord */ void setMaintainer( const OPimMaintainer& ); - bool isOverdue(); + bool isOverdue()const; virtual bool match( const QRegExp &r ) const; @@ -295,7 +296,11 @@ class OPimTodo : public OPimRecord bool operator==( const OPimTodo &toDoEvent ) const; OPimTodo &operator=( const OPimTodo &toDoEvent ); + //@{ int rtti() const; + static OPimTodo* safeCast( const OPimRecord* ); + //@} + private: class OPimTodoPrivate; 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 @@ -50,8 +50,8 @@ OPimTodoAccess::OPimTodoAccess( OPimTodoAccessBackend* end, enum Access ) setBackEnd( m_todoBackEnd ); } OPimTodoAccess::~OPimTodoAccess() { -// owarn << "~OPimTodoAccess" << oendl; } + void OPimTodoAccess::mergeWith( const QValueList& list ) { QValueList::ConstIterator it; for ( it = list.begin(); it != list.end(); ++it ) { @@ -60,38 +60,25 @@ void OPimTodoAccess::mergeWith( const QValueList& list ) { } OPimTodoAccess::List OPimTodoAccess::effectiveToDos( const QDate& start, const QDate& end, - bool includeNoDates ) { + bool includeNoDates )const { QArray 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 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 { 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 @@ -46,13 +46,11 @@ namespace Opie { class OPimTodoAccess : public QObject, public OPimAccessTemplate { 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 @@ -70,25 +68,20 @@ public: */ 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 @@ -102,23 +95,6 @@ public: void removeAllCompleted(); /** - * request information about what a backend supports. - * Supports in the sense of beeing able to store. - * This is related to the enum in OPimTodo - * - * @param backend Will be used in the future when we support multiple backend - */ - QBitArray backendSupport( const QString& backend = QString::null )const; - - /** - * see above but for a specefic attribute. This method was added for convience - * @param attr The attribute to be queried for - * @param backend Will be used in the future when we support multiple backends - */ - bool backendSupports( int attr, const QString& backend = QString::null )const; - - - /** * Return identification of used records */ int rtti() const; -- cgit v0.9.0.2