summaryrefslogtreecommitdiff
authorzecke <zecke>2004-11-18 21:45:49 (UTC)
committer zecke <zecke>2004-11-18 21:45:49 (UTC)
commit7484344ff5be1f7c54e51715776d0e3cadeb1ed0 (patch) (side-by-side diff)
tree96f427f7a1fb1c8ca0a6efbd72b51e916cb1651d
parent3302eb30390e6053637929316670da3e8fbe279e (diff)
downloadopie-7484344ff5be1f7c54e51715776d0e3cadeb1ed0.zip
opie-7484344ff5be1f7c54e51715776d0e3cadeb1ed0.tar.gz
opie-7484344ff5be1f7c54e51715776d0e3cadeb1ed0.tar.bz2
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
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--libopie2/opiepim/core/core.pro3
-rw-r--r--libopie2/opiepim/core/ocontactaccess.cpp7
-rw-r--r--libopie2/opiepim/core/ocontactaccess.h57
-rw-r--r--libopie2/opiepim/core/odatebookaccess.cpp35
-rw-r--r--libopie2/opiepim/core/odatebookaccess.h11
-rw-r--r--libopie2/opiepim/core/opimaccesstemplate.h351
-rw-r--r--libopie2/opiepim/core/opimcontact.cpp24
-rw-r--r--libopie2/opiepim/core/opimcontact.h4
-rw-r--r--libopie2/opiepim/core/opimevent.cpp19
-rw-r--r--libopie2/opiepim/core/opimevent.h24
-rw-r--r--libopie2/opiepim/core/opimglobal.h18
-rw-r--r--libopie2/opiepim/core/opimnotifymanager.cpp5
-rw-r--r--libopie2/opiepim/core/opimoccurrence.cpp319
-rw-r--r--libopie2/opiepim/core/opimoccurrence.h142
-rw-r--r--libopie2/opiepim/core/opimrecord.cpp23
-rw-r--r--libopie2/opiepim/core/opimrecord.h11
-rw-r--r--libopie2/opiepim/core/opimrecordlist.h17
-rw-r--r--libopie2/opiepim/core/opimresolver.h2
-rw-r--r--libopie2/opiepim/core/opimstate.h6
-rw-r--r--libopie2/opiepim/core/opimtemplatebase.cpp112
-rw-r--r--libopie2/opiepim/core/opimtemplatebase.h139
-rw-r--r--libopie2/opiepim/core/opimtimezone.cpp44
-rw-r--r--libopie2/opiepim/core/opimtodo.cpp127
-rw-r--r--libopie2/opiepim/core/opimtodo.h13
-rw-r--r--libopie2/opiepim/core/otodoaccess.cpp23
-rw-r--r--libopie2/opiepim/core/otodoaccess.h36
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
@@ -1,48 +1,51 @@
HEADERS += \
core/ocontactaccess.h \
core/odatebookaccess.h \
core/opimaccessfactory.h \
core/opimaccesstemplate.h \
core/opimcache.h \
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 \
core/opimxref.h \
core/opimxrefmanager.h \
core/opimxrefpartner.h \
core/otodoaccess.h
SOURCES += \
core/ocontactaccess.cpp \
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
@@ -49,49 +49,48 @@
#include <qasciidict.h>
#include <qdatetime.h>
#include <qfile.h>
#include <qregexp.h>
#include <qlist.h>
#include <qcopchannel_qws.h>
/* STD */
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
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 */
QCopChannel *dbchannel = new QCopChannel( "QPE/PIM", this );
connect( dbchannel, SIGNAL(received(const QCString&,const QByteArray&)),
this, SLOT(copMessage(const QCString&,const QByteArray&)) );
if ( autosync ){
QCopChannel *syncchannel = new QCopChannel( "QPE/Sync", this );
connect( syncchannel, SIGNAL(received(const QCString&,const QByteArray&)),
this, SLOT(copMessage(const QCString&,const QByteArray&)) );
}
}
OPimContactAccess::~OPimContactAccess ()
{
/* The user may forget to save the changed database, therefore try to
* do it for him..
*/
@@ -107,58 +106,58 @@ bool OPimContactAccess::save ()
* Therefore: Reload database and merge the data...
*/
if ( OPimAccessTemplate<OPimContact>::wasChangedExternally() )
reload();
bool status = OPimAccessTemplate<OPimContact>::save();
if ( !status ) return false;
/* Now tell everyone that new data is available.
*/
QCopEnvelope e( "QPE/PIM", "addressbookUpdated()" );
return true;
}
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
@@ -39,125 +39,118 @@
#include <qpe/qcopenvelope_qws.h>
#include <qvaluelist.h>
#include <qfileinfo.h>
#include <opie2/opimcontact.h>
#include <opie2/ocontactaccessbackend.h>
#include <opie2/opimaccesstemplate.h>
namespace Opie {
/**
* Class to access the contacts database.
* This is just a frontend for the real database handling which is
* done by the backend.
* This class is used to access the Contacts on a system. This class as any OPIE PIM
* class is backend independent.
* @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.
* @return <i>true</i> if the given settings are correct and possible.
*/
bool hasQuerySettings ( int querySettings ) const;
/**
* if the resource was changed externally.
* You should use the signal instead of polling possible changes !
*/
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;
Private *d;
};
}
#endif
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
@@ -18,101 +18,78 @@
_.=:. : :=>`: 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 <opie2/obackendfactory.h>
#include <opie2/odatebookaccess.h>
#include <opie2/opimresolver.h>
#include <opie2/opimglobal.h>
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 );
return lis;
}
/**
* @return all non repeating events
*/
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
@@ -28,54 +28,49 @@
*/
#ifndef OPIE_DATE_BOOK_ACCESS_H
#define OPIE_DATE_BOOK_ACCESS_H
#include "odatebookaccessbackend.h"
#include "opimaccesstemplate.h"
#include <opie2/opimevent.h>
namespace Opie {
/**
* This is the object orientated datebook database. It'll use OBackendFactory
* to query for a backend.
* All access to the datebook should be done via this class.
* Make sure to load and save the datebook this is not part of
* destructing and creating the object
*
* @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;
Private* d;
};
}
#endif
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,373 +1,522 @@
/*
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,
._= =} : 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_ACCESS_TEMPLATE_H
#define OPIE_PIM_ACCESS_TEMPLATE_H
/* OPIE */
#include <opie2/opimrecord.h>
#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 );
/**
* returns the backend
*/
BackEnd* backEnd();
BackEnd* m_backEnd;
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 ) {
/* same type */
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;
}
+/**
+ * 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 )
m_backEnd->setFrontend( this );
}
template <class T>
void OPimAccessTemplate<T>::cache( const T& t ) const{
/* hacky we need to work around the const*/
((OPimAccessTemplate<T>*)this)->m_cache.add( t );
}
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
@@ -60,49 +60,48 @@
namespace Opie
{
/*!
Creates a new, empty contact.
*/
OPimContact::OPimContact():OPimRecord(), mMap(), d( 0 )
{}
/*!
\internal
Creates a new contact. The properties of the contact are
set from \a fromMap.
*/
OPimContact::OPimContact( const QMap<int, QString> &fromMap ):OPimRecord(), mMap( fromMap ), d( 0 )
{
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() );
}
/*!
Destroys a contact.
*/
OPimContact::~OPimContact()
{}
/*! \fn void OPimContact::setTitle( const QString &str )
Sets the title of the contact to \a str.
*/
/*! \fn void OPimContact::setFirstName( const QString &str )
Sets the first name of the contact to \a str.
*/
/*! \fn void OPimContact::setMiddleName( const QString &str )
@@ -1117,99 +1116,95 @@ QString OPimContact::toShortText() const
QString OPimContact::type() const
{
return QString::fromLatin1( "OPimContact" );
}
class QString OPimContact::recordField( int pos ) const
{
QStringList SLFIELDS = fields(); // ?? why this ? (se)
return SLFIELDS[ pos ];
}
// In future releases, we should store birthday and anniversary
// internally as QDate instead of QString !
// QString is always too complicate to interprete (DD.MM.YY, DD/MM/YY, MM/DD/YY, etc..)(se)
/*! \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 ) );
}
/*! \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 )
{
//odebug << "insertEmail " << v << "" << oendl;
QString e = v.simplifyWhiteSpace();
QString def = defaultEmail();
// if no default, set it as the default email and don't insert
if ( def.isEmpty() )
{
setDefaultEmail( e ); // will insert into the list for us
return ;
}
// otherwise, insert assuming doesn't already exist
QString emailsStr = find( Qtopia::Emails );
if ( emailsStr.contains( e ) )
return ;
@@ -1261,31 +1256,50 @@ void OPimContact::setDefaultEmail( const QString &v )
{
QString e = v.simplifyWhiteSpace();
//odebug << "OPimContact::setDefaultEmail " << e << "" << oendl;
replace( Qtopia::DefaultEmail, e );
if ( !e.isEmpty() )
insertEmail( e );
}
void OPimContact::insertEmails( const QStringList &v )
{
for ( QStringList::ConstIterator it = v.begin(); it != v.end(); ++it )
insertEmail( *it );
}
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
@@ -207,49 +207,53 @@ class QPC_EXPORT OPimContact : public OPimRecord
QStringList childrenList() const;
// other
QString notes() const { return find( Qtopia::Notes ); }
QString groups() const { return find( Qtopia::Groups ); }
QStringList groupList() const;
QString toRichText() const;
QMap<int, QString> toMap() const;
QString field( int key ) const { return find( key ); }
void setUid( int i );
QString toShortText() const;
QString type() const;
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;
static QStringList fields();
void save( QString &buf ) const;
QString displayAddress( const QString &street,
const QString &city,
const QString &state,
const QString &zip,
const QString &country ) const;
QMap<int, QString> mMap;
OPimContactPrivate *d;
};
}
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
@@ -468,48 +468,67 @@ QString OPimEvent::toShortText() const
text += QString::number( startDateTime().time().minute() );
text += " - ";
text += description();
return text;
}
QString OPimEvent::type() const
{
return QString::fromLatin1( "OPimEvent" );
}
QString OPimEvent::recordField( int /*id */ ) const
{
return QString::null;
}
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
{
return true;
}
void OPimEvent::changeOrModify()
{
if ( data->count != 1 )
{
data->deref();
Data* d2 = new Data;
d2->description = data->description;
d2->location = data->location;
if ( data->manager )
d2->manager = new OPimNotifyManager( *data->manager );
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
@@ -97,119 +97,133 @@ class OPimEvent : public OPimRecord
FNote,
FTimeZone,
FRecParent,
FRecChildren,
};
/**
* Start with an Empty OPimEvent. UID == 0 means that it is empty
*/
OPimEvent( int uid = 0 );
/**
* copy c'tor
*/
OPimEvent( const OPimEvent& );
/**
* 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 &notifiers() 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 */
QDateTime startDateTime() const;
/** returns the start datetime in the current zone */
QDateTime startDateTimeInZone() const;
/** in current timezone */
void setEndDateTime( const QDateTime& );
/** in current timezone */
QDateTime endDateTime() const;
QDateTime endDateTimeInZone() const;
bool isMultipleDay() const;
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:
inline void changeOrModify();
void deref();
struct Data;
Data* data;
class Private;
Private* priv;
};
/**
* AN Event can span through multiple days. We split up a multiday eve
*/
class OEffectiveEvent
{
public:
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
@@ -8,57 +8,69 @@
.> <`_, > . <= 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 __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
};
};
}
}
#endif
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
@@ -143,108 +143,103 @@ void OPimNotifyManager::setReminders( const Reminders& rem )
* The idea is to check if the provider for our service
* is online
* if it is we will use QCOP
* if not the Factory to get the backend...
* Qtopia1.6 services would be kewl to have here....
*/
void OPimNotifyManager::registerNotify( const OPimNotify& )
{
}
/* FIXME!!! */
/**
* same as above...
* Also implement Url model
* have a MainWindow....
*/
void OPimNotifyManager::deregister( const OPimNotify& )
{
}
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
{
QString str;
OPimNotifyManager::Alarms alarms = m_al;
if ( !alarms.isEmpty() )
{
QStringList als;
OPimNotifyManager::Alarms::Iterator it = alarms.begin();
for ( ; it != alarms.end(); ++it )
{
/* only if time is valid */
if ( ( *it ).dateTime().isValid() )
{
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
{
QString str;
OPimNotifyManager::Reminders reminders = m_rem;
if ( !reminders.isEmpty() )
{
OPimNotifyManager::Reminders::Iterator it = reminders.begin();
QStringList records;
for ( ; it != reminders.end(); ++it )
{
records << QString::number( ( *it ).recordUid() );
}
str = records.join( ";" );
}
return str;
}
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 )
{
QStringList rems = QStringList::split( ";", str );
for ( QStringList::Iterator it = rems.begin(); it != rems.end(); ++it )
{
OPimReminder rem( ( *it ).toInt() );
add( rem );
}
}
}
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
@@ -79,73 +79,57 @@ QStringList OPimRecord::categoryNames( const QString& appname ) const
{
QStringList list;
QArray<int> cats = categories();
Categories catDB;
catDB.load( categoryFileName() );
for ( uint i = 0; i < cats.count(); i++ )
{
list << catDB.label( appname, cats[ i ] );
}
return list;
}
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 );
};
Qtopia::UidGen &OPimRecord::uidGen()
{
return m_uidGen;
}
OPimXRefManager &OPimRecord::xrefmanager()
{
return m_xrefman;
}
int OPimRecord::rtti() const
{
@@ -249,25 +233,32 @@ OPimXRefPartner OPimRecord::partner( QDataStream& stream )
void OPimRecord::setLastHitField( int lastHit ) const
{
m_lastHit = lastHit;
}
int OPimRecord::lastHitField() const
{
return m_lastHit;
}
QMap<QString, QString> OPimRecord::toExtraMap() const
{
return customMap;
}
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
@@ -11,77 +11,79 @@
- . .-<_> .<> 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 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 */
#include <qdatastream.h>
#include <qmap.h>
#include <qstring.h>
#include <qstringlist.h>
namespace Opie
{
/**
* This is the base class for
* all PIM Records
*
*/
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 );
/**
* copy operator
*/
OPimRecord &operator=( const OPimRecord& );
/**
* category names resolved
*/
QStringList categoryNames( const QString& appname ) const;
/**
* set category names they will be resolved
*/
void setCategoryNames( const QStringList& );
/**
* addCategoryName adds a name
@@ -117,52 +119,57 @@ class OPimRecord : public Qtopia::Record
{
setLastHitField( -1 );
return Qtopia::Record::match( QRegExp( regexp ) );
};
/**
* if implemented this function returns which item has been
* last hit by the match() function.
* or -1 if not implemented or no hit has occured
*/
int lastHitField() const;
/**
* converts the internal structure to a map
*/
virtual QMap<int, QString> toMap() const = 0;
// 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();
/**
* set the uid
*/
virtual void setUid( int uid );
/*
* used inside the Templates for casting
* REIMPLEMENT in your ....
*/
virtual int rtti() const;
/**
* some marshalling and de marshalling code
* saves the OPimRecord
* to and from a DataStream
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
@@ -20,48 +20,49 @@
++= -. .` .: 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 ORECORDLIST_H
#define ORECORDLIST_H
/* OPIE */
#include <opie2/opimtemplatebase.h>
#include <opie2/opimrecord.h>
//#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) );
*/
template <class T> class OPimRecordList;
template <class T = OPimRecord>
class OPimRecordListIterator
{
friend class OPimRecordList<T>;
public:
typedef OTemplateBase<T> Base;
/**
* The c'tor used internally from
* OPimRecordList
*/
OPimRecordListIterator( const QArray<int>, const Base* );
/**
@@ -99,145 +100,146 @@ class OPimRecordListIterator
*/
void setCurrent( uint cur );
private:
QArray<int> m_uids;
uint m_current;
const Base* m_temp;
bool m_end : 1;
T m_record;
bool m_direction : 1;
/* d pointer for future versions */
OPimRecordListIteratorPrivate *d;
};
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();
/**
* the end
*/
Iterator end();
/**
* the number of items in the list
*/
uint count() const;
T operator[] ( uint i );
int uidAt( uint i );
/**
* 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 */
template <class T>
OPimRecordListIterator<T>::OPimRecordListIterator()
{
m_current = 0;
m_temp = 0l;
m_end = true;
m_record = T();
/* forward */
m_direction = TRUE;
}
template <class T>
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;
}
template <class T>
OPimRecordListIterator<T> &OPimRecordListIterator<T>::operator=( const OPimRecordListIterator<T>& it )
{
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;
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;
}
template <class T>
OPimRecordListIterator<T> &OPimRecordListIterator<T>::operator++()
{
m_direction = true;
if ( m_current < m_uids.count() )
{
m_end = false;
++m_current;
}
else
m_end = true;
return *this;
@@ -378,26 +380,31 @@ template <class T>
bool OPimRecordList<T>::remove( int uid )
{
QArray<int> copy( m_ids.count() );
int counter = 0;
bool ret_val = false;
for ( uint i = 0; i < m_ids.count(); i++ )
{
if ( m_ids[ i ] != uid )
{
copy[ counter++ ] = m_ids[ i ];
}
else
ret_val = true;
}
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
@@ -24,50 +24,48 @@
-- :-=` 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 OPIMRESOLVER_H
#define OPIMRESOLVER_H
/* OPIE */
#include <opie2/opimtemplatebase.h>
/* QT */
#include <qstring.h>
#include <qvaluelist.h>
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
};
static OPimResolver* self();
/**
* return a record for a uid
* and an service
* You've THE OWNERSHIP NOW!
*/
OPimRecord *record( const QString& service, int uid );
/**
* return the QCopChannel for service
* When we will use Qtopia Services it will be used here
*/
QCString qcopChannel( enum BuiltIn& )const;
QCString qcopChannel( const QString& service )const;
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
@@ -17,54 +17,48 @@
=_ + =;=|` 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 OPIMSTATE_H
#define OPIMSTATE_H
/* QT */
#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,
Undefined
};
OPimState( int state = Undefined );
OPimState( const OPimState& );
~OPimState();
bool operator==( const OPimState& );
OPimState &operator=( const OPimState& );
void setState( int state);
int state()const;
private:
void deref();
inline void copyInternally();
struct Data;
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
@@ -11,120 +11,213 @@
- . .-<_> .<> 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 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
@@ -19,102 +19,116 @@
..}^=.= = ; 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 "opimtimezone.h"
/* OPIE */
#include <opie2/odebug.h>
/* 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;
}
}
namespace Opie
{
OPimTimeZone::OPimTimeZone( const ZoneName& zone )
: m_name( zone )
{}
OPimTimeZone::~OPimTimeZone()
{}
bool OPimTimeZone::isValid() const
{
return !m_name.isEmpty();
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
@@ -43,120 +43,116 @@
#include <qpe/categoryselect.h>
#include <qpe/stringutil.h>
/* QT */
#include <qobject.h>
#include <qshared.h>
namespace Opie
{
struct OPimTodo::OPimTodoData : public QShared
{
OPimTodoData() : QShared()
{
recur = 0;
state = 0;
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;
QMap<QString, QString> extra;
ushort prog;
OPimState *state;
OPimRecurrence *recur;
OPimMaintainer *maintainer;
QDate start;
QDate completed;
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;
data->sum = summary;
data->prog = progress;
data->desc = Qtopia::simplifyMultiLineSpace( description );
}
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;
data->sum = summary;
data->prog = progress;
data->desc = Qtopia::simplifyMultiLineSpace( description );
}
bool OPimTodo::match( const QRegExp &regExp ) const
{
if ( QString::number( data->priority ).find( regExp ) != -1 )
{
setLastHitField( Priority );
return true;
}
else if ( data->hasDate && data->date.toString().find( regExp ) != -1 )
{
setLastHitField( HasDate );
@@ -166,55 +162,75 @@ bool OPimTodo::match( const QRegExp &regExp ) const
{
setLastHitField( Description );
return true;
}
else if ( data->sum.find( regExp ) != -1 )
{
setLastHitField( Summary );
return true;
}
return false;
}
bool OPimTodo::isCompleted() const
{
return data->isCompleted;
}
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
{
return data->priority;
}
QString OPimTodo::summary() const
{
return data->sum;
}
ushort OPimTodo::progress() const
{
return data->prog;
}
@@ -287,49 +303,48 @@ bool OPimTodo::hasMaintainer() const
OPimMaintainer OPimTodo::maintainer() const
{
if ( !data->maintainer ) return OPimMaintainer();
return ( *data->maintainer );
}
void OPimTodo::setCompleted( bool completed )
{
changeOrModify();
data->isCompleted = completed;
}
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();
data->sum = sum;
}
void OPimTodo::setPriority( int prio )
{
changeOrModify();
data->priority = prio;
}
void OPimTodo::setDueDate( const QDate& date )
{
changeOrModify();
data->date = date;
}
@@ -359,49 +374,49 @@ void OPimTodo::setState( const OPimState& state )
}
void OPimTodo::setRecurrence( const OPimRecurrence& rec )
{
changeOrModify();
if ( data->recur )
( *data->recur ) = rec;
else
data->recur = new OPimRecurrence( rec );
}
void OPimTodo::setMaintainer( const OPimMaintainer& pim )
{
changeOrModify();
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 )
{
changeOrModify();
data->prog = progress;
}
QString OPimTodo::toShortText() const
{
return summary();
}
/*!
Returns a richt text string
*/
QString OPimTodo::toRichText() const
@@ -572,142 +587,224 @@ bool OPimTodo::operator>=( const OPimTodo &toDoEvent ) const
}
return true;
}
bool OPimTodo::operator==( const OPimTodo &toDoEvent ) const
{
if ( data->priority != toDoEvent.data->priority ) return false;
if ( data->priority != toDoEvent.data->prog ) return false;
if ( data->isCompleted != toDoEvent.data->isCompleted ) return false;
if ( data->hasDate != toDoEvent.data->hasDate ) return false;
if ( data->date != toDoEvent.data->date ) return false;
if ( data->sum != toDoEvent.data->sum ) return false;
if ( data->desc != toDoEvent.data->desc ) return false;
if ( data->maintainer != toDoEvent.data->maintainer )
return false;
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;
}
QMap<int, QString> OPimTodo::toMap() const
{
QMap<int, QString> map;
map.insert( Uid, QString::number( uid() ) );
map.insert( Category, idsToString( categories() ) );
map.insert( HasDate, QString::number( data->hasDate ) );
map.insert( Completed, QString::number( data->isCompleted ) );
map.insert( Description, data->desc );
map.insert( Summary, data->sum );
map.insert( Priority, QString::number( data->priority ) );
map.insert( DateDay, QString::number( data->date.day() ) );
map.insert( DateMonth, QString::number( data->date.month() ) );
map.insert( DateYear, QString::number( data->date.year() ) );
map.insert( Progress, QString::number( data->prog ) );
// map.insert( CrossReference, crossToString() );
/* FIXME!!! map.insert( State, );
map.insert( Recurrence, );
map.insert( Reminders, );
map.
*/
return map;
}
/**
* 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;
}
}
// WATCHOUT
/*
* if you add something to the Data struct
* be sure to copy it here
*/
void OPimTodo::copy( OPimTodoData* src, OPimTodoData* dest )
{
dest->date = src->date;
dest->isCompleted = src->isCompleted;
dest->hasDate = src->hasDate;
dest->priority = src->priority;
dest->desc = src->desc;
dest->sum = src->sum;
dest->extra = src->extra;
dest->prog = src->prog;
if ( src->state )
dest->state = new OPimState( *src->state );
if ( src->recur )
dest->recur = new OPimRecurrence( *src->recur );
if ( src->maintainer )
dest->maintainer = new OPimMaintainer( *src->maintainer )
;
dest->start = src->start;
dest->completed = src->completed;
if ( src->notifiers )
dest->notifiers = new OPimNotifyManager( *src->notifiers );
}
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
@@ -49,53 +49,54 @@ namespace Opie
class OPimState;
class OPimRecurrence;
class OPimMaintainer;
class OPimNotifyManager;
class OPimTodo : public OPimRecord
{
public:
typedef QValueList<OPimTodo> ValueList;
enum RecordFields {
Uid = Qtopia::UID_ID,
Category = Qtopia::CATEGORY_ID,
HasDate,
Completed,
Description,
Summary,
Priority,
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
@param category Which category does it belong( uid )
@param summary A small summary of the todo
@param description What is this ToDoEvent about
@param hasDate Does this Event got a deadline
@param date what is the deadline?
@param uid what is the UUID of this Event
**/
OPimTodo( bool completed = false, int priority = Normal,
const QStringList &category = QStringList(),
const QString &summary = QString::null ,
const QString &description = QString::null,
ushort progress = 0,
bool hasDate = false, QDate date = QDate::currentDate(),
int uid = 0 /*empty*/ );
OPimTodo( bool completed, int priority,
@@ -261,60 +262,64 @@ class OPimTodo : public OPimRecord
*/
void setStartDate( const QDate& date );
/**
* set the completed date
*/
void setCompletedDate( const QDate& date );
void setRecurrence( const OPimRecurrence& );
void setDescription( const QString& );
void setSummary( const QString& );
/**
* set the state of a Todo
* @param state State what the todo should take
*/
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 );
OPimTodoPrivate *d;
OPimTodoData *data;
};
inline bool OPimTodo::operator!=( const OPimTodo &toDoEvent ) const
{
return !( *this == toDoEvent );
}
}
#endif
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
@@ -29,73 +29,60 @@
#include <qdatetime.h>
#include <qpe/alarmserver.h>
// #include "otodoaccesssql.h"
#include <opie2/otodoaccess.h>
#include <opie2/obackendfactory.h>
#include <opie2/opimresolver.h>
#include <opie2/opimglobal.h>
namespace Opie {
OPimTodoAccess::OPimTodoAccess( OPimTodoAccessBackend* end, enum Access )
: QObject(), OPimAccessTemplate<OPimTodo>( end ), m_todoBackEnd( end )
{
// if (end == 0l )
// m_todoBackEnd = new OPimTodoAccessBackendSQL( QString::null);
// 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
@@ -25,118 +25,94 @@
If not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#ifndef OPIE_TODO_ACCESS_H
#define OPIE_TODO_ACCESS_H
#include <qobject.h>
#include <qvaluelist.h>
#include <opie2/opimtodo.h>
#include <opie2/otodoaccessbackend.h>
#include <opie2/opimaccesstemplate.h>
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();
/* 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* );
void changed( const OPimTodoAccess*, int uid );
void added( const OPimTodoAccess*, int uid );
void removed( const OPimTodoAccess*, int uid );
private:
int m_cat;
OPimTodoAccessBackend* m_todoBackEnd;
class OPimTodoAccessPrivate;
OPimTodoAccessPrivate* d;
};
}
#endif