28 files changed, 5109 insertions, 204 deletions
diff --git a/libopie2/opiepim/core/core.pro b/libopie2/opiepim/core/core.pro index 0473622..597b1e8 100644 --- a/libopie2/opiepim/core/core.pro +++ b/libopie2/opiepim/core/core.pro @@ -1,4 +1,5 @@ -HEADERS += core/oconversion.h \ +HEADERS += \ + core/opimdateconversion.h \ core/opimcache.h \ core/opimmaintainer.h \ core/opimresolver.h \ @@ -6,16 +7,17 @@ HEADERS += core/oconversion.h \ core/opimxref.h \ core/opimxrefmanager.h \ core/opimxrefpartner.h \ - core/orecur.h \ - core/otemplatebase.h \ - core/otimezone.h + core/opimrecurrence.h \ + core/opimtemplatebase.h \ + core/opimtimezone.h -SOURCES += core/oconversion.cpp \ +SOURCES += \ + core/opimdateconversion.cpp \ core/opimmaintainer.cpp \ core/opimresolver.cpp \ core/opimstate.cpp \ core/opimxref.cpp \ core/opimxrefmanager.cpp \ core/opimxrefpartner.cpp \ - core/orecur.cpp \ - core/otimezone.cpp + core/opimrecurrence.cpp \ + core/opimtimezone.cpp diff --git a/libopie2/opiepim/core/ocontactaccess.cpp b/libopie2/opiepim/core/ocontactaccess.cpp index f67a40c..c12e138 100644 --- a/libopie2/opiepim/core/ocontactaccess.cpp +++ b/libopie2/opiepim/core/ocontactaccess.cpp @@ -55,20 +55,20 @@ namespace Opie { -OContactAccess::OContactAccess ( const QString appname, const QString , - OContactAccessBackend* end, bool autosync ): - OPimAccessTemplate<OContact>( end ) +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 ) { qWarning ("Using BackendFactory !"); - end = OBackendFactory<OContactAccessBackend>::Default( "contact", appname ); + end = OBackendFactory<OPimContactAccessBackend>::Default( "contact", appname ); } // Set backend locally and in template m_backEnd = end; - OPimAccessTemplate<OContact>::setBackEnd (end); + OPimAccessTemplate<OPimContact>::setBackEnd (end); /* Connect signal of external db change to function */ @@ -83,7 +83,7 @@ OContactAccess::OContactAccess ( const QString appname, const QString , } -OContactAccess::~OContactAccess () +OPimContactAccess::~OPimContactAccess () { /* The user may forget to save the changed database, therefore try to * do it for him.. @@ -93,16 +93,16 @@ OContactAccess::~OContactAccess () } -bool OContactAccess::save () +bool OPimContactAccess::save () { /* If the database was changed externally, we could not save the * Data. This will remove added items which is unacceptable ! * Therefore: Reload database and merge the data... */ - if ( OPimAccessTemplate<OContact>::wasChangedExternally() ) + if ( OPimAccessTemplate<OPimContact>::wasChangedExternally() ) reload(); - bool status = OPimAccessTemplate<OContact>::save(); + bool status = OPimAccessTemplate<OPimContact>::save(); if ( !status ) return false; /* Now tell everyone that new data is available. @@ -112,38 +112,38 @@ bool OContactAccess::save () return true; } -const uint OContactAccess::querySettings() +const uint OPimContactAccess::querySettings() { return ( m_backEnd->querySettings() ); } -bool OContactAccess::hasQuerySettings ( int querySettings ) const +bool OPimContactAccess::hasQuerySettings ( int querySettings ) const { return ( m_backEnd->hasQuerySettings ( querySettings ) ); } -ORecordList<OContact> OContactAccess::sorted( bool ascending, int sortOrder, int sortFilter, int cat ) const +OPimRecordList<OPimContact> OPimContactAccess::sorted( bool ascending, int sortOrder, int sortFilter, int cat ) const { QArray<int> matchingContacts = m_backEnd -> sorted( ascending, sortOrder, sortFilter, cat ); - return ( ORecordList<OContact>(matchingContacts, this) ); + return ( OPimRecordList<OPimContact>(matchingContacts, this) ); } -bool OContactAccess::wasChangedExternally()const +bool OPimContactAccess::wasChangedExternally()const { return ( m_backEnd->wasChangedExternally() ); } -void OContactAccess::copMessage( const QCString &msg, const QByteArray & ) +void OPimContactAccess::copMessage( const QCString &msg, const QByteArray & ) { if ( msg == "addressbookUpdated()" ){ - qWarning ("OContactAccess: Received addressbokUpdated()"); + qWarning ("OPimContactAccess: Received addressbokUpdated()"); emit signalChanged ( this ); } else if ( msg == "flush()" ) { - qWarning ("OContactAccess: Received flush()"); + qWarning ("OPimContactAccess: Received flush()"); save (); } else if ( msg == "reload()" ) { - qWarning ("OContactAccess: Received reload()"); + qWarning ("OPimContactAccess: Received reload()"); reload (); emit signalChanged ( this ); } diff --git a/libopie2/opiepim/core/ocontactaccess.h b/libopie2/opiepim/core/ocontactaccess.h index 505c87b..cf5333a 100644 --- a/libopie2/opiepim/core/ocontactaccess.h +++ b/libopie2/opiepim/core/ocontactaccess.h @@ -41,7 +41,7 @@ #include <qvaluelist.h> #include <qfileinfo.h> -#include <opie2/ocontact.h> +#include <opie2/opimcontact.h> #include <opie2/ocontactaccessbackend.h> #include <opie2/opimaccesstemplate.h> @@ -55,7 +55,7 @@ namespace Opie { * @author Stefan Eilers, Holger Freyther * @see OPimAccessTemplate */ -class OContactAccess: public QObject, public OPimAccessTemplate<OContact> +class OPimContactAccess: public QObject, public OPimAccessTemplate<OPimContact> { Q_OBJECT @@ -72,11 +72,11 @@ class OContactAccess: public QObject, public OPimAccessTemplate<OContact> * 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 OContactAccessBackend + * @see OPimContactAccessBackend */ - OContactAccess (const QString appname, const QString filename = 0l, - OContactAccessBackend* backend = 0l, bool handlesync = true); - ~OContactAccess (); + OPimContactAccess (const QString appname, const QString filename = 0l, + OPimContactAccessBackend* backend = 0l, bool handlesync = true); + ~OPimContactAccess (); /** Constants for query. * Use this constants to set the query parameters. @@ -135,13 +135,13 @@ class OContactAccess: public QObject, public OPimAccessTemplate<OContact> * is useful if an application has to handle multiple databases at the same time. * @see reload() */ - void signalChanged ( const OContactAccess *which ); + void signalChanged ( const OPimContactAccess *which ); private: - // class OContactAccessPrivate; - // OContactAccessPrivate* d; - OContactAccessBackend *m_backEnd; + // class OPimContactAccessPrivate; + // OPimContactAccessPrivate* d; + OPimContactAccessBackend *m_backEnd; bool m_loading:1; private slots: diff --git a/libopie2/opiepim/core/odatebookaccess.cpp b/libopie2/opiepim/core/odatebookaccess.cpp index 8c527f6..ac310c1 100644 --- a/libopie2/opiepim/core/odatebookaccess.cpp +++ b/libopie2/opiepim/core/odatebookaccess.cpp @@ -38,7 +38,7 @@ namespace Opie { * @param ac What kind of access is intended */ ODateBookAccess::ODateBookAccess( ODateBookAccessBackend* back, enum Access ac ) - : OPimAccessTemplate<OEvent>( back ) + : OPimAccessTemplate<OPimEvent>( back ) { if (!back ) back = OBackendFactory<ODateBookAccessBackend>::Default("datebook", QString::null ); diff --git a/libopie2/opiepim/core/odatebookaccess.h b/libopie2/opiepim/core/odatebookaccess.h index 38dc754..6c9290f 100644 --- a/libopie2/opiepim/core/odatebookaccess.h +++ b/libopie2/opiepim/core/odatebookaccess.h @@ -32,7 +32,7 @@ #include "odatebookaccessbackend.h" #include "opimaccesstemplate.h" -#include <opie2/oevent.h> +#include <opie2/opimevent.h> namespace Opie { /** @@ -44,7 +44,7 @@ namespace Opie { * * @author Holger Freyther, Stefan Eilers */ -class ODateBookAccess : public OPimAccessTemplate<OEvent> { +class ODateBookAccess : public OPimAccessTemplate<OPimEvent> { public: ODateBookAccess( ODateBookAccessBackend* = 0l, enum Access acc = Random ); ~ODateBookAccess(); diff --git a/libopie2/opiepim/core/opimaccesstemplate.h b/libopie2/opiepim/core/opimaccesstemplate.h index 5826cbc..f1bcc44 100644 --- a/libopie2/opiepim/core/opimaccesstemplate.h +++ b/libopie2/opiepim/core/opimaccesstemplate.h @@ -33,10 +33,10 @@ #include <opie2/opimrecord.h> #include <opie2/opimaccessbackend.h> -#include <opie2/orecordlist.h> +#include <opie2/opimrecordlist.h> #include <opie2/opimcache.h> -#include <opie2/otemplatebase.h> +#include <opie2/opimtemplatebase.h> namespace Opie { @@ -57,7 +57,7 @@ public: Random = 0, SortedAccess }; - typedef ORecordList<T> List; + typedef OPimRecordList<T> List; typedef OPimAccessBackend<T> BackEnd; typedef OPimCache<T> Cache; diff --git a/libopie2/opiepim/core/opimcontact.cpp b/libopie2/opiepim/core/opimcontact.cpp new file mode 100644 index 0000000..a5df597 --- a/dev/null +++ b/libopie2/opiepim/core/opimcontact.cpp @@ -0,0 +1,1293 @@ +/* + This file is part of the Opie Project + 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. +*/ + +#define QTOPIA_INTERNAL_CONTACT_MRE + +#include "opimcontact.h" + +/* OPIE */ +#include <opie2/opimresolver.h> +#include <opie2/opimdateconversion.h> +#include <qpe/stringutil.h> +#include <qpe/timestring.h> +#include <qpe/config.h> + +/* QT */ +#include <qobject.h> +#include <qregexp.h> +#include <qstylesheet.h> +#include <qfileinfo.h> +#include <qmap.h> + +/* STD */ +#include <stdio.h> + +/*! + \class Contact contact.h + \brief The Contact class holds the data of an address book entry. + + This data includes information the name of the person, contact + information, and business information such as deparment and job title. + + \ingroup qtopiaemb + \ingroup qtopiadesktop +*/ + + +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 ) ) + { + qWarning( "Invalid UID found. Generate new one.." ); + 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 ) + Sets the middle name of the contact to \a str. +*/ + +/*! \fn void OPimContact::setLastName( const QString &str ) + Sets the last name of the contact to \a str. +*/ + +/*! \fn void OPimContact::setSuffix( const QString &str ) + Sets the suffix of the contact to \a str. +*/ + +/*! \fn void OPimContact::setFileAs( const QString &str ) + Sets the contact to filed as \a str. +*/ + +/*! \fn void OPimContact::setDefaultEmail( const QString &str ) + Sets the default email of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomeStreet( const QString &str ) + Sets the home street address of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomeCity( const QString &str ) + Sets the home city of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomeState( const QString &str ) + Sets the home state of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomeZip( const QString &str ) + Sets the home zip code of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomeCountry( const QString &str ) + Sets the home country of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomePhone( const QString &str ) + Sets the home phone number of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomeFax( const QString &str ) + Sets the home fax number of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomeMobile( const QString &str ) + Sets the home mobile phone number of the contact to \a str. +*/ + +/*! \fn void OPimContact::setHomeWebpage( const QString &str ) + Sets the home webpage of the contact to \a str. +*/ + +/*! \fn void OPimContact::setCompany( const QString &str ) + Sets the company for contact to \a str. +*/ + +/*! \fn void OPimContact::setJobTitle( const QString &str ) + Sets the job title of the contact to \a str. +*/ + +/*! \fn void OPimContact::setDepartment( const QString &str ) + Sets the department for contact to \a str. +*/ + +/*! \fn void OPimContact::setOffice( const QString &str ) + Sets the office for contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessStreet( const QString &str ) + Sets the business street address of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessCity( const QString &str ) + Sets the business city of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessState( const QString &str ) + Sets the business state of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessZip( const QString &str ) + Sets the business zip code of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessCountry( const QString &str ) + Sets the business country of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessPhone( const QString &str ) + Sets the business phone number of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessFax( const QString &str ) + Sets the business fax number of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessMobile( const QString &str ) + Sets the business mobile phone number of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessPager( const QString &str ) + Sets the business pager number of the contact to \a str. +*/ + +/*! \fn void OPimContact::setBusinessWebpage( const QString &str ) + Sets the business webpage of the contact to \a str. +*/ + +/*! \fn void OPimContact::setProfession( const QString &str ) + Sets the profession of the contact to \a str. +*/ + +/*! \fn void OPimContact::setAssistant( const QString &str ) + Sets the assistant of the contact to \a str. +*/ + +/*! \fn void OPimContact::setManager( const QString &str ) + Sets the manager of the contact to \a str. +*/ + +/*! \fn void OPimContact::setSpouse( const QString &str ) + Sets the spouse of the contact to \a str. +*/ + +/*! \fn void OPimContact::setGender( const QString &str ) + Sets the gender of the contact to \a str. +*/ + +/*! \fn void OPimContact::setNickname( const QString &str ) + Sets the nickname of the contact to \a str. +*/ + +/*! \fn void OPimContact::setNotes( const QString &str ) + Sets the notes about the contact to \a str. +*/ + +/*! \fn QString OPimContact::title() const + Returns the title of the contact. +*/ + +/*! \fn QString OPimContact::firstName() const + Returns the first name of the contact. +*/ + +/*! \fn QString OPimContact::middleName() const + Returns the middle name of the contact. +*/ + +/*! \fn QString OPimContact::lastName() const + Returns the last name of the contact. +*/ + +/*! \fn QString OPimContact::suffix() const + Returns the suffix of the contact. +*/ + +/*! \fn QString OPimContact::fileAs() const + Returns the string the contact is filed as. +*/ + +/*! \fn QString OPimContact::defaultEmail() const + Returns the default email address of the contact. +*/ + +/*! \fn QString OPimContact::emails() const + Returns the list of email address for a contact separated by ';'s in a single + string. +*/ + +/*! \fn QString OPimContact::homeStreet() const + Returns the home street address of the contact. +*/ + +/*! \fn QString OPimContact::homeCity() const + Returns the home city of the contact. +*/ + +/*! \fn QString OPimContact::homeState() const + Returns the home state of the contact. +*/ + +/*! \fn QString OPimContact::homeZip() const + Returns the home zip of the contact. +*/ + +/*! \fn QString OPimContact::homeCountry() const + Returns the home country of the contact. +*/ + +/*! \fn QString OPimContact::homePhone() const + Returns the home phone number of the contact. +*/ + +/*! \fn QString OPimContact::homeFax() const + Returns the home fax number of the contact. +*/ + +/*! \fn QString OPimContact::homeMobile() const + Returns the home mobile number of the contact. +*/ + +/*! \fn QString OPimContact::homeWebpage() const + Returns the home webpage of the contact. +*/ + +/*! \fn QString OPimContact::company() const + Returns the company for the contact. +*/ + +/*! \fn QString OPimContact::department() const + Returns the department for the contact. +*/ + +/*! \fn QString OPimContact::office() const + Returns the office for the contact. +*/ + +/*! \fn QString OPimContact::jobTitle() const + Returns the job title of the contact. +*/ + +/*! \fn QString OPimContact::profession() const + Returns the profession of the contact. +*/ + +/*! \fn QString OPimContact::assistant() const + Returns the assistant of the contact. +*/ + +/*! \fn QString OPimContact::manager() const + Returns the manager of the contact. +*/ + +/*! \fn QString OPimContact::businessStreet() const + Returns the business street address of the contact. +*/ + +/*! \fn QString OPimContact::businessCity() const + Returns the business city of the contact. +*/ + +/*! \fn QString OPimContact::businessState() const + Returns the business state of the contact. +*/ + +/*! \fn QString OPimContact::businessZip() const + Returns the business zip of the contact. +*/ + +/*! \fn QString OPimContact::businessCountry() const + Returns the business country of the contact. +*/ + +/*! \fn QString OPimContact::businessPhone() const + Returns the business phone number of the contact. +*/ + +/*! \fn QString OPimContact::businessFax() const + Returns the business fax number of the contact. +*/ + +/*! \fn QString OPimContact::businessMobile() const + Returns the business mobile number of the contact. +*/ + +/*! \fn QString OPimContact::businessPager() const + Returns the business pager number of the contact. +*/ + +/*! \fn QString OPimContact::businessWebpage() const + Returns the business webpage of the contact. +*/ + +/*! \fn QString OPimContact::spouse() const + Returns the spouse of the contact. +*/ + +/*! \fn QString OPimContact::gender() const + Returns the gender of the contact. +*/ + +/*! \fn QString OPimContact::nickname() const + Returns the nickname of the contact. +*/ + +/*! \fn QString OPimContact::children() const + Returns the children of the contact. +*/ + +/*! \fn QString OPimContact::notes() const + Returns the notes relating to the the contact. +*/ + +/*! \fn QString OPimContact::groups() const + \internal + Returns the groups for the contact. +*/ + +/*! \fn QStringList OPimContact::groupList() const + \internal +*/ + +/*! \fn QString OPimContact::field(int) const + \internal +*/ + +/*! \fn void OPimContact::saveJournal( journal_action, const QString & = QString::null ) + \internal +*/ + +/*! \fn void OPimContact::setUid( int id ) + \internal + Sets the uid for this record to \a id. +*/ + +/*! \enum OPimContact::journal_action + \internal +*/ + +/*! + \internal +*/ +QMap<int, QString> OPimContact::toMap() const +{ + QMap<int, QString> map = mMap; + QString cats = idsToString( categories() ); + if ( !cats.isEmpty() ) + map.insert( Qtopia::AddressCategory, cats ); + return map; +} + +/*! + Returns a rich text formatted QString representing the contents the contact. +*/ +QString OPimContact::toRichText() const +{ + QString text; + QString value, comp, state; + QString str; + bool marker = false; + + Config cfg( "qpe" ); + cfg.setGroup( "Appearance" ); + int addressformat = cfg.readNumEntry( "AddressFormat", Zip_City_State ); + + // name, jobtitle and company + if ( !( value = fullName() ).isEmpty() ) + text += "<b><h3><img src=\"addressbook/AddressBook\"> " + Qtopia::escapeString( value ) + "</h3></b>"; + + if ( !( value = jobTitle() ).isEmpty() ) + text += Qtopia::escapeString( value ) + " "; + + comp = company(); + if ( !( value = department() ).isEmpty() ) + { + text += Qtopia::escapeString( value ); + if ( comp ) + text += ", " + Qtopia::escapeString( comp ); + } + else if ( comp ) + text += "<br>" + Qtopia::escapeString( comp ); + text += "<br><hr>"; + + // defailt email + QString defEmail = defaultEmail(); + if ( !defEmail.isEmpty() ) + { + text += "<b><img src=\"addressbook/email\"> " + QObject::tr( "Default Email: " ) + "</b>" + + Qtopia::escapeString( defEmail ); + marker = true; + } + + // business address + if ( !businessStreet().isEmpty() || !businessCity().isEmpty() || + !businessZip().isEmpty() || !businessCountry().isEmpty() ) + { + text += QObject::tr( "<br><b>Work Address:</b>" ); + marker = true; + } + + if ( !( value = businessStreet() ).isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( value ); + marker = true; + } + + switch ( addressformat ) + { + case Zip_City_State: + { // Zip_Code City, State + state = businessState(); + if ( !( value = businessZip() ).isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( value ) + " "; + marker = true; + + } + if ( !( value = businessCity() ).isEmpty() ) + { + marker = true; + if ( businessZip().isEmpty() && !businessStreet().isEmpty() ) + text += "<br>"; + text += Qtopia::escapeString( value ); + if ( state ) + text += ", " + Qtopia::escapeString( state ); + } + else if ( !state.isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( state ); + marker = true; + } + break; + } + case City_State_Zip: + { // City, State Zip_Code + state = businessState(); + if ( !( value = businessCity() ).isEmpty() ) + { + marker = true; + text += "<br>" + Qtopia::escapeString( value ); + if ( state ) + text += ", " + Qtopia::escapeString( state ); + } + else if ( !state.isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( state ); + marker = true; + } + if ( !( value = businessZip() ).isEmpty() ) + { + text += " " + Qtopia::escapeString( value ); + marker = true; + } + break; + } + } + + if ( !( value = businessCountry() ).isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( value ); + marker = true; + } + + // rest of Business data + str = office(); + if ( !str.isEmpty() ) + { + text += "<br><b>" + QObject::tr( "Office: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + str = businessWebpage(); + if ( !str.isEmpty() ) + { + text += "<br><b><img src=\"addressbook/webpagework\"> " + QObject::tr( "Business Web Page: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + str = businessPhone(); + if ( !str.isEmpty() ) + { + text += "<br><b><img src=\"addressbook/phonework\"> " + QObject::tr( "Business Phone: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + str = businessFax(); + if ( !str.isEmpty() ) + { + text += "<br><b><img src=\"addressbook/faxwork\"> " + QObject::tr( "Business Fax: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + str = businessMobile(); + if ( !str.isEmpty() ) + { + text += "<br><b><img src=\"addressbook/mobilework\"> " + QObject::tr( "Business Mobile: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + str = businessPager(); + if ( !str.isEmpty() ) + { + text += "<br><b>" + QObject::tr( "Business Pager: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + + // text += "<br>"; + + // home address + if ( !homeStreet().isEmpty() || !homeCity().isEmpty() || + !homeZip().isEmpty() || !homeCountry().isEmpty() ) + { + text += QObject::tr( "<br><b>Home Address:</b>" ); + marker = true; + } + + if ( !( value = homeStreet() ).isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( value ); + marker = true; + } + + switch ( addressformat ) + { + case Zip_City_State: + { // Zip_Code City, State + state = homeState(); + if ( !( value = homeZip() ).isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( value ) + " "; + marker = true; + } + if ( !( value = homeCity() ).isEmpty() ) + { + marker = true; + if ( homeZip().isEmpty() && !homeStreet().isEmpty() ) + text += "<br>"; + text += Qtopia::escapeString( value ); + if ( !state.isEmpty() ) + text += ", " + Qtopia::escapeString( state ); + } + else if ( !state.isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( state ); + marker = true; + } + break; + } + case City_State_Zip: + { // City, State Zip_Code + state = homeState(); + if ( !( value = homeCity() ).isEmpty() ) + { + marker = true; + text += "<br>" + Qtopia::escapeString( value ); + if ( state ) + text += ", " + Qtopia::escapeString( state ); + } + else if ( !state.isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( state ); + marker = true; + } + if ( !( value = homeZip() ).isEmpty() ) + { + text += " " + Qtopia::escapeString( value ); + marker = true; + } + break; + } + } + + if ( !( value = homeCountry() ).isEmpty() ) + { + text += "<br>" + Qtopia::escapeString( value ); + marker = true; + } + + // rest of Home data + str = homeWebpage(); + if ( !str.isEmpty() ) + { + text += "<br><b><img src=\"addressbook/webpagehome\"> " + QObject::tr( "Home Web Page: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + str = homePhone(); + if ( !str.isEmpty() ) + { + text += "<br><b><img src=\"addressbook/phonehome\"> " + QObject::tr( "Home Phone: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + str = homeFax(); + if ( !str.isEmpty() ) + { + text += "<br><b><img src=\"addressbook/faxhome\"> " + QObject::tr( "Home Fax: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + str = homeMobile(); + if ( !str.isEmpty() ) + { + text += "<br><b><img src=\"addressbook/mobilehome\"> " + QObject::tr( "Home Mobile: " ) + "</b>" + + Qtopia::escapeString( str ); + marker = true; + } + + if ( marker ) + text += "<br><hr>"; + + // the rest... + str = emails(); + if ( !str.isEmpty() && ( str != defEmail ) ) + text += "<br><b>" + QObject::tr( "All Emails: " ) + "</b>" + + Qtopia::escapeString( str ); + str = profession(); + if ( !str.isEmpty() ) + text += "<br><b>" + QObject::tr( "Profession: " ) + "</b>" + + Qtopia::escapeString( str ); + str = assistant(); + if ( !str.isEmpty() ) + text += "<br><b>" + QObject::tr( "Assistant: " ) + "</b>" + + Qtopia::escapeString( str ); + str = manager(); + if ( !str.isEmpty() ) + text += "<br><b>" + QObject::tr( "Manager: " ) + "</b>" + + Qtopia::escapeString( str ); + str = gender(); + if ( !str.isEmpty() && str.toInt() != 0 ) + { + text += "<br>"; + if ( str.toInt() == 1 ) + str = QObject::tr( "Male" ); + else if ( str.toInt() == 2 ) + str = QObject::tr( "Female" ); + text += "<b>" + QObject::tr( "Gender: " ) + "</b>" + str; + } + str = spouse(); + if ( !str.isEmpty() ) + text += "<br><b>" + QObject::tr( "Spouse: " ) + "</b>" + + Qtopia::escapeString( str ); + if ( birthday().isValid() ) + { + str = TimeString::numberDateString( birthday() ); + text += "<br><b>" + QObject::tr( "Birthday: " ) + "</b>" + + Qtopia::escapeString( str ); + } + if ( anniversary().isValid() ) + { + str = TimeString::numberDateString( anniversary() ); + text += "<br><b>" + QObject::tr( "Anniversary: " ) + "</b>" + + Qtopia::escapeString( str ); + } + str = children(); + if ( !str.isEmpty() ) + text += "<br><b>" + QObject::tr( "Children: " ) + "</b>" + + Qtopia::escapeString( str ); + + str = nickname(); + if ( !str.isEmpty() ) + text += "<br><b>" + QObject::tr( "Nickname: " ) + "</b>" + + Qtopia::escapeString( str ); + + // categories + if ( categoryNames( "Contacts" ).count() ) + { + text += "<br><b>" + QObject::tr( "Category:" ) + "</b> "; + text += categoryNames( "Contacts" ).join( ", " ); + } + + // notes last + if ( !( value = notes() ).isEmpty() ) + { + text += "<br><hr><b>" + QObject::tr( "Notes:" ) + "</b> "; + QRegExp reg( "\n" ); + + //QString tmp = Qtopia::escapeString(value); + QString tmp = QStyleSheet::convertFromPlainText( value ); + //tmp.replace( reg, "<br>" ); + text += "<br>" + tmp + "<br>"; + } + return text; +} + +/*! + \internal +*/ +void OPimContact::insert( int key, const QString &v ) +{ + QString value = v.stripWhiteSpace(); + if ( value.isEmpty() ) + mMap.remove( key ); + else + mMap.insert( key, value ); +} + +/*! + \internal +*/ +void OPimContact::replace( int key, const QString & v ) +{ + QString value = v.stripWhiteSpace(); + if ( value.isEmpty() ) + mMap.remove( key ); + else + mMap.replace( key, value ); +} + +/*! + \internal +*/ +QString OPimContact::find( int key ) const +{ + return mMap[ key ]; +} + +/*! + \internal +*/ +QString OPimContact::displayAddress( const QString &street, + const QString &city, + const QString &state, + const QString &zip, + const QString &country ) const +{ + QString s = street; + if ( !street.isEmpty() ) + s += "\n"; + s += city; + if ( !city.isEmpty() && !state.isEmpty() ) + s += ", "; + s += state; + if ( !state.isEmpty() && !zip.isEmpty() ) + s += " "; + s += zip; + if ( !country.isEmpty() && !s.isEmpty() ) + s += "\n"; + s += country; + return s; +} + +/*! + \internal +*/ +QString OPimContact::displayBusinessAddress() const +{ + return displayAddress( businessStreet(), businessCity(), + businessState(), businessZip(), + businessCountry() ); +} + +/*! + \internal +*/ +QString OPimContact::displayHomeAddress() const +{ + return displayAddress( homeStreet(), homeCity(), + homeState(), homeZip(), + homeCountry() ); +} + +/*! + Returns the full name of the contact +*/ +QString OPimContact::fullName() const +{ + QString title = find( Qtopia::Title ); + QString firstName = find( Qtopia::FirstName ); + QString middleName = find( Qtopia::MiddleName ); + QString lastName = find( Qtopia::LastName ); + QString suffix = find( Qtopia::Suffix ); + + QString name = title; + if ( !firstName.isEmpty() ) + { + if ( !name.isEmpty() ) + name += " "; + name += firstName; + } + if ( !middleName.isEmpty() ) + { + if ( !name.isEmpty() ) + name += " "; + name += middleName; + } + if ( !lastName.isEmpty() ) + { + if ( !name.isEmpty() ) + name += " "; + name += lastName; + } + if ( !suffix.isEmpty() ) + { + if ( !name.isEmpty() ) + name += " "; + name += suffix; + } + return name.simplifyWhiteSpace(); +} + +/*! + Returns a list of the names of the children of the contact. +*/ +QStringList OPimContact::childrenList() const +{ + return QStringList::split( " ", find( Qtopia::Children ) ); +} + +/*! \fn void OPimContact::insertEmail( const QString &email ) + + Insert \a email into the email list. Ensures \a email can only be added + once. If there is no default email address set, it sets it to the \a email. +*/ + +/*! \fn void OPimContact::removeEmail( const QString &email ) + + Removes the \a email from the email list. If the default email was \a email, + then the default email address is assigned to the first email in the + email list +*/ + +/*! \fn void OPimContact::clearEmails() + + Clears the email list. + */ + +/*! \fn void OPimContact::insertEmails( const QStringList &emailList ) + + Appends the \a emailList to the exiting email list + */ + +/*! + Returns a list of email addresses belonging to the contact, including + the default email address. +*/ +QStringList OPimContact::emailList() const +{ + QString emailStr = emails(); + + QStringList r; + if ( !emailStr.isEmpty() ) + { + qDebug( " emailstr " ); + QStringList l = QStringList::split( emailSeparator(), emailStr ); + for ( QStringList::ConstIterator it = l.begin();it != l.end();++it ) + r += ( *it ).simplifyWhiteSpace(); + } + + return r; +} + +/*! + \overload + + Generates the string for the contact to be filed as from the first, + middle and last name of the contact. +*/ +void OPimContact::setFileAs() +{ + QString lastName, firstName, middleName, fileas; + + lastName = find( Qtopia::LastName ); + firstName = find( Qtopia::FirstName ); + middleName = find( Qtopia::MiddleName ); + if ( !lastName.isEmpty() && !firstName.isEmpty() + && !middleName.isEmpty() ) + fileas = lastName + ", " + firstName + " " + middleName; + else if ( !lastName.isEmpty() && !firstName.isEmpty() ) + fileas = lastName + ", " + firstName; + else if ( !lastName.isEmpty() || !firstName.isEmpty() || + !middleName.isEmpty() ) + fileas = firstName + ( firstName.isEmpty() ? "" : " " ) + + middleName + ( middleName.isEmpty() ? "" : " " ) + + lastName; + + replace( Qtopia::FileAs, fileas ); +} + +/*! + \internal + Appends the contact information to \a buf. +*/ +void OPimContact::save( QString &buf ) const +{ + static const QStringList SLFIELDS = fields(); + // I'm expecting "<Contact " in front of this... + for ( QMap<int, QString>::ConstIterator it = mMap.begin(); + it != mMap.end(); ++it ) + { + const QString &value = it.data(); + int key = it.key(); + if ( !value.isEmpty() ) + { + if ( key == Qtopia::AddressCategory || key == Qtopia::AddressUid ) + continue; + + key -= Qtopia::AddressCategory + 1; + buf += SLFIELDS[ key ]; + buf += "=\"" + Qtopia::escapeString( value ) + "\" "; + } + } + buf += customToXml(); + if ( categories().count() > 0 ) + buf += "Categories=\"" + idsToString( categories() ) + "\" "; + buf += "Uid=\"" + QString::number( uid() ) + "\" "; + // You need to close this yourself +} + + +/*! + \internal + Returns the list of fields belonging to a contact + Never change order of this list ! It has to be regarding + enum AddressBookFields !! +*/ +QStringList OPimContact::fields() +{ + QStringList list; + + list.append( "Title" ); // Not Used! + list.append( "FirstName" ); + list.append( "MiddleName" ); + list.append( "LastName" ); + list.append( "Suffix" ); + list.append( "FileAs" ); + + list.append( "JobTitle" ); + list.append( "Department" ); + list.append( "Company" ); + list.append( "BusinessPhone" ); + list.append( "BusinessFax" ); + list.append( "BusinessMobile" ); + + list.append( "DefaultEmail" ); + list.append( "Emails" ); + + list.append( "HomePhone" ); + list.append( "HomeFax" ); + list.append( "HomeMobile" ); + + list.append( "BusinessStreet" ); + list.append( "BusinessCity" ); + list.append( "BusinessState" ); + list.append( "BusinessZip" ); + list.append( "BusinessCountry" ); + list.append( "BusinessPager" ); + list.append( "BusinessWebPage" ); + + list.append( "Office" ); + list.append( "Profession" ); + list.append( "Assistant" ); + list.append( "Manager" ); + + list.append( "HomeStreet" ); + list.append( "HomeCity" ); + list.append( "HomeState" ); + list.append( "HomeZip" ); + list.append( "HomeCountry" ); + list.append( "HomeWebPage" ); + + list.append( "Spouse" ); + list.append( "Gender" ); + list.append( "Birthday" ); + list.append( "Anniversary" ); + list.append( "Nickname" ); + list.append( "Children" ); + + list.append( "Notes" ); + list.append( "Groups" ); + + return list; +} + + +/*! + Sets the list of email address for contact to those contained in \a str. + Email address should be separated by ';'s. +*/ +void OPimContact::setEmails( const QString &str ) +{ + replace( Qtopia::Emails, str ); + if ( str.isEmpty() ) + setDefaultEmail( QString::null ); +} + +/*! + Sets the list of children for the contact to those contained in \a str. +*/ +void OPimContact::setChildren( const QString &str ) +{ + replace( Qtopia::Children, str ); +} + +/*! + \overload + Returns TRUE if the contact matches the regular expression \a regexp. + Otherwise returns FALSE. +*/ +bool OPimContact::match( const QRegExp &r ) const +{ + setLastHitField( -1 ); + bool match; + match = false; + QMap<int, QString>::ConstIterator it; + for ( it = mMap.begin(); it != mMap.end(); ++it ) + { + if ( ( *it ).find( r ) > -1 ) + { + setLastHitField( it.key() ); + match = true; + break; + } + } + return match; +} + + +QString OPimContact::toShortText() const +{ + return ( fullName() ); +} + + +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() ) + { + qWarning( "Remove Birthday" ); + 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() ) + { + qWarning( "Remove Anniversary" ); + 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 ); + // qWarning ("Birthday %s", str.latin1() ); + 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 ); + // qWarning ("Anniversary %s", str.latin1() ); + if ( !str.isEmpty() ) + return OPimDateConversion::dateFromString ( str ); + else + return empty; +} + + +void OPimContact::insertEmail( const QString &v ) +{ + //qDebug("insertEmail %s", v.latin1()); + 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 ; + if ( !emailsStr.isEmpty() ) + emailsStr += emailSeparator(); + emailsStr += e; + replace( Qtopia::Emails, emailsStr ); +} + + + void OPimContact::removeEmail( const QString &v ) +{ + QString e = v.simplifyWhiteSpace(); + QString def = defaultEmail(); + QString emailsStr = find( Qtopia::Emails ); + QStringList emails = emailList(); + + // otherwise, must first contain it + if ( !emailsStr.contains( e ) ) + return ; + + // remove it + //qDebug(" removing email from list %s", e.latin1()); + emails.remove( e ); + // reset the string + emailsStr = emails.join( emailSeparator() ); // Sharp's brain dead separator + replace( Qtopia::Emails, emailsStr ); + + // if default, then replace the default email with the first one + if ( def == e ) + { + //qDebug("removeEmail is default; setting new default"); + if ( !emails.count() ) + clearEmails(); + else // setDefaultEmail will remove e from the list + setDefaultEmail( emails.first() ); + } +} + + +void OPimContact::clearEmails() +{ + mMap.remove( Qtopia::DefaultEmail ); + mMap.remove( Qtopia::Emails ); +} + + +void OPimContact::setDefaultEmail( const QString &v ) +{ + QString e = v.simplifyWhiteSpace(); + + //qDebug("OPimContact::setDefaultEmail %s", e.latin1()); + 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() +{ + return OPimResolver::AddressBook; +} + + +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 new file mode 100644 index 0000000..c08f7ed --- a/dev/null +++ b/libopie2/opiepim/core/opimcontact.h @@ -0,0 +1,256 @@ +/* + This file is part of the Opie Project + Copyright (C) The Main Author <main-author@whereever.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 OCONTACT_H +#define OCONTACT_H + +/* OPIE */ +#include <opie2/opimrecord.h> +#include <qpe/recordfields.h> + +/* QT */ +#include <qdatetime.h> +#include <qstringlist.h> + +#if defined(QPC_TEMPLATEDLL) +// MOC_SKIP_BEGIN +QPC_TEMPLATEEXTERN template class QPC_EXPORT QMap<int, QString>; +// MOC_SKIP_END +#endif + +namespace Opie +{ +class OPimContactPrivate; + +/** + * OPimContact class represents a specialised PIM Record for contacts. + * It does store all kind of persopn related information. + * + * @short Contact Container + * @author TT, Stefan Eiler, Holger Freyther + */ +class QPC_EXPORT OPimContact : public OPimRecord +{ + friend class DataSet; + + public: + OPimContact(); + OPimContact( const QMap<int, QString> &fromMap ); + virtual ~OPimContact(); + + enum DateFormat{ + Zip_City_State = 0, + City_State_Zip + }; + + /* + * do we need to inline them + * if yes do we need to inline them this way? + * -zecke + */ + void setTitle( const QString &v ) { replace( Qtopia::Title, v ); } + void setFirstName( const QString &v ) { replace( Qtopia::FirstName, v ); } + void setMiddleName( const QString &v ) { replace( Qtopia::MiddleName, v ); } + void setLastName( const QString &v ) { replace( Qtopia::LastName, v ); } + void setSuffix( const QString &v ) { replace( Qtopia::Suffix, v ); } + void setFileAs( const QString &v ) { replace( Qtopia::FileAs, v ); } + void setFileAs(); + + // default email address + void setDefaultEmail( const QString &v ); + // inserts email to list and ensure's doesn't already exist + void insertEmail( const QString &v ); + void removeEmail( const QString &v ); + void clearEmails(); + void insertEmails( const QStringList &v ); + + // home + void setHomeStreet( const QString &v ) { replace( Qtopia::HomeStreet, v ); } + void setHomeCity( const QString &v ) { replace( Qtopia::HomeCity, v ); } + void setHomeState( const QString &v ) { replace( Qtopia::HomeState, v ); } + void setHomeZip( const QString &v ) { replace( Qtopia::HomeZip, v ); } + void setHomeCountry( const QString &v ) { replace( Qtopia::HomeCountry, v ); } + void setHomePhone( const QString &v ) { replace( Qtopia::HomePhone, v ); } + void setHomeFax( const QString &v ) { replace( Qtopia::HomeFax, v ); } + void setHomeMobile( const QString &v ) { replace( Qtopia::HomeMobile, v ); } + void setHomeWebpage( const QString &v ) { replace( Qtopia::HomeWebPage, v ); } + + // business + void setCompany( const QString &v ) { replace( Qtopia::Company, v ); } + void setBusinessStreet( const QString &v ) { replace( Qtopia::BusinessStreet, v ); } + void setBusinessCity( const QString &v ) { replace( Qtopia::BusinessCity, v ); } + void setBusinessState( const QString &v ) { replace( Qtopia::BusinessState, v ); } + void setBusinessZip( const QString &v ) { replace( Qtopia::BusinessZip, v ); } + void setBusinessCountry( const QString &v ) { replace( Qtopia::BusinessCountry, v ); } + void setBusinessWebpage( const QString &v ) { replace( Qtopia::BusinessWebPage, v ); } + void setJobTitle( const QString &v ) { replace( Qtopia::JobTitle, v ); } + void setDepartment( const QString &v ) { replace( Qtopia::Department, v ); } + void setOffice( const QString &v ) { replace( Qtopia::Office, v ); } + void setBusinessPhone( const QString &v ) { replace( Qtopia::BusinessPhone, v ); } + void setBusinessFax( const QString &v ) { replace( Qtopia::BusinessFax, v ); } + void setBusinessMobile( const QString &v ) { replace( Qtopia::BusinessMobile, v ); } + void setBusinessPager( const QString &v ) { replace( Qtopia::BusinessPager, v ); } + void setProfession( const QString &v ) { replace( Qtopia::Profession, v ); } + void setAssistant( const QString &v ) { replace( Qtopia::Assistant, v ); } + void setManager( const QString &v ) { replace( Qtopia::Manager, v ); } + + // personal + void setSpouse( const QString &v ) { replace( Qtopia::Spouse, v ); } + void setGender( const QString &v ) { replace( Qtopia::Gender, v ); } + void setBirthday( const QDate &v ); + void setAnniversary( const QDate &v ); + void setNickname( const QString &v ) { replace( Qtopia::Nickname, v ); } + void setChildren( const QString &v ); + + // other + void setNotes( const QString &v ) { replace( Qtopia::Notes, v ); } + + virtual bool match( const QRegExp ®exp ) const; + + // // custom + // void setCustomField( const QString &key, const QString &v ) + // { replace(Custom- + key, v ); } + + // name + QString fullName() const; + QString title() const { return find( Qtopia::Title ); } + QString firstName() const { return find( Qtopia::FirstName ); } + QString middleName() const { return find( Qtopia::MiddleName ); } + QString lastName() const { return find( Qtopia::LastName ); } + QString suffix() const { return find( Qtopia::Suffix ); } + QString fileAs() const { return find( Qtopia::FileAs ); } + + // email + QString defaultEmail() const { return find( Qtopia::DefaultEmail ); } + QStringList emailList() const; + + // home + /* + * OPimAddress address(enum Location)const; + * would be some how nicer... + * -zecke + */ + QString homeStreet() const { return find( Qtopia::HomeStreet ); } + QString homeCity() const { return find( Qtopia::HomeCity ); } + QString homeState() const { return find( Qtopia::HomeState ); } + QString homeZip() const { return find( Qtopia::HomeZip ); } + QString homeCountry() const { return find( Qtopia::HomeCountry ); } + QString homePhone() const { return find( Qtopia::HomePhone ); } + QString homeFax() const { return find( Qtopia::HomeFax ); } + QString homeMobile() const { return find( Qtopia::HomeMobile ); } + QString homeWebpage() const { return find( Qtopia::HomeWebPage ); } + /** Multi line string containing all non-empty address info in the form + * Street + * City, State Zip + * Country + */ + QString displayHomeAddress() const; + + // business + QString company() const { return find( Qtopia::Company ); } + QString businessStreet() const { return find( Qtopia::BusinessStreet ); } + QString businessCity() const { return find( Qtopia::BusinessCity ); } + QString businessState() const { return find( Qtopia::BusinessState ); } + QString businessZip() const { return find( Qtopia::BusinessZip ); } + QString businessCountry() const { return find( Qtopia::BusinessCountry ); } + QString businessWebpage() const { return find( Qtopia::BusinessWebPage ); } + QString jobTitle() const { return find( Qtopia::JobTitle ); } + QString department() const { return find( Qtopia::Department ); } + QString office() const { return find( Qtopia::Office ); } + QString businessPhone() const { return find( Qtopia::BusinessPhone ); } + QString businessFax() const { return find( Qtopia::BusinessFax ); } + QString businessMobile() const { return find( Qtopia::BusinessMobile ); } + QString businessPager() const { return find( Qtopia::BusinessPager ); } + QString profession() const { return find( Qtopia::Profession ); } + QString assistant() const { return find( Qtopia::Assistant ); } + QString manager() const { return find( Qtopia::Manager ); } + /** Multi line string containing all non-empty address info in the form + * Street + * City, State Zip + * Country + */ + QString displayBusinessAddress() const; + + //personal + QString spouse() const { return find( Qtopia::Spouse ); } + QString gender() const { return find( Qtopia::Gender ); } + QDate birthday() const; + QDate anniversary() const; + QString nickname() const { return find( Qtopia::Nickname ); } + QString children() const { return find( Qtopia::Children ); } + 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 ); } + static int rtti(); + + 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; +}; + +} + +#endif diff --git a/libopie2/opiepim/core/opimcontactfields.cpp b/libopie2/opiepim/core/opimcontactfields.cpp new file mode 100644 index 0000000..4b0ba3b --- a/dev/null +++ b/libopie2/opiepim/core/opimcontactfields.cpp @@ -0,0 +1,518 @@ +/* + This file is part of the Opie Project + 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. +*/ + +#include "opimcontactfields.h" + +/* OPIE */ +#include <opie2/opimcontact.h> +#include <qpe/recordfields.h> // We should use our own enum in the future .. +#include <qpe/config.h> + +/* QT */ +#include <qobject.h> +#include <qstringlist.h> + + +namespace Opie +{ +/*! + \internal + Returns a list of personal field names for a contact. +*/ +QStringList OPimContactFields::personalfields( bool sorted, bool translated ) +{ + QStringList list; + QMap<int, QString> mapIdToStr; + if ( translated ) + mapIdToStr = idToTrFields(); + else + mapIdToStr = idToUntrFields(); + + list.append( mapIdToStr[ Qtopia::AddressUid ] ); + list.append( mapIdToStr[ Qtopia::AddressCategory ] ); + + list.append( mapIdToStr[ Qtopia::Title ] ); + list.append( mapIdToStr[ Qtopia::FirstName ] ); + list.append( mapIdToStr[ Qtopia::MiddleName ] ); + list.append( mapIdToStr[ Qtopia::LastName ] ); + list.append( mapIdToStr[ Qtopia::Suffix ] ); + list.append( mapIdToStr[ Qtopia::FileAs ] ); + + list.append( mapIdToStr[ Qtopia::JobTitle ] ); + list.append( mapIdToStr[ Qtopia::Department ] ); + list.append( mapIdToStr[ Qtopia::Company ] ); + + list.append( mapIdToStr[ Qtopia::Notes ] ); + list.append( mapIdToStr[ Qtopia::Groups ] ); + + if ( sorted ) list.sort(); + return list; +} + +/*! + \internal + Returns a list of details field names for a contact. +*/ +QStringList OPimContactFields::detailsfields( bool sorted, bool translated ) +{ + QStringList list; + QMap<int, QString> mapIdToStr; + if ( translated ) + mapIdToStr = idToTrFields(); + else + mapIdToStr = idToUntrFields(); + + list.append( mapIdToStr[ Qtopia::Office ] ); + list.append( mapIdToStr[ Qtopia::Profession ] ); + list.append( mapIdToStr[ Qtopia::Assistant ] ); + list.append( mapIdToStr[ Qtopia::Manager ] ); + + list.append( mapIdToStr[ Qtopia::Spouse ] ); + list.append( mapIdToStr[ Qtopia::Gender ] ); + list.append( mapIdToStr[ Qtopia::Birthday ] ); + list.append( mapIdToStr[ Qtopia::Anniversary ] ); + list.append( mapIdToStr[ Qtopia::Nickname ] ); + list.append( mapIdToStr[ Qtopia::Children ] ); + + if ( sorted ) list.sort(); + return list; +} + +/*! + \internal + Returns a list of phone field names for a contact. +*/ +QStringList OPimContactFields::phonefields( bool sorted, bool translated ) +{ + QStringList list; + QMap<int, QString> mapIdToStr; + if ( translated ) + mapIdToStr = idToTrFields(); + else + mapIdToStr = idToUntrFields(); + + list.append( mapIdToStr[ Qtopia::BusinessPhone ] ); + list.append( mapIdToStr[ Qtopia::BusinessFax ] ); + list.append( mapIdToStr[ Qtopia::BusinessMobile ] ); + list.append( mapIdToStr[ Qtopia::BusinessPager ] ); + list.append( mapIdToStr[ Qtopia::BusinessWebPage ] ); + + list.append( mapIdToStr[ Qtopia::DefaultEmail ] ); + list.append( mapIdToStr[ Qtopia::Emails ] ); + + list.append( mapIdToStr[ Qtopia::HomePhone ] ); + list.append( mapIdToStr[ Qtopia::HomeFax ] ); + list.append( mapIdToStr[ Qtopia::HomeMobile ] ); + // list.append( mapIdToStr[Qtopia::HomePager] ); + list.append( mapIdToStr[ Qtopia::HomeWebPage ] ); + + if ( sorted ) list.sort(); + + return list; +} + +/*! + \internal + Returns a list of field names for a contact. +*/ +QStringList OPimContactFields::fields( bool sorted, bool translated ) +{ + QStringList list; + QMap<int, QString> mapIdToStr; + if ( translated ) + mapIdToStr = idToTrFields(); + else + mapIdToStr = idToUntrFields(); + + list += personalfields( sorted, translated ); + + list += phonefields( sorted, translated ); + + list.append( mapIdToStr[ Qtopia::BusinessStreet ] ); + list.append( mapIdToStr[ Qtopia::BusinessCity ] ); + list.append( mapIdToStr[ Qtopia::BusinessState ] ); + list.append( mapIdToStr[ Qtopia::BusinessZip ] ); + list.append( mapIdToStr[ Qtopia::BusinessCountry ] ); + + list.append( mapIdToStr[ Qtopia::HomeStreet ] ); + list.append( mapIdToStr[ Qtopia::HomeCity ] ); + list.append( mapIdToStr[ Qtopia::HomeState ] ); + list.append( mapIdToStr[ Qtopia::HomeZip ] ); + list.append( mapIdToStr[ Qtopia::HomeCountry ] ); + + list += detailsfields( sorted, translated ); + + if ( sorted ) list.sort(); + + return list; +} + + +/*! + \internal + Returns an untranslated list of personal field names for a contact. +*/ +QStringList OPimContactFields::untrpersonalfields( bool sorted ) +{ + return personalfields( sorted, false ); +} + + +/*! + \internal + Returns a translated list of personal field names for a contact. +*/ +QStringList OPimContactFields::trpersonalfields( bool sorted ) +{ + return personalfields( sorted, true ); +} + + +/*! + \internal + Returns an untranslated list of details field names for a contact. +*/ +QStringList OPimContactFields::untrdetailsfields( bool sorted ) +{ + return detailsfields( sorted, false ); +} + + +/*! + \internal + Returns a translated list of details field names for a contact. +*/ +QStringList OPimContactFields::trdetailsfields( bool sorted ) +{ + return detailsfields( sorted, true ); +} + + +/*! + \internal + Returns a translated list of phone field names for a contact. +*/ +QStringList OPimContactFields::trphonefields( bool sorted ) +{ + return phonefields( sorted, true ); +} + +/*! + \internal + Returns an untranslated list of phone field names for a contact. +*/ +QStringList OPimContactFields::untrphonefields( bool sorted ) +{ + return phonefields( sorted, false ); +} + + +/*! + \internal + Returns a translated list of field names for a contact. +*/ +QStringList OPimContactFields::trfields( bool sorted ) +{ + return fields( sorted, true ); +} + +/*! + \internal + Returns an untranslated list of field names for a contact. +*/ +QStringList OPimContactFields::untrfields( bool sorted ) +{ + return fields( sorted, false ); +} + +QMap<int, QString> OPimContactFields::idToTrFields() +{ + QMap<int, QString> ret_map; + + ret_map.insert( Qtopia::AddressUid, QObject::tr( "User Id" ) ); + ret_map.insert( Qtopia::AddressCategory, QObject::tr( "Categories" ) ); + + ret_map.insert( Qtopia::Title, QObject::tr( "Name Title" ) ); + ret_map.insert( Qtopia::FirstName, QObject::tr( "First Name" ) ); + ret_map.insert( Qtopia::MiddleName, QObject::tr( "Middle Name" ) ); + ret_map.insert( Qtopia::LastName, QObject::tr( "Last Name" ) ); + ret_map.insert( Qtopia::Suffix, QObject::tr( "Suffix" ) ); + ret_map.insert( Qtopia::FileAs, QObject::tr( "File As" ) ); + + ret_map.insert( Qtopia::JobTitle, QObject::tr( "Job Title" ) ); + ret_map.insert( Qtopia::Department, QObject::tr( "Department" ) ); + ret_map.insert( Qtopia::Company, QObject::tr( "Company" ) ); + ret_map.insert( Qtopia::BusinessPhone, QObject::tr( "Business Phone" ) ); + ret_map.insert( Qtopia::BusinessFax, QObject::tr( "Business Fax" ) ); + ret_map.insert( Qtopia::BusinessMobile, QObject::tr( "Business Mobile" ) ); + + // email + ret_map.insert( Qtopia::DefaultEmail, QObject::tr( "Default Email" ) ); + ret_map.insert( Qtopia::Emails, QObject::tr( "Emails" ) ); + + ret_map.insert( Qtopia::HomePhone, QObject::tr( "Home Phone" ) ); + ret_map.insert( Qtopia::HomeFax, QObject::tr( "Home Fax" ) ); + ret_map.insert( Qtopia::HomeMobile, QObject::tr( "Home Mobile" ) ); + + // business + ret_map.insert( Qtopia::BusinessStreet, QObject::tr( "Business Street" ) ); + ret_map.insert( Qtopia::BusinessCity, QObject::tr( "Business City" ) ); + ret_map.insert( Qtopia::BusinessState, QObject::tr( "Business State" ) ); + ret_map.insert( Qtopia::BusinessZip, QObject::tr( "Business Zip" ) ); + ret_map.insert( Qtopia::BusinessCountry, QObject::tr( "Business Country" ) ); + ret_map.insert( Qtopia::BusinessPager, QObject::tr( "Business Pager" ) ); + ret_map.insert( Qtopia::BusinessWebPage, QObject::tr( "Business WebPage" ) ); + + ret_map.insert( Qtopia::Office, QObject::tr( "Office" ) ); + ret_map.insert( Qtopia::Profession, QObject::tr( "Profession" ) ); + ret_map.insert( Qtopia::Assistant, QObject::tr( "Assistant" ) ); + ret_map.insert( Qtopia::Manager, QObject::tr( "Manager" ) ); + + // home + ret_map.insert( Qtopia::HomeStreet, QObject::tr( "Home Street" ) ); + ret_map.insert( Qtopia::HomeCity, QObject::tr( "Home City" ) ); + ret_map.insert( Qtopia::HomeState, QObject::tr( "Home State" ) ); + ret_map.insert( Qtopia::HomeZip, QObject::tr( "Home Zip" ) ); + ret_map.insert( Qtopia::HomeCountry, QObject::tr( "Home Country" ) ); + ret_map.insert( Qtopia::HomeWebPage, QObject::tr( "Home Web Page" ) ); + + //personal + ret_map.insert( Qtopia::Spouse, QObject::tr( "Spouse" ) ); + ret_map.insert( Qtopia::Gender, QObject::tr( "Gender" ) ); + ret_map.insert( Qtopia::Birthday, QObject::tr( "Birthday" ) ); + ret_map.insert( Qtopia::Anniversary, QObject::tr( "Anniversary" ) ); + ret_map.insert( Qtopia::Nickname, QObject::tr( "Nickname" ) ); + ret_map.insert( Qtopia::Children, QObject::tr( "Children" ) ); + + // other + ret_map.insert( Qtopia::Notes, QObject::tr( "Notes" ) ); + + + return ret_map; +} + +QMap<int, QString> OPimContactFields::idToUntrFields() +{ + QMap<int, QString> ret_map; + + ret_map.insert( Qtopia::AddressUid, "User Id" ); + ret_map.insert( Qtopia::AddressCategory, "Categories" ); + + ret_map.insert( Qtopia::Title, "Name Title" ); + ret_map.insert( Qtopia::FirstName, "First Name" ); + ret_map.insert( Qtopia::MiddleName, "Middle Name" ); + ret_map.insert( Qtopia::LastName, "Last Name" ); + ret_map.insert( Qtopia::Suffix, "Suffix" ); + ret_map.insert( Qtopia::FileAs, "File As" ); + + ret_map.insert( Qtopia::JobTitle, "Job Title" ); + ret_map.insert( Qtopia::Department, "Department" ); + ret_map.insert( Qtopia::Company, "Company" ); + ret_map.insert( Qtopia::BusinessPhone, "Business Phone" ); + ret_map.insert( Qtopia::BusinessFax, "Business Fax" ); + ret_map.insert( Qtopia::BusinessMobile, "Business Mobile" ); + + // email + ret_map.insert( Qtopia::DefaultEmail, "Default Email" ); + ret_map.insert( Qtopia::Emails, "Emails" ); + + ret_map.insert( Qtopia::HomePhone, "Home Phone" ); + ret_map.insert( Qtopia::HomeFax, "Home Fax" ); + ret_map.insert( Qtopia::HomeMobile, "Home Mobile" ); + + // business + ret_map.insert( Qtopia::BusinessStreet, "Business Street" ); + ret_map.insert( Qtopia::BusinessCity, "Business City" ); + ret_map.insert( Qtopia::BusinessState, "Business State" ); + ret_map.insert( Qtopia::BusinessZip, "Business Zip" ); + ret_map.insert( Qtopia::BusinessCountry, "Business Country" ); + ret_map.insert( Qtopia::BusinessPager, "Business Pager" ); + ret_map.insert( Qtopia::BusinessWebPage, "Business WebPage" ); + + ret_map.insert( Qtopia::Office, "Office" ); + ret_map.insert( Qtopia::Profession, "Profession" ); + ret_map.insert( Qtopia::Assistant, "Assistant" ); + ret_map.insert( Qtopia::Manager, "Manager" ); + + // home + ret_map.insert( Qtopia::HomeStreet, "Home Street" ); + ret_map.insert( Qtopia::HomeCity, "Home City" ); + ret_map.insert( Qtopia::HomeState, "Home State" ); + ret_map.insert( Qtopia::HomeZip, "Home Zip" ); + ret_map.insert( Qtopia::HomeCountry, "Home Country" ); + ret_map.insert( Qtopia::HomeWebPage, "Home Web Page" ); + + //personal + ret_map.insert( Qtopia::Spouse, "Spouse" ); + ret_map.insert( Qtopia::Gender, "Gender" ); + ret_map.insert( Qtopia::Birthday, "Birthday" ); + ret_map.insert( Qtopia::Anniversary, "Anniversary" ); + ret_map.insert( Qtopia::Nickname, "Nickname" ); + ret_map.insert( Qtopia::Children, "Children" ); + + // other + ret_map.insert( Qtopia::Notes, "Notes" ); + ret_map.insert( Qtopia::Groups, "Groups" ); + + + return ret_map; +} + +QMap<QString, int> OPimContactFields::trFieldsToId() +{ + QMap<int, QString> idtostr = idToTrFields(); + QMap<QString, int> ret_map; + + + QMap<int, QString>::Iterator it; + for ( it = idtostr.begin(); it != idtostr.end(); ++it ) + ret_map.insert( *it, it.key() ); + + + return ret_map; +} + +/* ======================================================================= */ + +QMap<QString, int> OPimContactFields::untrFieldsToId() +{ + QMap<int, QString> idtostr = idToUntrFields(); + QMap<QString, int> ret_map; + + + QMap<int, QString>::Iterator it; + for ( it = idtostr.begin(); it != idtostr.end(); ++it ) + ret_map.insert( *it, it.key() ); + + + return ret_map; +} + + +OPimContactFields::OPimContactFields() : + fieldOrder( DEFAULT_FIELD_ORDER ), + changedFieldOrder( false ) +{ + // Get the global field order from the config file and + // use it as a start pattern + Config cfg ( "AddressBook" ); + cfg.setGroup( "ContactFieldOrder" ); + globalFieldOrder = cfg.readEntry( "General", DEFAULT_FIELD_ORDER ); +} + +OPimContactFields::~OPimContactFields() +{ + + // We will store the fieldorder into the config file + // to reuse it for the future.. + if ( changedFieldOrder ) + { + Config cfg ( "AddressBook" ); + cfg.setGroup( "ContactFieldOrder" ); + cfg.writeEntry( "General", globalFieldOrder ); + } +} + + + +void OPimContactFields::saveToRecord( OPimContact &cnt ) +{ + + qDebug( "ocontactfields saveToRecord: >%s<", fieldOrder.latin1() ); + + // Store fieldorder into this contact. + cnt.setCustomField( CONTACT_FIELD_ORDER_NAME, fieldOrder ); + + globalFieldOrder = fieldOrder; + changedFieldOrder = true; + +} + +void OPimContactFields::loadFromRecord( const OPimContact &cnt ) +{ + qDebug( "ocontactfields loadFromRecord" ); + qDebug( "loading >%s<", cnt.fullName().latin1() ); + + // Get fieldorder for this contact. If none is defined, + // we will use the global one from the config file.. + + fieldOrder = cnt.customField( CONTACT_FIELD_ORDER_NAME ); + + qDebug( "fieldOrder from contact>%s<", fieldOrder.latin1() ); + + if ( fieldOrder.isEmpty() ) + { + fieldOrder = globalFieldOrder; + } + + + qDebug( "effective fieldOrder in loadFromRecord >%s<", fieldOrder.latin1() ); +} + +void OPimContactFields::setFieldOrder( int num, int index ) +{ + qDebug( "qcontactfields setfieldorder pos %i -> %i", num, index ); + + fieldOrder[ num ] = QString::number( index, 16 ) [ 0 ]; + + // We will store this new fieldorder globally to + // remember it for contacts which have none + globalFieldOrder = fieldOrder; + changedFieldOrder = true; + + qDebug( "fieldOrder >%s<", fieldOrder.latin1() ); +} + +int OPimContactFields::getFieldOrder( int num, int defIndex ) +{ + qDebug( "ocontactfields getFieldOrder" ); + qDebug( "fieldOrder >%s<", fieldOrder.latin1() ); + + // Get index of combo as char.. + QChar poschar = fieldOrder[ num ]; + + bool ok; + int ret = 0; + // Convert char to number.. + if ( !( poschar == QChar::null ) ) + ret = QString( poschar ).toInt( &ok, 16 ); + else + ok = false; + + // Return default value if index for + // num was not set or if anything else happened.. + if ( !ok ) ret = defIndex; + + qDebug( "returning >%i<", ret ); + + return ret; + +} + +} diff --git a/libopie2/opiepim/core/opimcontactfields.h b/libopie2/opiepim/core/opimcontactfields.h new file mode 100644 index 0000000..3aa3894 --- a/dev/null +++ b/libopie2/opiepim/core/opimcontactfields.h @@ -0,0 +1,102 @@ +/* + This file is part of the Opie Project + Copyright (C) The Main Author <main-author@whereever.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 OCONTACTFIELDS_H +#define OCONTACTFIELDS_H + +class QStringList; + +/* OPIE */ +#include <opie2/opimcontact.h> + +/* QT */ +#include <qmap.h> +#include <qstring.h> + +#define CONTACT_FIELD_ORDER_NAME "opie-contactfield-order" +#define DEFAULT_FIELD_ORDER "__________" + +namespace Opie +{ +class OPimContactFields +{ + + public: + OPimContactFields(); + ~OPimContactFields(); + /** Set the index for combo boxes. + * Sets the <b>index</b> of combo <b>num</b>. + * @param num selects the number of the combo + * @param index sets the index in the combo + */ + void setFieldOrder( int num, int index ); + + /** Get the index for combo boxes. + * Returns the index of combo <b>num</b> or defindex + * if none was defined.. + * @param num Selects the number of the combo + * @param defIndex will be returned if none was defined (either + * globally in the config file, nor by the contact which was used + * by loadFromRecord() ) + */ + int getFieldOrder( int num, int defIndex ); + + /** Store fieldorder to contact. */ + void saveToRecord( OPimContact& ); + /** Get Fieldorder from contact. */ + void loadFromRecord( const OPimContact& ); + + private: + QString fieldOrder; + QString globalFieldOrder; + bool changedFieldOrder; + + public: + static QStringList personalfields( bool sorted = true, bool translated = false ); + static QStringList phonefields( bool sorted = true, bool translated = false ); + static QStringList detailsfields( bool sorted = true, bool translated = false ); + static QStringList fields( bool sorted = true, bool translated = false ); + + static QStringList trpersonalfields( bool sorted = true ); + static QStringList untrpersonalfields( bool sorted = true ); + static QStringList trphonefields( bool sorted = true ); + static QStringList untrphonefields( bool sorted = true ); + static QStringList trdetailsfields( bool sorted = true ); + static QStringList untrdetailsfields( bool sorted = true ); + static QStringList trfields( bool sorted = true ); + static QStringList untrfields( bool sorted = true ); + + static QMap<int, QString> idToTrFields(); + static QMap<QString, int> trFieldsToId(); + static QMap<int, QString> idToUntrFields(); + static QMap<QString, int> untrFieldsToId(); + +}; +} +#endif diff --git a/libopie2/opiepim/core/oconversion.cpp b/libopie2/opiepim/core/opimdateconversion.cpp index 160c2c6..8bf891b 100644 --- a/libopie2/opiepim/core/oconversion.cpp +++ b/libopie2/opiepim/core/opimdateconversion.cpp @@ -27,13 +27,13 @@ _;:, .> :=|. This program is free software; you can */
/* OPIE */
-#include <opie2/oconversion.h>
+#include <opie2/opimdateconversion.h>
#include <qpe/timeconversion.h>
namespace Opie
{
-QString OConversion::dateToString( const QDate &d )
+QString OPimDateConversion::dateToString( const QDate &d )
{
if ( d.isNull() || !d.isValid() )
return QString::null;
@@ -52,7 +52,7 @@ QString OConversion::dateToString( const QDate &d ) }
-QDate OConversion::dateFromString( const QString& s )
+QDate OPimDateConversion::dateFromString( const QString& s )
{
QDate date;
@@ -99,7 +99,7 @@ QDate OConversion::dateFromString( const QString& s ) }
-QString OConversion::dateTimeToString( const QDateTime& dt )
+QString OPimDateConversion::dateTimeToString( const QDateTime& dt )
{
if ( !dt.isValid() || dt.isNull() )
return QString::null;
@@ -122,7 +122,7 @@ QString OConversion::dateTimeToString( const QDateTime& dt ) }
-QDateTime OConversion::dateTimeFromString( const QString& str )
+QDateTime OPimDateConversion::dateTimeFromString( const QString& str )
{
if ( str.isEmpty() )
diff --git a/libopie2/opiepim/core/oconversion.h b/libopie2/opiepim/core/opimdateconversion.h index eeb97e5..45536da 100644 --- a/libopie2/opiepim/core/oconversion.h +++ b/libopie2/opiepim/core/opimdateconversion.h @@ -35,7 +35,7 @@ namespace Opie { -class OConversion +class OPimDateConversion { public: static QString dateToString( const QDate &d ); diff --git a/libopie2/opiepim/core/opimevent.cpp b/libopie2/opiepim/core/opimevent.cpp new file mode 100644 index 0000000..3ddbf85 --- a/dev/null +++ b/libopie2/opiepim/core/opimevent.cpp @@ -0,0 +1,1025 @@ +/* + This file is part of the Opie Project + 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. +*/ + +#include "opimevent.h" + +/* OPIE */ +#include <opie2/opimrecurrence.h> +#include <opie2/opimresolver.h> +#include <opie2/opimnotifymanager.h> +#include <qpe/categories.h> +#include <qpe/palmtopuidgen.h> +#include <qpe/stringutil.h> + +/* QT */ +#include <qshared.h> +#include <qarray.h> + +namespace Opie +{ + +int OCalendarHelper::week( const QDate& date ) +{ + // Calculates the week this date is in within that + // month. Equals the "row" is is in in the month view + int week = 1; + QDate tmp( date.year(), date.month(), 1 ); + if ( date.dayOfWeek() < tmp.dayOfWeek() ) + ++week; + + week += ( date.day() - 1 ) / 7; + + return week; +} + + +int OCalendarHelper::ocurrence( const QDate& date ) +{ + // calculates the number of occurrances of this day of the + // week till the given date (e.g 3rd Wednesday of the month) + return ( date.day() - 1 ) / 7 + 1; +} + + +int OCalendarHelper::dayOfWeek( char day ) +{ + int dayOfWeek = 1; + char i = OPimRecurrence::MON; + while ( !( i & day ) && i <= OPimRecurrence::SUN ) + { + i <<= 1; + ++dayOfWeek; + } + return dayOfWeek; +} + + +int OCalendarHelper::monthDiff( const QDate& first, const QDate& second ) +{ + return ( second.year() - first.year() ) * 12 + + second.month() - first.month(); +} + + +struct OPimEvent::Data : public QShared +{ + Data() : QShared() + { + child = 0; + recur = 0; + manager = 0; + isAllDay = false; + parent = 0; + } + ~Data() + { + delete manager; + delete recur; + } + QString description; + QString location; + OPimNotifyManager* manager; + OPimRecurrence* recur; + QString note; + QDateTime created; + QDateTime start; + QDateTime end; +bool isAllDay : 1; + QString timezone; + QArray<int>* child; + int parent; +}; + + +OPimEvent::OPimEvent( int uid ) + : OPimRecord( uid ) +{ + data = new Data; +} + + +OPimEvent::OPimEvent( const OPimEvent& ev ) + : OPimRecord( ev ), data( ev.data ) +{ + data->ref(); +} + + +OPimEvent::OPimEvent( const QMap<int, QString> map ) + : OPimRecord( 0 ) +{ + data = new Data; + + fromMap( map ); +} + + +OPimEvent::~OPimEvent() +{ + if ( data->deref() ) + { + delete data; + data = 0; + } +} + + +OPimEvent& OPimEvent::operator=( const OPimEvent& ev ) +{ + if ( this == &ev ) return * this; + + OPimRecord::operator=( ev ); + ev.data->ref(); + deref(); + data = ev.data; + + + return *this; +} + + +QString OPimEvent::description() const +{ + return data->description; +} + + +void OPimEvent::setDescription( const QString& description ) +{ + changeOrModify(); + data->description = description; +} + + +void OPimEvent::setLocation( const QString& loc ) +{ + changeOrModify(); + data->location = loc; +} + + +QString OPimEvent::location() const +{ + return data->location; +} + + +OPimNotifyManager &OPimEvent::notifiers() const +{ + // I hope we can skip the changeOrModify here + // the notifier should take care of it + // and OPimNotify is shared too + if ( !data->manager ) + data->manager = new OPimNotifyManager; + + return *data->manager; +} + + +bool OPimEvent::hasNotifiers() const +{ + if ( !data->manager ) + return false; + if ( data->manager->reminders().isEmpty() && + data->manager->alarms().isEmpty() ) + return false; + + return true; +} + + +OPimRecurrence OPimEvent::recurrence() const +{ + if ( !data->recur ) + data->recur = new OPimRecurrence; + + return *data->recur; +} + + +void OPimEvent::setRecurrence( const OPimRecurrence& rec ) +{ + changeOrModify(); + if ( data->recur ) + ( *data->recur ) = rec; + else + data->recur = new OPimRecurrence( rec ); +} + + +bool OPimEvent::hasRecurrence() const +{ + if ( !data->recur ) return false; + return data->recur->doesRecur(); +} + + +QString OPimEvent::note() const +{ + return data->note; +} + + +void OPimEvent::setNote( const QString& note ) +{ + changeOrModify(); + data->note = note; +} + + +QDateTime OPimEvent::createdDateTime() const +{ + return data->created; +} + + +void OPimEvent::setCreatedDateTime( const QDateTime& time ) +{ + changeOrModify(); + data->created = time; +} + + +QDateTime OPimEvent::startDateTime() const +{ + if ( data->isAllDay ) + return QDateTime( data->start.date(), QTime( 0, 0, 0 ) ); + return data->start; +} + + +QDateTime OPimEvent::startDateTimeInZone() const +{ + /* if no timezone, or all day event or if the current and this timeZone match... */ + if ( data->timezone.isEmpty() || data->isAllDay || data->timezone == OPimTimeZone::current().timeZone() ) return startDateTime(); + + OPimTimeZone zone( data->timezone ); + return zone.toDateTime( data->start, OPimTimeZone::current() ); +} + + +void OPimEvent::setStartDateTime( const QDateTime& dt ) +{ + changeOrModify(); + data->start = dt; +} + + +QDateTime OPimEvent::endDateTime() const +{ + /* + * if all Day event the end time needs + * to be on the same day as the start + */ + if ( data->isAllDay ) + return QDateTime( data->start.date(), QTime( 23, 59, 59 ) ); + return data->end; +} + + +QDateTime OPimEvent::endDateTimeInZone() const +{ + /* if no timezone, or all day event or if the current and this timeZone match... */ + if ( data->timezone.isEmpty() || data->isAllDay || data->timezone == OPimTimeZone::current().timeZone() ) return endDateTime(); + + OPimTimeZone zone( data->timezone ); + return zone.toDateTime( data->end, OPimTimeZone::current() ); +} + + +void OPimEvent::setEndDateTime( const QDateTime& dt ) +{ + changeOrModify(); + data->end = dt; +} + + +bool OPimEvent::isMultipleDay() const +{ + return data->end.date().day() - data->start.date().day(); +} + + +bool OPimEvent::isAllDay() const +{ + return data->isAllDay; +} + + +void OPimEvent::setAllDay( bool allDay ) +{ + changeOrModify(); + data->isAllDay = allDay; + if ( allDay ) data->timezone = "UTC"; +} + + +void OPimEvent::setTimeZone( const QString& tz ) +{ + changeOrModify(); + data->timezone = tz; +} + + +QString OPimEvent::timeZone() const +{ + if ( data->isAllDay ) return QString::fromLatin1( "UTC" ); + return data->timezone; +} + + +bool OPimEvent::match( const QRegExp& re ) const +{ + if ( re.match( data->description ) != -1 ) + { + setLastHitField( Qtopia::DatebookDescription ); + return true; + } + if ( re.match( data->note ) != -1 ) + { + setLastHitField( Qtopia::Note ); + return true; + } + if ( re.match( data->location ) != -1 ) + { + setLastHitField( Qtopia::Location ); + return true; + } + if ( re.match( data->start.toString() ) != -1 ) + { + setLastHitField( Qtopia::StartDateTime ); + return true; + } + if ( re.match( data->end.toString() ) != -1 ) + { + setLastHitField( Qtopia::EndDateTime ); + return true; + } + return false; +} + + +QString OPimEvent::toRichText() const +{ + QString text, value; + + // description + text += "<b><h3><img src=\"datebook/DateBook\">"; + if ( !description().isEmpty() ) + { + text += Qtopia::escapeString( description() ).replace( QRegExp( "[\n]" ), "" ); + } + text += "</h3></b><br><hr><br>"; + + // location + if ( !( value = location() ).isEmpty() ) + { + text += "<b>" + QObject::tr( "Location:" ) + "</b> "; + text += Qtopia::escapeString( value ) + "<br>"; + } + + // all day event + if ( isAllDay() ) + { + text += "<b><i>" + QObject::tr( "This is an all day event" ) + "</i></b><br>"; + } + // multiple day event + else if ( isMultipleDay () ) + { + text += "<b><i>" + QObject::tr( "This is a multiple day event" ) + "</i></b><br>"; + } + // start & end times + else + { + // start time + if ( startDateTime().isValid() ) + { + text += "<b>" + QObject::tr( "Start:" ) + "</b> "; + text += Qtopia::escapeString( startDateTime().toString() ). + replace( QRegExp( "[\n]" ), "<br>" ) + "<br>"; + } + + // end time + if ( endDateTime().isValid() ) + { + text += "<b>" + QObject::tr( "End:" ) + "</b> "; + text += Qtopia::escapeString( endDateTime().toString() ). + replace( QRegExp( "[\n]" ), "<br>" ) + "<br>"; + } + } + + // categories + if ( categoryNames( "Calendar" ).count() ) + { + text += "<b>" + QObject::tr( "Category:" ) + "</b> "; + text += categoryNames( "Calendar" ).join( ", " ); + text += "<br>"; + } + + //notes + if ( !note().isEmpty() ) + { + text += "<b>" + QObject::tr( "Note:" ) + "</b><br>"; + text += note(); + // text += Qtopia::escapeString(note() ). + // replace(QRegExp( "[\n]"), "<br>" ) + "<br>"; + } + return text; +} + + +QString OPimEvent::toShortText() const +{ + QString text; + text += QString::number( startDateTime().date().day() ); + text += "."; + text += QString::number( startDateTime().date().month() ); + text += "."; + text += QString::number( startDateTime().date().year() ); + text += " "; + text += QString::number( startDateTime().time().hour() ); + text += ":"; + 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() +{ + return OPimResolver::DateBook; +} + + +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 ); + + if ( data->recur ) + d2->recur = new OPimRecurrence( *data->recur ); + + d2->note = data->note; + d2->created = data->created; + d2->start = data->start; + d2->end = data->end; + d2->isAllDay = data->isAllDay; + d2->timezone = data->timezone; + d2->parent = data->parent; + + if ( data->child ) + { + d2->child = new QArray<int>( *data->child ); + d2->child->detach(); + } + + data = d2; + } +} + + +void OPimEvent::deref() +{ + if ( data->deref() ) + { + delete data; + data = 0; + } +} +// Exporting Event data to map. Using the same +// encoding as ODateBookAccessBackend_xml does.. +// Thus, we could remove the stuff there and use this +// for it and for all other places.. +// Encoding should happen at one place, only ! (eilers) +QMap<int, QString> OPimEvent::toMap() const +{ + QMap<int, QString> retMap; + + retMap.insert( OPimEvent::FUid, QString::number( uid() ) ); + retMap.insert( OPimEvent::FCategories, Qtopia::escapeString( Qtopia::Record::idsToString( categories() ) ) ); + retMap.insert( OPimEvent::FDescription, Qtopia::escapeString( description() ) ); + retMap.insert( OPimEvent::FLocation, Qtopia::escapeString( location() ) ); + retMap.insert( OPimEvent::FType, isAllDay() ? "AllDay" : "" ); + OPimAlarm alarm = notifiers().alarms() [ 0 ]; + retMap.insert( OPimEvent::FAlarm, QString::number( alarm.dateTime().secsTo( startDateTime() ) / 60 ) ); + retMap.insert( OPimEvent::FSound, ( alarm.sound() == OPimAlarm::Loud ) ? "loud" : "silent" ); + + OPimTimeZone zone( timeZone().isEmpty() ? OPimTimeZone::current() : timeZone() ); + retMap.insert( OPimEvent::FStart, QString::number( zone.fromUTCDateTime( zone.toDateTime( startDateTime(), OPimTimeZone::utc() ) ) ) ); + retMap.insert( OPimEvent::FEnd, QString::number( zone.fromUTCDateTime( zone.toDateTime( endDateTime(), OPimTimeZone::utc() ) ) ) ); + retMap.insert( OPimEvent::FNote, Qtopia::escapeString( note() ) ); + retMap.insert( OPimEvent::FTimeZone, timeZone().isEmpty() ? QString( "None" ) : timeZone() ); + if ( parent() ) + retMap.insert( OPimEvent::FRecParent, QString::number( parent() ) ); + if ( children().count() ) + { + QArray<int> childr = children(); + QString buf; + for ( uint i = 0; i < childr.count(); i++ ) + { + if ( i != 0 ) buf += " "; + buf += QString::number( childr[ i ] ); + } + retMap.insert( OPimEvent::FRecChildren, buf ); + } + + // Add recurrence stuff + if ( hasRecurrence() ) + { + OPimRecurrence recur = recurrence(); + QMap<int, QString> recFields = recur.toMap(); + retMap.insert( OPimEvent::FRType, recFields[ OPimRecurrence::RType ] ); + retMap.insert( OPimEvent::FRWeekdays, recFields[ OPimRecurrence::RWeekdays ] ); + retMap.insert( OPimEvent::FRPosition, recFields[ OPimRecurrence::RPosition ] ); + retMap.insert( OPimEvent::FRFreq, recFields[ OPimRecurrence::RFreq ] ); + retMap.insert( OPimEvent::FRHasEndDate, recFields[ OPimRecurrence::RHasEndDate ] ); + retMap.insert( OPimEvent::FREndDate, recFields[ OPimRecurrence::EndDate ] ); + retMap.insert( OPimEvent::FRCreated, recFields[ OPimRecurrence::Created ] ); + retMap.insert( OPimEvent::FRExceptions, recFields[ OPimRecurrence::Exceptions ] ); + } + else + { + OPimRecurrence recur = recurrence(); + QMap<int, QString> recFields = recur.toMap(); + retMap.insert( OPimEvent::FRType, recFields[ OPimRecurrence::RType ] ); + } + + return retMap; +} + + +void OPimEvent::fromMap( const QMap<int, QString>& map ) +{ + + // We just want to set the UID if it is really stored. + if ( !map[ OPimEvent::FUid ].isEmpty() ) + setUid( map[ OPimEvent::FUid ].toInt() ); + + setCategories( idsFromString( map[ OPimEvent::FCategories ] ) ); + setDescription( map[ OPimEvent::FDescription ] ); + setLocation( map[ OPimEvent::FLocation ] ); + + if ( map[ OPimEvent::FType ] == "AllDay" ) + setAllDay( true ); + else + setAllDay( false ); + + int alarmTime = -1; + if ( !map[ OPimEvent::FAlarm ].isEmpty() ) + alarmTime = map[ OPimEvent::FAlarm ].toInt(); + + int sound = ( ( map[ OPimEvent::FSound ] == "loud" ) ? OPimAlarm::Loud : OPimAlarm::Silent ); + if ( ( alarmTime != -1 ) ) + { + QDateTime dt = startDateTime().addSecs( -1 * alarmTime * 60 ); + OPimAlarm al( sound , dt ); + notifiers().add( al ); + } + if ( !map[ OPimEvent::FTimeZone ].isEmpty() && ( map[ OPimEvent::FTimeZone ] != "None" ) ) + { + setTimeZone( map[ OPimEvent::FTimeZone ] ); + } + + time_t start = ( time_t ) map[ OPimEvent::FStart ].toLong(); + time_t end = ( time_t ) map[ OPimEvent::FEnd ].toLong(); + + /* AllDay is always in UTC */ + if ( isAllDay() ) + { + OPimTimeZone utc = OPimTimeZone::utc(); + setStartDateTime( utc.fromUTCDateTime( start ) ); + setEndDateTime ( utc.fromUTCDateTime( end ) ); + setTimeZone( "UTC" ); // make sure it is really utc + } + else + { + /* to current date time */ + // qWarning(" Start is %d", start ); + OPimTimeZone zone( timeZone().isEmpty() ? OPimTimeZone::current() : timeZone() ); + QDateTime date = zone.toDateTime( start ); + qWarning( " Start is %s", date.toString().latin1() ); + setStartDateTime( zone.toDateTime( date, OPimTimeZone::current() ) ); + + date = zone.toDateTime( end ); + setEndDateTime ( zone.toDateTime( date, OPimTimeZone::current() ) ); + } + + if ( !map[ OPimEvent::FRecParent ].isEmpty() ) + setParent( map[ OPimEvent::FRecParent ].toInt() ); + + if ( !map[ OPimEvent::FRecChildren ].isEmpty() ) + { + QStringList list = QStringList::split( ' ', map[ OPimEvent::FRecChildren ] ); + for ( QStringList::Iterator it = list.begin(); it != list.end(); ++it ) + { + addChild( ( *it ).toInt() ); + } + } + + // Fill recurrence stuff and put it directly into the OPimRecurrence-Object using fromMap.. + if ( !map[ OPimEvent::FRType ].isEmpty() ) + { + QMap<int, QString> recFields; + recFields.insert( OPimRecurrence::RType, map[ OPimEvent::FRType ] ); + recFields.insert( OPimRecurrence::RWeekdays, map[ OPimEvent::FRWeekdays ] ); + recFields.insert( OPimRecurrence::RPosition, map[ OPimEvent::FRPosition ] ); + recFields.insert( OPimRecurrence::RFreq, map[ OPimEvent::FRFreq ] ); + recFields.insert( OPimRecurrence::RHasEndDate, map[ OPimEvent::FRHasEndDate ] ); + recFields.insert( OPimRecurrence::EndDate, map[ OPimEvent::FREndDate ] ); + recFields.insert( OPimRecurrence::Created, map[ OPimEvent::FRCreated ] ); + recFields.insert( OPimRecurrence::Exceptions, map[ OPimEvent::FRExceptions ] ); + OPimRecurrence recur( recFields ); + setRecurrence( recur ); + } + +} + + +int OPimEvent::parent() const +{ + return data->parent; +} + + +void OPimEvent::setParent( int uid ) +{ + changeOrModify(); + data->parent = uid; +} + + +QArray<int> OPimEvent::children() const +{ + if ( !data->child ) return QArray<int>(); + else + return data->child->copy(); +} + + +void OPimEvent::setChildren( const QArray<int>& arr ) +{ + changeOrModify(); + if ( data->child ) delete data->child; + + data->child = new QArray<int>( arr ); + data->child->detach(); +} + + +void OPimEvent::addChild( int uid ) +{ + changeOrModify(); + if ( !data->child ) + { + data->child = new QArray<int>( 1 ); + ( *data->child ) [ 0 ] = uid; + } + else + { + int count = data->child->count(); + data->child->resize( count + 1 ); + ( *data->child ) [ count ] = uid; + } +} + + +void OPimEvent::removeChild( int uid ) +{ + if ( !data->child || !data->child->contains( uid ) ) return ; + changeOrModify(); + QArray<int> newAr( data->child->count() - 1 ); + int j = 0; + uint count = data->child->count(); + for ( uint i = 0; i < count; i++ ) + { + if ( ( *data->child ) [ i ] != uid ) + { + newAr[ j ] = ( *data->child ) [ i ]; + j++; + } + } + ( *data->child ) = newAr; +} + + +struct OEffectiveEvent::Data : public QShared +{ + Data() : QShared() + {} + OPimEvent event; + QDate date; + QTime start, end; + QDate startDate, endDate; +bool dates : 1; +}; + + +OEffectiveEvent::OEffectiveEvent() +{ + data = new Data; + data->date = QDate::currentDate(); + data->start = data->end = QTime::currentTime(); + data->dates = false; +} + + +OEffectiveEvent::OEffectiveEvent( const OPimEvent& ev, const QDate& startDate, + Position pos ) +{ + data = new Data; + data->event = ev; + data->date = startDate; + if ( pos & Start ) + data->start = ev.startDateTime().time(); + else + data->start = QTime( 0, 0, 0 ); + + if ( pos & End ) + data->end = ev.endDateTime().time(); + else + data->end = QTime( 23, 59, 59 ); + + data->dates = false; +} + + +OEffectiveEvent::OEffectiveEvent( const OEffectiveEvent& ev ) +{ + data = ev.data; + data->ref(); +} + + +OEffectiveEvent::~OEffectiveEvent() +{ + if ( data->deref() ) + { + delete data; + data = 0; + } +} + + +OEffectiveEvent& OEffectiveEvent::operator=( const OEffectiveEvent& ev ) +{ + if ( *this == ev ) return * this; + + ev.data->ref(); + deref(); + data = ev.data; + + return *this; +} + + +void OEffectiveEvent::setStartTime( const QTime& ti ) +{ + changeOrModify(); + data->start = ti; +} + + +void OEffectiveEvent::setEndTime( const QTime& en ) +{ + changeOrModify(); + data->end = en; +} + + +void OEffectiveEvent::setEvent( const OPimEvent& ev ) +{ + changeOrModify(); + data->event = ev; +} + + +void OEffectiveEvent::setDate( const QDate& da ) +{ + changeOrModify(); + data->date = da; +} + + +void OEffectiveEvent::setEffectiveDates( const QDate& from, + const QDate& to ) +{ + if ( !from.isValid() ) + { + data->dates = false; + return ; + } + + data->startDate = from; + data->endDate = to; +} + + +QString OEffectiveEvent::description() const +{ + return data->event.description(); +} + + +QString OEffectiveEvent::location() const +{ + return data->event.location(); +} + + +QString OEffectiveEvent::note() const +{ + return data->event.note(); +} + + +OPimEvent OEffectiveEvent::event() const +{ + return data->event; +} + + +QTime OEffectiveEvent::startTime() const +{ + return data->start; +} + + +QTime OEffectiveEvent::endTime() const +{ + return data->end; +} + + +QDate OEffectiveEvent::date() const +{ + return data->date; +} + + +int OEffectiveEvent::length() const +{ + return ( data->end.hour() * 60 - data->start.hour() * 60 ) + + QABS( data->start.minute() - data->end.minute() ); +} + + +int OEffectiveEvent::size() const +{ + return ( data->end.hour() - data->start.hour() ) * 3600 + + ( data->end.minute() - data->start.minute() * 60 + + data->end.second() - data->start.second() ); +} + + +QDate OEffectiveEvent::startDate() const +{ + if ( data->dates ) + return data->startDate; + else if ( data->event.hasRecurrence() ) // single day, since multi-day should have a d pointer + return data->date; + else + return data->event.startDateTime().date(); +} + + +QDate OEffectiveEvent::endDate() const +{ + if ( data->dates ) + return data->endDate; + else if ( data->event.hasRecurrence() ) + return data->date; + else + return data->event.endDateTime().date(); +} + + +void OEffectiveEvent::deref() +{ + if ( data->deref() ) + { + delete data; + data = 0; + } +} + + +void OEffectiveEvent::changeOrModify() +{ + if ( data->count != 1 ) + { + data->deref(); + Data* d2 = new Data; + d2->event = data->event; + d2->date = data->date; + d2->start = data->start; + d2->end = data->end; + d2->startDate = data->startDate; + d2->endDate = data->endDate; + d2->dates = data->dates; + data = d2; + } +} + + +bool OEffectiveEvent::operator<( const OEffectiveEvent &e ) const +{ + if ( data->date < e.date() ) + return TRUE; + if ( data->date == e.date() ) + return ( startTime() < e.startTime() ); + else + return FALSE; +} + + +bool OEffectiveEvent::operator<=( const OEffectiveEvent &e ) const +{ + return ( data->date <= e.date() ); +} + + +bool OEffectiveEvent::operator==( const OEffectiveEvent &e ) const +{ + return ( date() == e.date() + && startTime() == e.startTime() + && endTime() == e.endTime() + && event() == e.event() ); +} + + +bool OEffectiveEvent::operator!=( const OEffectiveEvent &e ) const +{ + return !( *this == e ); +} + + +bool OEffectiveEvent::operator>( const OEffectiveEvent &e ) const +{ + return !( *this <= e ); +} + + +bool OEffectiveEvent::operator>= ( const OEffectiveEvent &e ) const +{ + return !( *this < e ); +} + +} diff --git a/libopie2/opiepim/core/opimevent.h b/libopie2/opiepim/core/opimevent.h new file mode 100644 index 0000000..949f263 --- a/dev/null +++ b/libopie2/opiepim/core/opimevent.h @@ -0,0 +1,275 @@ +/* + This file is part of the Opie Project + 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. +*/ +// CONTAINS GPLed code of TT + +#ifndef OEVENT_H +#define OEVENT_H + +/* OPIE */ +#include <opie2/opimtimezone.h> +#include <opie2/opimrecord.h> +#include <qpe/recordfields.h> +#include <qpe/palmtopuidgen.h> + +/* QT */ +#include <qstring.h> +#include <qdatetime.h> +#include <qvaluelist.h> + +namespace Opie +{ +struct OCalendarHelper +{ + /** calculate the week number of the date */ + static int week( const QDate& ); + /** calculate the occurence of week days since the start of the month */ + static int ocurrence( const QDate& ); + + // returns the dayOfWeek for the *first* day it finds (ignores + // any further days!). Returns 1 (Monday) if there isn't any day found + static int dayOfWeek( char day ); + + /** returns the diff of month */ + static int monthDiff( const QDate& first, const QDate& second ); + +}; + +class OPimNotifyManager; +class OPimRecurrence; + +/** + * This is the container for all Events. It encapsules all + * available information for a single Event + * @short container for events. + */ +class OPimEvent : public OPimRecord +{ + public: + typedef QValueList<OPimEvent> ValueList; + /** + * RecordFields contain possible attributes + * used in the Results of toMap().. + */ + enum RecordFields { + FUid = Qtopia::UID_ID, + FCategories = Qtopia::CATEGORY_ID, + FDescription = 0, + FLocation, + FType, + FAlarm, + FSound, + FRType, + FRWeekdays, + FRPosition, + FRFreq, + FRHasEndDate, + FREndDate, + FRCreated, + FRExceptions, + FStart, + FEnd, + 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 ¬ifiers() const; + + OPimRecurrence recurrence() const; + void setRecurrence( const OPimRecurrence& ); + bool hasRecurrence() const; + + QString note() const; + void setNote( const QString& note ); + + + QDateTime createdDateTime() const; + void setCreatedDateTime( const QDateTime& dt ); + + /** set the date to dt. dt is the QDateTime in localtime */ + void setStartDateTime( const QDateTime& ); + /** returns the datetime in the local timeZone */ + 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 */ + 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; + + static int rtti(); + + bool loadFromStream( QDataStream& ); + bool saveToStream( QDataStream& ) const; + + /* 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: + typedef QValueList<OEffectiveEvent> ValueList; + enum Position { MidWay, Start, End, StartEnd }; + // If we calculate the effective event of a multi-day event + // we have to figure out whether we are at the first day, + // at the end, or anywhere else ("middle"). This is important + // for the start/end times (00:00/23:59) + // MidWay: 00:00 -> 23:59, as we are "in the middle" of a multi- + // day event + // Start: start time -> 23:59 + // End: 00:00 -> end time + // Start | End == StartEnd: for single-day events (default) + // here we draw start time -> end time + OEffectiveEvent(); + OEffectiveEvent( const OPimEvent& event, const QDate& startDate, Position pos = StartEnd ); + OEffectiveEvent( const OEffectiveEvent& ); + OEffectiveEvent &operator=( const OEffectiveEvent& ); + ~OEffectiveEvent(); + + void setStartTime( const QTime& ); + void setEndTime( const QTime& ); + void setEvent( const OPimEvent& ); + void setDate( const QDate& ); + + void setEffectiveDates( const QDate& from, const QDate& to ); + + QString description() const; + QString location() const; + QString note() const; + OPimEvent event() const; + QTime startTime() const; + QTime endTime() const; + QDate date() const; + + /* return the length in hours */ + int length() const; + int size() const; + + QDate startDate() const; + QDate endDate() const; + + bool operator<( const OEffectiveEvent &e ) const; + bool operator<=( const OEffectiveEvent &e ) const; + bool operator==( const OEffectiveEvent &e ) const; + bool operator!=( const OEffectiveEvent &e ) const; + bool operator>( const OEffectiveEvent &e ) const; + bool operator>= ( const OEffectiveEvent &e ) const; + + private: + void deref(); + inline void changeOrModify(); + class Private; + Private* priv; + struct Data; + Data* data; + +}; + +} + +#endif diff --git a/libopie2/opiepim/core/opimnotify.h b/libopie2/opiepim/core/opimnotify.h index d0e40ca..4f74d2e 100644 --- a/libopie2/opiepim/core/opimnotify.h +++ b/libopie2/opiepim/core/opimnotify.h @@ -138,7 +138,7 @@ class OPimAlarm : public OPimNotify * A Reminder will be put into the * datebook * Note that the returned dateTime() may be not valid. - * In these cases one must resolve the uid and get the OEvent + * In these cases one must resolve the uid and get the OPimEvent */ class OPimReminder : public OPimNotify { diff --git a/libopie2/opiepim/core/opimnotifymanager.cpp b/libopie2/opiepim/core/opimnotifymanager.cpp index a54d597..573340a 100644 --- a/libopie2/opiepim/core/opimnotifymanager.cpp +++ b/libopie2/opiepim/core/opimnotifymanager.cpp @@ -30,7 +30,7 @@ #include "opimnotifymanager.h" /* OPIE */ -#include <opie2/oconversion.h> +#include <opie2/opimdateconversion.h> /* QT */ #include <qstringlist.h> @@ -184,7 +184,7 @@ QString OPimNotifyManager::alarmsToString() const /* only if time is valid */ if ( ( *it ).dateTime().isValid() ) { - als << OConversion::dateTimeToString( ( *it ).dateTime() ) + als << OPimDateConversion::dateTimeToString( ( *it ).dateTime() ) + ":" + QString::number( ( *it ).duration() ) + ":" + QString::number( ( *it ).sound() ) + ":"; @@ -227,8 +227,8 @@ void OPimNotifyManager::alarmsFromString( const QString& str ) QStringList alarm = QStringList::split( ":", ( *it ), TRUE ); // allow empty qWarning( "alarm: %s", alarm.join( "___" ).latin1() ); qWarning( "alarm[0]: %s %s", alarm[ 0 ].latin1(), - OConversion::dateTimeFromString( alarm[ 0 ] ).toString().latin1() ); - OPimAlarm al( alarm[ 2 ].toInt(), OConversion::dateTimeFromString( alarm[ 0 ] ), + OPimDateConversion::dateTimeFromString( alarm[ 0 ] ).toString().latin1() ); + OPimAlarm al( alarm[ 2 ].toInt(), OPimDateConversion::dateTimeFromString( alarm[ 0 ] ), alarm[ 1 ].toInt() ); add( al ); } diff --git a/libopie2/opiepim/core/opimrecordlist.h b/libopie2/opiepim/core/opimrecordlist.h new file mode 100644 index 0000000..b23138d --- a/dev/null +++ b/libopie2/opiepim/core/opimrecordlist.h @@ -0,0 +1,402 @@ +/* + This file is part of the Opie Project + Copyright (C) The Main Author <main-author@whereever.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 ORECORDLIST_H +#define ORECORDLIST_H + +/* OPIE */ +#include <opie2/opimtemplatebase.h> +#include <opie2/opimrecord.h> + +/* QT */ +#include <qarray.h> + +namespace Opie +{ + +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* ); + + /** + * The standard c'tor + */ + OPimRecordListIterator(); + ~OPimRecordListIterator(); + + OPimRecordListIterator( const OPimRecordListIterator& ); + OPimRecordListIterator &operator=( const OPimRecordListIterator& ); + + /** + * a * operator ;) + * use it like this T = (*it); + */ + T operator*(); + OPimRecordListIterator &operator++(); + OPimRecordListIterator &operator--(); + + bool operator==( const OPimRecordListIterator& it ); + bool operator!=( const OPimRecordListIterator& it ); + + /** + * the current item + */ + uint current() const; + + /** + * the number of items + */ + uint count() const; + + /** + * sets the current item + */ + 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 +{ + public: + typedef OTemplateBase<T> Base; + typedef OPimRecordListIterator<T> Iterator; + + /** + * c'tor + */ + OPimRecordList () + {} + OPimRecordList( const QArray<int>& ids, + 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; + */ + 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 ) +{ + // qWarning("OPimRecordListIterator copy c'tor"); + 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*() +{ + //qWarning("operator* %d %d", m_current, m_uids[m_current] ); + 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; +} + + +template <class T> +OPimRecordListIterator<T> &OPimRecordListIterator<T>::operator--() +{ + m_direction = false; + if ( m_current > 0 ) + { + --m_current; + m_end = false; + } + else + m_end = true; + + return *this; +} + + +template <class T> +bool OPimRecordListIterator<T>::operator==( const OPimRecordListIterator<T>& it ) +{ + + /* if both are at we're the same.... */ + if ( m_end == it.m_end ) return true; + + if ( m_uids != it.m_uids ) return false; + if ( m_current != it.m_current ) return false; + if ( m_temp != it.m_temp ) return false; + + return true; +} + + +template <class T> +bool OPimRecordListIterator<T>::operator!=( const OPimRecordListIterator<T>& it ) +{ + return !( *this == it ); +} + + +template <class T> +OPimRecordListIterator<T>::OPimRecordListIterator( const QArray<int> uids, + const Base* t ) + : m_uids( uids ), m_current( 0 ), m_temp( t ), m_end( false ), + m_direction( false ) +{ + /* if the list is empty we're already at the end of the list */ + if ( uids.count() == 0 ) + m_end = true; +} + + +template <class T> +uint OPimRecordListIterator<T>::current() const +{ + return m_current; +} + + +template <class T> +void OPimRecordListIterator<T>::setCurrent( uint cur ) +{ + if ( cur < m_uids.count() ) + { + m_end = false; + m_current = cur; + } +} +template <class T> +uint OPimRecordListIterator<T>::count() const +{ + return m_uids.count(); +} + + +template <class T> +OPimRecordList<T>::OPimRecordList( const QArray<int>& ids, + const Base* acc ) + : m_ids( ids ), m_acc( acc ) +{} + + +template <class T> +OPimRecordList<T>::~OPimRecordList() +{ + /* nothing to do here */ +} + + +template <class T> +typename OPimRecordList<T>::Iterator OPimRecordList<T>::begin() +{ + Iterator it( m_ids, m_acc ); + return it; +} + + +template <class T> +typename OPimRecordList<T>::Iterator OPimRecordList<T>::end() +{ + Iterator it( m_ids, m_acc ); + it.m_end = true; + it.m_current = m_ids.count(); + + return it; +} + + +template <class T> +uint OPimRecordList<T>::count() const +{ + return m_ids.count(); +} + + +template <class T> +T OPimRecordList<T>::operator[] ( uint i ) +{ + if ( i >= m_ids.count() ) + return T(); + /* forward */ + return m_acc->find( m_ids[ i ], m_ids, i ); +} + + +template <class T> +int OPimRecordList<T>::uidAt( uint i ) +{ + return m_ids[ i ]; +} + + +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; +} + +} +#endif diff --git a/libopie2/opiepim/core/orecur.cpp b/libopie2/opiepim/core/opimrecurrence.cpp index 5e2da25..98bd647 100644 --- a/libopie2/opiepim/core/orecur.cpp +++ b/libopie2/opiepim/core/opimrecurrence.cpp @@ -27,10 +27,10 @@ Boston, MA 02111-1307, USA. */ -#include "orecur.h" +#include "opimrecurrence.h" /* OPIE */ -#include <opie2/otimezone.h> +#include <opie2/opimtimezone.h> #include <qpe/timeconversion.h> /* QT */ @@ -41,9 +41,9 @@ namespace Opie { -struct ORecur::Data : public QShared { +struct OPimRecurrence::Data : public QShared { Data() : QShared() { - type = ORecur::NoRepeat; + type = OPimRecurrence::NoRepeat; freq = -1; days = 0; pos = 0; @@ -52,7 +52,7 @@ struct ORecur::Data : public QShared { end = QDate::currentDate(); } char days; // Q_UINT8 for 8 seven days;) - ORecur::RepeatType type; + OPimRecurrence::RepeatType type; int freq; int pos; bool hasEnd : 1; @@ -65,25 +65,25 @@ struct ORecur::Data : public QShared { }; -ORecur::ORecur() { +OPimRecurrence::OPimRecurrence() { data = new Data; } -ORecur::ORecur( const QMap<int, QString>& map ) +OPimRecurrence::OPimRecurrence( const QMap<int, QString>& map ) { - ORecur(); + OPimRecurrence(); fromMap( map ); } -ORecur::ORecur( const ORecur& rec) +OPimRecurrence::OPimRecurrence( const OPimRecurrence& rec) : data( rec.data ) { data->ref(); } -ORecur::~ORecur() { +OPimRecurrence::~OPimRecurrence() { if ( data->deref() ) { delete data; data = 0l; @@ -91,7 +91,7 @@ ORecur::~ORecur() { } -void ORecur::deref() { +void OPimRecurrence::deref() { if ( data->deref() ) { delete data; data = 0l; @@ -99,12 +99,12 @@ void ORecur::deref() { } -bool ORecur::operator==( const ORecur& )const { +bool OPimRecurrence::operator==( const OPimRecurrence& )const { return false; } -ORecur &ORecur::operator=( const ORecur& re) { +OPimRecurrence &OPimRecurrence::operator=( const OPimRecurrence& re) { if ( *this == re ) return *this; re.data->ref(); @@ -115,7 +115,7 @@ ORecur &ORecur::operator=( const ORecur& re) { } -bool ORecur::doesRecur()const { +bool OPimRecurrence::doesRecur()const { return !( type() == NoRepeat ); } @@ -124,7 +124,7 @@ bool ORecur::doesRecur()const { * we try to be smart here * */ -bool ORecur::doesRecur( const QDate& date ) { +bool OPimRecurrence::doesRecur( const QDate& date ) { /* the day before the recurrance */ QDate da = date.addDays(-1); @@ -139,7 +139,7 @@ bool ORecur::doesRecur( const QDate& date ) { // FIXME unuglify! // GPL from Datebookdb.cpp // FIXME exception list! -bool ORecur::nextOcurrence( const QDate& from, QDate& next ) { +bool OPimRecurrence::nextOcurrence( const QDate& from, QDate& next ) { bool stillLooking; stillLooking = p_nextOccurrence( from, next ); while ( stillLooking && data->list.contains(next) ) @@ -149,7 +149,7 @@ bool ORecur::nextOcurrence( const QDate& from, QDate& next ) { } -bool ORecur::p_nextOccurrence( const QDate& from, QDate& next ) { +bool OPimRecurrence::p_nextOccurrence( const QDate& from, QDate& next ) { // easy checks, first are we too far in the future or too far in the past? QDate tmpDate; @@ -423,122 +423,122 @@ bool ORecur::p_nextOccurrence( const QDate& from, QDate& next ) { } -ORecur::RepeatType ORecur::type()const{ +OPimRecurrence::RepeatType OPimRecurrence::type()const{ return data->type; } -int ORecur::frequency()const { +int OPimRecurrence::frequency()const { return data->freq; } -int ORecur::position()const { +int OPimRecurrence::position()const { return data->pos; } -char ORecur::days() const{ +char OPimRecurrence::days() const{ return data->days; } -bool ORecur::hasEndDate()const { +bool OPimRecurrence::hasEndDate()const { return data->hasEnd; } -QDate ORecur::endDate()const { +QDate OPimRecurrence::endDate()const { return data->end; } -QDate ORecur::start()const{ +QDate OPimRecurrence::start()const{ return data->start; } -QDateTime ORecur::createdDateTime()const { +QDateTime OPimRecurrence::createdDateTime()const { return data->create; } -int ORecur::repetition()const { +int OPimRecurrence::repetition()const { return data->rep; } -QString ORecur::service()const { +QString OPimRecurrence::service()const { return data->app; } -ORecur::ExceptionList& ORecur::exceptions() { +OPimRecurrence::ExceptionList& OPimRecurrence::exceptions() { return data->list; } -void ORecur::setType( const RepeatType& z) { +void OPimRecurrence::setType( const RepeatType& z) { checkOrModify(); data->type = z; } -void ORecur::setFrequency( int freq ) { +void OPimRecurrence::setFrequency( int freq ) { checkOrModify(); data->freq = freq; } -void ORecur::setPosition( int pos ) { +void OPimRecurrence::setPosition( int pos ) { checkOrModify(); data->pos = pos; } -void ORecur::setDays( char c ) { +void OPimRecurrence::setDays( char c ) { checkOrModify(); data->days = c; } -void ORecur::setEndDate( const QDate& dt) { +void OPimRecurrence::setEndDate( const QDate& dt) { checkOrModify(); data->end = dt; } -void ORecur::setCreatedDateTime( const QDateTime& t) { +void OPimRecurrence::setCreatedDateTime( const QDateTime& t) { checkOrModify(); data->create = t; } -void ORecur::setHasEndDate( bool b) { +void OPimRecurrence::setHasEndDate( bool b) { checkOrModify(); data->hasEnd = b; } -void ORecur::setRepitition( int rep ) { +void OPimRecurrence::setRepitition( int rep ) { checkOrModify(); data->rep = rep; } -void ORecur::setService( const QString& app ) { +void OPimRecurrence::setService( const QString& app ) { checkOrModify(); data->app = app; } -void ORecur::setStart( const QDate& dt ) { +void OPimRecurrence::setStart( const QDate& dt ) { checkOrModify(); data->start = dt; } -void ORecur::checkOrModify() { +void OPimRecurrence::checkOrModify() { if ( data->count != 1 ) { data->deref(); Data* d2 = new Data; @@ -558,51 +558,51 @@ void ORecur::checkOrModify() { } -QString ORecur::toString()const { +QString OPimRecurrence::toString()const { QString buf; QMap<int, QString> recMap = toMap(); buf += " rtype=\""; - buf += recMap[ORecur::RType]; + buf += recMap[OPimRecurrence::RType]; buf += "\""; if (data->days > 0 ) - buf += " rweekdays=\"" + recMap[ORecur::RWeekdays] + "\""; + buf += " rweekdays=\"" + recMap[OPimRecurrence::RWeekdays] + "\""; if ( data->pos != 0 ) - buf += " rposition=\"" + recMap[ORecur::RPosition] + "\""; + buf += " rposition=\"" + recMap[OPimRecurrence::RPosition] + "\""; - buf += " rfreq=\"" + recMap[ORecur::RFreq] + "\""; - buf += " rhasenddate=\"" + recMap[ORecur::RHasEndDate]+ "\""; + buf += " rfreq=\"" + recMap[OPimRecurrence::RFreq] + "\""; + buf += " rhasenddate=\"" + recMap[OPimRecurrence::RHasEndDate]+ "\""; if ( data->hasEnd ) buf += " enddt=\"" - + recMap[ORecur::EndDate] + + recMap[OPimRecurrence::EndDate] + "\""; - buf += " created=\"" + recMap[ORecur::Created] + "\""; + buf += " created=\"" + recMap[OPimRecurrence::Created] + "\""; if ( data->list.isEmpty() ) return buf; buf += " exceptions=\""; - buf += recMap[ORecur::Exceptions]; + buf += recMap[OPimRecurrence::Exceptions]; buf += "\" "; return buf; } -QString ORecur::rTypeString() const +QString OPimRecurrence::rTypeString() const { QString retString; switch ( data->type ) { - case ORecur::Daily: + case OPimRecurrence::Daily: retString = "Daily"; break; - case ORecur::Weekly: + case OPimRecurrence::Weekly: retString = "Weekly"; break; - case ORecur::MonthlyDay: + case OPimRecurrence::MonthlyDay: retString = "MonthlyDay"; break; - case ORecur::MonthlyDate: + case OPimRecurrence::MonthlyDate: retString = "MonthlyDate"; break; - case ORecur::Yearly: + case OPimRecurrence::Yearly: retString = "Yearly"; break; default: @@ -614,33 +614,33 @@ QString ORecur::rTypeString() const return retString; } -QMap<QString, ORecur::RepeatType> ORecur::rTypeValueConvertMap() const +QMap<QString, OPimRecurrence::RepeatType> OPimRecurrence::rTypeValueConvertMap() const { QMap<QString, RepeatType> convertMap; - convertMap.insert( QString( "Daily" ), ORecur::Daily ); - convertMap.insert( QString( "Weekly" ), ORecur::Weekly ); - convertMap.insert( QString( "MonthlyDay" ), ORecur::MonthlyDay ); - convertMap.insert( QString( "MonthlyDate" ), ORecur::MonthlyDate ); - convertMap.insert( QString( "Yearly" ), ORecur::Yearly ); - convertMap.insert( QString( "NoRepeat" ), ORecur::NoRepeat ); + convertMap.insert( QString( "Daily" ), OPimRecurrence::Daily ); + convertMap.insert( QString( "Weekly" ), OPimRecurrence::Weekly ); + convertMap.insert( QString( "MonthlyDay" ), OPimRecurrence::MonthlyDay ); + convertMap.insert( QString( "MonthlyDate" ), OPimRecurrence::MonthlyDate ); + convertMap.insert( QString( "Yearly" ), OPimRecurrence::Yearly ); + convertMap.insert( QString( "NoRepeat" ), OPimRecurrence::NoRepeat ); return convertMap; } -QMap<int, QString> ORecur::toMap() const +QMap<int, QString> OPimRecurrence::toMap() const { QMap<int, QString> retMap; - retMap.insert( ORecur::RType, rTypeString() ); - retMap.insert( ORecur::RWeekdays, QString::number( static_cast<int>( data->days ) ) ); - retMap.insert( ORecur::RPosition, QString::number(data->pos ) ); - retMap.insert( ORecur::RFreq, QString::number( data->freq ) ); - retMap.insert( ORecur::RHasEndDate, QString::number( static_cast<int>( data->hasEnd ) ) ); + retMap.insert( OPimRecurrence::RType, rTypeString() ); + retMap.insert( OPimRecurrence::RWeekdays, QString::number( static_cast<int>( data->days ) ) ); + retMap.insert( OPimRecurrence::RPosition, QString::number(data->pos ) ); + retMap.insert( OPimRecurrence::RFreq, QString::number( data->freq ) ); + retMap.insert( OPimRecurrence::RHasEndDate, QString::number( static_cast<int>( data->hasEnd ) ) ); if( data -> hasEnd ) - retMap.insert( ORecur::EndDate, QString::number( OTimeZone::utc().fromUTCDateTime( QDateTime( data->end, QTime(12,0,0) ) ) ) ); - retMap.insert( ORecur::Created, QString::number( OTimeZone::utc().fromUTCDateTime( data->create ) ) ); + retMap.insert( OPimRecurrence::EndDate, QString::number( OPimTimeZone::utc().fromUTCDateTime( QDateTime( data->end, QTime(12,0,0) ) ) ) ); + retMap.insert( OPimRecurrence::Created, QString::number( OPimTimeZone::utc().fromUTCDateTime( data->create ) ) ); if ( data->list.isEmpty() ) return retMap; @@ -656,31 +656,31 @@ QMap<int, QString> ORecur::toMap() const exceptBuf += QCString().sprintf("%04d%02d%02d", date.year(), date.month(), date.day() ); } - retMap.insert( ORecur::Exceptions, exceptBuf ); + retMap.insert( OPimRecurrence::Exceptions, exceptBuf ); return retMap; } -void ORecur::fromMap( const QMap<int, QString>& map ) +void OPimRecurrence::fromMap( const QMap<int, QString>& map ) { QMap<QString, RepeatType> repTypeMap = rTypeValueConvertMap(); - data -> type = repTypeMap[ map [ORecur::RType] ]; - data -> days = (char) map[ ORecur::RWeekdays ].toInt(); - data -> pos = map[ ORecur::RPosition ].toInt(); - data -> freq = map[ ORecur::RFreq ].toInt(); - data -> hasEnd= map[ ORecur::RHasEndDate ].toInt() ? true : false; - OTimeZone utc = OTimeZone::utc(); + data -> type = repTypeMap[ map [OPimRecurrence::RType] ]; + data -> days = (char) map[ OPimRecurrence::RWeekdays ].toInt(); + data -> pos = map[ OPimRecurrence::RPosition ].toInt(); + data -> freq = map[ OPimRecurrence::RFreq ].toInt(); + data -> hasEnd= map[ OPimRecurrence::RHasEndDate ].toInt() ? true : false; + OPimTimeZone utc = OPimTimeZone::utc(); if ( data -> hasEnd ){ - data -> end = utc.fromUTCDateTime( (time_t) map[ ORecur::EndDate ].toLong() ).date(); + data -> end = utc.fromUTCDateTime( (time_t) map[ OPimRecurrence::EndDate ].toLong() ).date(); } - data -> create = utc.fromUTCDateTime( (time_t) map[ ORecur::Created ].toLong() ).date(); + data -> create = utc.fromUTCDateTime( (time_t) map[ OPimRecurrence::Created ].toLong() ).date(); #if 0 // FIXME: Exceptions currently not supported... // Convert the list of exceptions from QString into ExceptionList data -> list.clear(); - QString exceptStr = map[ ORecur::Exceptions ]; + QString exceptStr = map[ OPimRecurrence::Exceptions ]; QStringList exceptList = QStringList::split( " ", exceptStr ); ... #endif diff --git a/libopie2/opiepim/core/orecur.h b/libopie2/opiepim/core/opimrecurrence.h index 7808897..f186cfe 100644 --- a/libopie2/opiepim/core/orecur.h +++ b/libopie2/opiepim/core/opimrecurrence.h @@ -43,7 +43,7 @@ namespace Opie { * Class to handle Recurrencies.. */ -class ORecur { +class OPimRecurrence { public: typedef QValueList<QDate> ExceptionList; @@ -54,13 +54,13 @@ class ORecur { enum Fields{ RType = 0, RWeekdays, RPosition, RFreq, RHasEndDate, EndDate, Created, Exceptions }; - ORecur(); - ORecur( const QMap<int, QString>& map ); - ORecur( const ORecur& ); - ~ORecur(); + OPimRecurrence(); + OPimRecurrence( const QMap<int, QString>& map ); + OPimRecurrence( const OPimRecurrence& ); + ~OPimRecurrence(); - ORecur &operator=( const ORecur& ); - bool operator==(const ORecur& )const; + OPimRecurrence &operator=( const OPimRecurrence& ); + bool operator==(const OPimRecurrence& )const; bool doesRecur()const; /* if it recurrs on that day */ @@ -85,7 +85,7 @@ class ORecur { bool nextOcurrence( const QDate& FromWhereToStart, QDate &recurDate ); /** - * The module this ORecur belongs to + * The module this OPimRecurrence belongs to */ QString service()const; @@ -129,8 +129,8 @@ class ORecur { class Data; Data* data; - class ORecurPrivate; - ORecurPrivate *d; + class OPimRecurrencePrivate; + OPimRecurrencePrivate *d; }; } diff --git a/libopie2/opiepim/core/opimresolver.cpp b/libopie2/opiepim/core/opimresolver.cpp index 73d7de1..eb6661a 100644 --- a/libopie2/opiepim/core/opimresolver.cpp +++ b/libopie2/opiepim/core/opimresolver.cpp @@ -72,9 +72,9 @@ OPimRecord* OPimResolver::record( int rtti ) { OPimRecord* rec = 0l; switch( rtti ) { case 1: /* todolist */ - rec = new OTodo(); + rec = new OPimTodo(); case 2: /* contact */ - rec = new OContact(); + rec = new OPimContact(); default: break; } @@ -211,12 +211,12 @@ OPimBase* OPimResolver::backend( int rtti ) { OPimBase* base = 0l; switch( rtti ) { case TodoList: - base = new OTodoAccess(); + base = new OPimTodoAccess(); break; case DateBook: break; case AddressBook: - base = new OContactAccess("Resolver"); + base = new OPimContactAccess("Resolver"); break; default: break; diff --git a/libopie2/opiepim/core/opimresolver.h b/libopie2/opiepim/core/opimresolver.h index dd6f07f..0a6dddf 100644 --- a/libopie2/opiepim/core/opimresolver.h +++ b/libopie2/opiepim/core/opimresolver.h @@ -30,7 +30,7 @@ #define OPIMRESOLVER_H /* OPIE */ -#include <opie2/otemplatebase.h> +#include <opie2/opimtemplatebase.h> /* QT */ #include <qstring.h> diff --git a/libopie2/opiepim/core/otemplatebase.h b/libopie2/opiepim/core/opimtemplatebase.h index 58cbfeb..58cbfeb 100644 --- a/libopie2/opiepim/core/otemplatebase.h +++ b/libopie2/opiepim/core/opimtemplatebase.h diff --git a/libopie2/opiepim/core/otimezone.cpp b/libopie2/opiepim/core/opimtimezone.cpp index e67715f..be21b1b 100644 --- a/libopie2/opiepim/core/otimezone.cpp +++ b/libopie2/opiepim/core/opimtimezone.cpp @@ -27,7 +27,7 @@ Boston, MA 02111-1307, USA. */ -#include "otimezone.h" +#include "opimtimezone.h" /* STD */ #include <stdio.h> @@ -100,16 +100,16 @@ time_t to_Time_t( const QDateTime& utc, const QString& str ) namespace Opie { -OTimeZone::OTimeZone( const ZoneName& zone ) +OPimTimeZone::OPimTimeZone( const ZoneName& zone ) : m_name( zone ) {} -OTimeZone::~OTimeZone() +OPimTimeZone::~OPimTimeZone() {} -bool OTimeZone::isValid() const +bool OPimTimeZone::isValid() const { return !m_name.isEmpty(); } @@ -118,25 +118,25 @@ bool OTimeZone::isValid() const * we will get the current timezone * and ask it to convert to the timezone date */ -QDateTime OTimeZone::toLocalDateTime( const QDateTime& dt ) +QDateTime OPimTimeZone::toLocalDateTime( const QDateTime& dt ) { - return OTimeZone::current().toDateTime( dt, *this ); + return OPimTimeZone::current().toDateTime( dt, *this ); } -QDateTime OTimeZone::toUTCDateTime( const QDateTime& dt ) +QDateTime OPimTimeZone::toUTCDateTime( const QDateTime& dt ) { - return OTimeZone::utc().toDateTime( dt, *this ); + return OPimTimeZone::utc().toDateTime( dt, *this ); } -QDateTime OTimeZone::fromUTCDateTime( time_t t ) +QDateTime OPimTimeZone::fromUTCDateTime( time_t t ) { return utcTime( t ); } -QDateTime OTimeZone::toDateTime( time_t t ) +QDateTime OPimTimeZone::toDateTime( time_t t ) { return utcTime( t, m_name ); } @@ -146,7 +146,7 @@ QDateTime OTimeZone::toDateTime( time_t t ) * convert dt to utc using zone.m_name * convert utc -> timeZoneDT using this->m_name */ -QDateTime OTimeZone::toDateTime( const QDateTime& dt, const OTimeZone& zone ) +QDateTime OPimTimeZone::toDateTime( const QDateTime& dt, const OPimTimeZone& zone ) { time_t utc = to_Time_t( dt, zone.m_name ); qWarning( "%d %s", utc, zone.m_name.latin1() ); @@ -154,33 +154,33 @@ QDateTime OTimeZone::toDateTime( const QDateTime& dt, const OTimeZone& zone ) } -time_t OTimeZone::fromDateTime( const QDateTime& time ) +time_t OPimTimeZone::fromDateTime( const QDateTime& time ) { return to_Time_t( time, m_name ); } -time_t OTimeZone::fromUTCDateTime( const QDateTime& time ) +time_t OPimTimeZone::fromUTCDateTime( const QDateTime& time ) { return to_Time_t( time, "UTC" ); } -OTimeZone OTimeZone::current() +OPimTimeZone OPimTimeZone::current() { QCString str = ::getenv( "TZ" ); - OTimeZone zone( str ); + OPimTimeZone zone( str ); return zone; } -OTimeZone OTimeZone::utc() +OPimTimeZone OPimTimeZone::utc() { - return OTimeZone( "UTC" ); + return OPimTimeZone( "UTC" ); } -QString OTimeZone::timeZone() const +QString OPimTimeZone::timeZone() const { return m_name; } diff --git a/libopie2/opiepim/core/otimezone.h b/libopie2/opiepim/core/opimtimezone.h index f0b4022..284e80f 100644 --- a/libopie2/opiepim/core/otimezone.h +++ b/libopie2/opiepim/core/opimtimezone.h @@ -44,12 +44,12 @@ namespace Opie * and to localtime * and time_t */ -class OTimeZone { +class OPimTimeZone { public: typedef QString ZoneName; - OTimeZone( const ZoneName& = ZoneName::null ); - virtual ~OTimeZone(); // just in case. + OPimTimeZone( const ZoneName& = ZoneName::null ); + virtual ~OPimTimeZone(); // just in case. bool isValid()const; @@ -80,7 +80,7 @@ class OTimeZone { /** * converts the QDateTime from one timezone to this timeZone */ - QDateTime toDateTime( const QDateTime&, const OTimeZone& timeZone ); + QDateTime toDateTime( const QDateTime&, const OPimTimeZone& timeZone ); /** * converts the date time into a time_t. It takes the timezone into account @@ -92,8 +92,8 @@ class OTimeZone { */ time_t fromUTCDateTime( const QDateTime& ); - static OTimeZone current(); - static OTimeZone utc(); + static OPimTimeZone current(); + static OPimTimeZone utc(); QString timeZone() const; diff --git a/libopie2/opiepim/core/opimtodo.cpp b/libopie2/opiepim/core/opimtodo.cpp new file mode 100644 index 0000000..34df807 --- a/dev/null +++ b/libopie2/opiepim/core/opimtodo.cpp @@ -0,0 +1,712 @@ +/* + This file is part of the Opie Project + Copyright (C) The Main Author <main-author@whereever.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 "opimtodo.h" + +/* OPIE */ +#include <opie2/opimstate.h> +#include <opie2/opimrecurrence.h> +#include <opie2/opimmaintainer.h> +#include <opie2/opimnotifymanager.h> +#include <opie2/opimresolver.h> +#include <qpe/palmtopuidgen.h> +#include <qpe/stringutil.h> +#include <qpe/palmtoprecord.h> +#include <qpe/stringutil.h> +#include <qpe/categories.h> +#include <qpe/categoryselect.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; + } + + 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(); + // qWarning("ref up"); +} + + +OPimTodo::~OPimTodo() +{ + + // qWarning("~OPimTodo " ); + if ( data->deref() ) + { + // qWarning("OPimTodo::dereffing"); + 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 ) +{ + // qWarning("OPimTodoData " + summary); + 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 ) +{ + // qWarning("OPimTodoData" + summary); + 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 ®Exp ) 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 ); + return true; + } + else if ( data->desc.find( regExp ) != -1 ) + { + 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; +} + + +bool OPimTodo::hasStartDate() const +{ + return data->start.isValid(); +} + + +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; +} + + +QDate OPimTodo::dueDate() const +{ + return data->date; +} + + +QDate OPimTodo::startDate() const +{ + return data->start; +} + + +QDate OPimTodo::completedDate() const +{ + return data->completed; +} + + +QString OPimTodo::description() const +{ + return data->desc; +} + + +bool OPimTodo::hasState() const +{ + if ( !data->state ) return false; + return ( data->state->state() != OPimState::Undefined ); +} + + +OPimState OPimTodo::state() const +{ + if ( !data->state ) + { + OPimState state; + return state; + } + + return ( *data->state ); +} + + +bool OPimTodo::hasRecurrence() const +{ + if ( !data->recur ) return false; + return data->recur->doesRecur(); +} + + +OPimRecurrence OPimTodo::recurrence() const +{ + if ( !data->recur ) return OPimRecurrence(); + + return ( *data->recur ); +} + + +bool OPimTodo::hasMaintainer() const +{ + if ( !data->maintainer ) return false; + + return ( data->maintainer->mode() != OPimMaintainer::Undefined ); +} + + +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 ) +{ + // qWarning( "desc " + desc ); + 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; +} + + +void OPimTodo::setStartDate( const QDate& date ) +{ + changeOrModify(); + data->start = date; +} + + +void OPimTodo::setCompletedDate( const QDate& date ) +{ + changeOrModify(); + data->completed = date; +} + + +void OPimTodo::setState( const OPimState& state ) +{ + changeOrModify(); + if ( data->state ) + ( *data->state ) = state; + else + data->state = new 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( ) +{ + 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 +{ + QString text; + QStringList catlist; + + // summary + text += "<b><h3><img src=\"todo/TodoList\"> "; + if ( !summary().isEmpty() ) + { + text += Qtopia::escapeString( summary() ).replace( QRegExp( "[\n]" ), "" ); + } + text += "</h3></b><br><hr><br>"; + + // description + if ( !description().isEmpty() ) + { + text += "<b>" + QObject::tr( "Description:" ) + "</b><br>"; + text += Qtopia::escapeString( description() ).replace( QRegExp( "[\n]" ), "<br>" ) + "<br>"; + } + + // priority + int priorityval = priority(); + text += "<b>" + QObject::tr( "Priority:" ) + " </b><img src=\"todo/priority" + + QString::number( priorityval ) + "\"> "; + + switch ( priorityval ) + { + case 1 : text += QObject::tr( "Very high" ); + break; + case 2 : text += QObject::tr( "High" ); + break; + case 3 : text += QObject::tr( "Normal" ); + break; + case 4 : text += QObject::tr( "Low" ); + break; + case 5 : text += QObject::tr( "Very low" ); + break; + }; + text += "<br>"; + + // progress + text += "<b>" + QObject::tr( "Progress:" ) + " </b>" + + QString::number( progress() ) + " %<br>"; + + // due date + if ( hasDueDate() ) + { + QDate dd = dueDate(); + int off = QDate::currentDate().daysTo( dd ); + + text += "<b>" + QObject::tr( "Deadline:" ) + " </b><font color=\""; + if ( off < 0 ) + text += "#FF0000"; + else if ( off == 0 ) + text += "#FFFF00"; + else if ( off > 0 ) + text += "#00FF00"; + + text += "\">" + dd.toString() + "</font><br>"; + } + + // categories + text += "<b>" + QObject::tr( "Category:" ) + "</b> "; + text += categoryNames( "Todo List" ).join( ", " ); + text += "<br>"; + + return text; +} + + +bool OPimTodo::hasNotifiers() const +{ + if ( !data->notifiers ) return false; + return !data->notifiers->isEmpty(); +} + + +OPimNotifyManager& OPimTodo::notifiers() +{ + if ( !data->notifiers ) + data->notifiers = new OPimNotifyManager; + return ( *data->notifiers ); +} + + +const OPimNotifyManager& OPimTodo::notifiers() const +{ + if ( !data->notifiers ) + data->notifiers = new OPimNotifyManager; + + return ( *data->notifiers ); +} + + +bool OPimTodo::operator<( const OPimTodo &toDoEvent ) const +{ + if ( !hasDueDate() && !toDoEvent.hasDueDate() ) return true; + if ( !hasDueDate() && toDoEvent.hasDueDate() ) return false; + if ( hasDueDate() && toDoEvent.hasDueDate() ) + { + if ( dueDate() == toDoEvent.dueDate() ) + { // let's the priority decide + return priority() < toDoEvent.priority(); + } + else + { + return dueDate() < toDoEvent.dueDate(); + } + } + return false; +} + + +bool OPimTodo::operator<=( const OPimTodo &toDoEvent ) const +{ + if ( !hasDueDate() && !toDoEvent.hasDueDate() ) return true; + if ( !hasDueDate() && toDoEvent.hasDueDate() ) return true; + if ( hasDueDate() && toDoEvent.hasDueDate() ) + { + if ( dueDate() == toDoEvent.dueDate() ) + { // let's the priority decide + return priority() <= toDoEvent.priority(); + } + else + { + return dueDate() <= toDoEvent.dueDate(); + } + } + return true; +} + + +bool OPimTodo::operator>( const OPimTodo &toDoEvent ) const +{ + if ( !hasDueDate() && !toDoEvent.hasDueDate() ) return false; + if ( !hasDueDate() && toDoEvent.hasDueDate() ) return false; + if ( hasDueDate() && toDoEvent.hasDueDate() ) + { + if ( dueDate() == toDoEvent.dueDate() ) + { // let's the priority decide + return priority() > toDoEvent.priority(); + } + else + { + return dueDate() > toDoEvent.dueDate(); + } + } + return false; +} + + +bool OPimTodo::operator>=( const OPimTodo &toDoEvent ) const +{ + if ( !hasDueDate() && !toDoEvent.hasDueDate() ) return true; + if ( !hasDueDate() && toDoEvent.hasDueDate() ) return false; + if ( hasDueDate() && toDoEvent.hasDueDate() ) + { + if ( dueDate() == toDoEvent.dueDate() ) + { // let's the priority decide + return priority() > toDoEvent.priority(); + } + else + { + return dueDate() > toDoEvent.dueDate(); + } + } + 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() +{ + + // qWarning("deref in ToDoEvent"); + if ( data->deref() ) + { + // qWarning("deleting"); + delete data; + data = 0; + } +} + + +OPimTodo &OPimTodo::operator=( const OPimTodo &item ) +{ + if ( this == &item ) return * this; + + OPimRecord::operator=( item ); + //qWarning("operator= ref "); + 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 ) + { + qWarning( "changeOrModify" ); + 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 +{ + return QString::null; +} + + +int OPimTodo::rtti() +{ + return OPimResolver::TodoList; +} + +} diff --git a/libopie2/opiepim/core/opimtodo.h b/libopie2/opiepim/core/opimtodo.h new file mode 100644 index 0000000..5304180 --- a/dev/null +++ b/libopie2/opiepim/core/opimtodo.h @@ -0,0 +1,320 @@ +/* + This file is part of the Opie Project + Copyright (C) The Main Author <main-author@whereever.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 OTODOEVENT_H +#define OTODOEVENT_H + +/* OPIE */ +#include <opie2/opimrecord.h> +#include <qpe/recordfields.h> +#include <qpe/palmtopuidgen.h> + +/* QT */ +#include <qarray.h> +#include <qmap.h> +#include <qregexp.h> +#include <qstringlist.h> +#include <qdatetime.h> +#include <qvaluelist.h> + +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, + Maintainer, + StartDate, + CompletedDate + }; + 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, + const QArray<int>& category, + const QString& summary = QString::null, + const QString& description = QString::null, + ushort progress = 0, + bool hasDate = false, QDate date = QDate::currentDate(), + int uid = 0 /* empty */ ); + + /** Copy c'tor + * + */ + OPimTodo( const OPimTodo & ); + + /** + *destructor + */ + ~OPimTodo(); + + /** + * Is this event completed? + */ + bool isCompleted() const; + + /** + * Does this Event have a deadline + */ + bool hasDueDate() const; + bool hasStartDate() const; + bool hasCompletedDate() const; + + /** + * What is the priority? + */ + int priority() const ; + + /** + * progress as ushort 0, 20, 40, 60, 80 or 100% + */ + ushort progress() const; + + /** + * The due Date + */ + QDate dueDate() const; + + /** + * When did it start? + */ + QDate startDate() const; + + /** + * When was it completed? + */ + QDate completedDate() const; + + /** + * does it have a state? + */ + bool hasState() const; + + /** + * What is the state of this OPimTodo? + */ + OPimState state() const; + + /** + * has recurrence? + */ + bool hasRecurrence() const; + + /** + * the recurrance of this + */ + OPimRecurrence recurrence() const; + + /** + * does this OPimTodo have a maintainer? + */ + bool hasMaintainer() const; + + /** + * the Maintainer of this OPimTodo + */ + OPimMaintainer maintainer() const; + + /** + * The description of the todo + */ + QString description() const; + + /** + * A small summary of the todo + */ + QString summary() const; + + /** + * @reimplemented + * Return this todoevent in a RichText formatted QString + */ + QString toRichText() const; + + bool hasNotifiers() const; + /* + * FIXME check if the sharing is still fine!! -zecke + * ### CHECK If API is fine + */ + /** + * return a reference to our notifiers... + */ + OPimNotifyManager ¬ifiers(); + + /** + * + */ + const OPimNotifyManager ¬ifiers() const; + + /** + * reimplementations + */ + QString type() const; + QString toShortText() const; + QString recordField( int id ) const; + + /** + * toMap puts all data into the map. int relates + * to ToDoEvent RecordFields enum + */ + QMap<int, QString> toMap() const; + + /** + * Set if this Todo is completed + */ + void setCompleted( bool completed ); + + /** + * set if this todo got an end data + */ + void setHasDueDate( bool hasDate ); + // FIXME we do not have these for start, completed + // cause we'll use the isNull() of QDate for figuring + // out if it's has a date... + // decide what to do here? -zecke + + /** + * Set the priority of the Todo + */ + void setPriority( int priority ); + + /** + * Set the progress. + */ + void setProgress( ushort progress ); + + /** + * set the end date + */ + void setDueDate( const QDate& date ); + + /** + * set the start date + */ + void setStartDate( const QDate& date ); + + /** + * set the completed date + */ + void setCompletedDate( const QDate& date ); + + void setRecurrence( const 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(); + + + 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 ); + + static int rtti(); + + 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 2a3695d..83750d5 100644 --- a/libopie2/opiepim/core/otodoaccess.cpp +++ b/libopie2/opiepim/core/otodoaccess.cpp @@ -35,28 +35,28 @@ #include <opie2/obackendfactory.h> namespace Opie { -OTodoAccess::OTodoAccess( OTodoAccessBackend* end, enum Access ) - : QObject(), OPimAccessTemplate<OTodo>( end ), m_todoBackEnd( end ) +OPimTodoAccess::OPimTodoAccess( OPimTodoAccessBackend* end, enum Access ) + : QObject(), OPimAccessTemplate<OPimTodo>( end ), m_todoBackEnd( end ) { // if (end == 0l ) -// m_todoBackEnd = new OTodoAccessBackendSQL( QString::null); +// m_todoBackEnd = new OPimTodoAccessBackendSQL( QString::null); // Zecke: Du musst hier noch fr das XML-Backend einen Appnamen bergeben ! if (end == 0l ) - m_todoBackEnd = OBackendFactory<OTodoAccessBackend>::Default ("todo", QString::null); + m_todoBackEnd = OBackendFactory<OPimTodoAccessBackend>::Default ("todo", QString::null); setBackEnd( m_todoBackEnd ); } -OTodoAccess::~OTodoAccess() { -// qWarning("~OTodoAccess"); +OPimTodoAccess::~OPimTodoAccess() { +// qWarning("~OPimTodoAccess"); } -void OTodoAccess::mergeWith( const QValueList<OTodo>& list ) { - QValueList<OTodo>::ConstIterator it; +void OPimTodoAccess::mergeWith( const QValueList<OPimTodo>& list ) { + QValueList<OPimTodo>::ConstIterator it; for ( it = list.begin(); it != list.end(); ++it ) { replace( (*it) ); } } -OTodoAccess::List OTodoAccess::effectiveToDos( const QDate& start, +OPimTodoAccess::List OPimTodoAccess::effectiveToDos( const QDate& start, const QDate& end, bool includeNoDates ) { QArray<int> ints = m_todoBackEnd->effectiveToDos( start, end, includeNoDates ); @@ -64,29 +64,29 @@ OTodoAccess::List OTodoAccess::effectiveToDos( const QDate& start, List lis( ints, this ); return lis; } -OTodoAccess::List OTodoAccess::effectiveToDos( const QDate& start, +OPimTodoAccess::List OPimTodoAccess::effectiveToDos( const QDate& start, bool includeNoDates ) { return effectiveToDos( start, QDate::currentDate(), includeNoDates ); } -OTodoAccess::List OTodoAccess::overDue() { +OPimTodoAccess::List OPimTodoAccess::overDue() { List lis( m_todoBackEnd->overDue(), this ); return lis; } /* sort order */ -OTodoAccess::List OTodoAccess::sorted( bool ascending, int sort,int filter, int cat ) { +OPimTodoAccess::List OPimTodoAccess::sorted( bool ascending, int sort,int filter, int cat ) { QArray<int> ints = m_todoBackEnd->sorted( ascending, sort, filter, cat ); - OTodoAccess::List list( ints, this ); + OPimTodoAccess::List list( ints, this ); return list; } -void OTodoAccess::removeAllCompleted() { +void OPimTodoAccess::removeAllCompleted() { m_todoBackEnd->removeAllCompleted(); } -QBitArray OTodoAccess::backendSupport( const QString& ) const{ +QBitArray OPimTodoAccess::backendSupport( const QString& ) const{ return m_todoBackEnd->supports(); } -bool OTodoAccess::backendSupports( int attr, const QString& ar) const{ +bool OPimTodoAccess::backendSupports( int attr, const QString& ar) const{ return backendSupport(ar).testBit( attr ); } diff --git a/libopie2/opiepim/core/otodoaccess.h b/libopie2/opiepim/core/otodoaccess.h index e13d277..51f3793 100644 --- a/libopie2/opiepim/core/otodoaccess.h +++ b/libopie2/opiepim/core/otodoaccess.h @@ -32,18 +32,18 @@ #include <qobject.h> #include <qvaluelist.h> -#include <opie2/otodo.h> +#include <opie2/opimtodo.h> #include <opie2/otodoaccessbackend.h> #include <opie2/opimaccesstemplate.h> namespace Opie { /** - * OTodoAccess + * OPimTodoAccess * the class to get access to * the todolist */ -class OTodoAccess : public QObject, public OPimAccessTemplate<OTodo> { +class OPimTodoAccess : public QObject, public OPimAccessTemplate<OPimTodo> { Q_OBJECT public: enum SortOrder { Completed = 0, @@ -58,8 +58,8 @@ public: * the default resource will be * picked up */ - OTodoAccess( OTodoAccessBackend* = 0l, enum Access acc = Random ); - ~OTodoAccess(); + OPimTodoAccess( OPimTodoAccessBackend* = 0l, enum Access acc = Random ); + ~OPimTodoAccess(); /* our functions here */ @@ -81,7 +81,7 @@ public: /** - * return overdue OTodos + * return overdue OPimTodos */ List overDue(); @@ -91,10 +91,10 @@ public: List sorted( bool ascending, int sortOrder, int sortFilter, int cat ); /** - * merge a list of OTodos into + * merge a list of OPimTodos into * the resource */ - void mergeWith( const QValueList<OTodo>& ); + void mergeWith( const QValueList<OPimTodo>& ); /** * delete all already completed items @@ -104,7 +104,7 @@ public: /** * request information about what a backend supports. * Supports in the sense of beeing able to store. - * This is related to the enum in OTodo + * This is related to the enum in OPimTodo * * @param backend Will be used in the future when we support multiple backend */ @@ -118,17 +118,17 @@ public: bool backendSupports( int attr, const QString& backend = QString::null )const; signals: /** - * if the OTodoAccess was changed + * if the OPimTodoAccess was changed */ - void changed( const OTodoAccess* ); - void changed( const OTodoAccess*, int uid ); - void added( const OTodoAccess*, int uid ); - void removed( const OTodoAccess*, int uid ); + 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; - OTodoAccessBackend* m_todoBackEnd; - class OTodoAccessPrivate; - OTodoAccessPrivate* d; + OPimTodoAccessBackend* m_todoBackEnd; + class OPimTodoAccessPrivate; + OPimTodoAccessPrivate* d; }; } |