*phew* here is the class and file rename patch. not converted yet: backend,

but that will be not visible to application classes so we can change it later.

53 files changed, 1266 insertions, 1267 deletions

diff --git a/libopie2/opiepim/backend/obackendfactory.h b/libopie2/opiepim/backend/obackendfactory.h
index 346e2f5..06421d1 100644
--- a/libopie2/opiepim/backend/obackendfactory.h
+++ b/libopie2/opiepim/backend/obackendfactory.h
@@ -55,17 +55,17 @@ class OBackendPrivate;
 /**
  * This class is our factory. It will give us the default implementations
  * of at least Todolist, Contacts and Datebook. In the future this class will
  * allow users to switch the backend with ( XML->SQLite ) without the need
  * to recompile.#
  * This class as the whole PIM Api is making use of templates
  *
  * <pre>
- *   OTodoAccessBackend* backend = OBackEndFactory<OTodoAccessBackend>::Default("todo", QString::null );
+ *   OPimTodoAccessBackend* backend = OBackEndFactory<OPimTodoAccessBackend>::Default("todo", QString::null );
  *   backend->load();
  * </pre>
  *
  * @author Stefan Eilers
  * @version 0.1
  */
 template<class T>
 class OBackendFactory
@@ -103,33 +103,33 @@ class OBackendFactory
 
                 int *find = dict[ backendName ];
                 if (!find ) return 0;
 
 		switch ( *find ){
 		case TODO:
 #ifdef __USE_SQL
 			if ( backend == "sql" )
-				return (T*) new OTodoAccessBackendSQL("");
+				return (T*) new OPimTodoAccessBackendSQL("");
 #else
 			if ( backend == "sql" )
 				qWarning ("OBackendFactory:: sql Backend for TODO not implemented! Using XML instead!");
 #endif
 
-			return (T*) new OTodoAccessXML( appName );
+			return (T*) new OPimTodoAccessXML( appName );
 		case CONTACT:
 #ifdef __USE_SQL
 			if ( backend == "sql" )
-				return (T*) new OContactAccessBackend_SQL("");
+				return (T*) new OPimContactAccessBackend_SQL("");
 #else
 			if ( backend == "sql" )
 				qWarning ("OBackendFactory:: sql Backend for CONTACT not implemented! Using XML instead!");
 #endif
 
-			return (T*) new OContactAccessBackend_XML( appName );
+			return (T*) new OPimContactAccessBackend_XML( appName );
 		case DATE:
 #ifdef __USE_SQL
 			if ( backend == "sql" )
 				return (T*) new ODateBookAccessBackend_SQL("");
 #else
 			if ( backend == "sql" )
                             qWarning("OBackendFactory:: sql Backend for DATEBOOK not implemented! Using XML instead!");
 #endif
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend.h b/libopie2/opiepim/backend/ocontactaccessbackend.h
index 6113cea..8436adc 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend.h
+++ b/libopie2/opiepim/backend/ocontactaccessbackend.h
@@ -34,42 +34,42 @@
  * Copyright (c) 2002 by Stefan Eilers (Eilers.Stefan@epost.de)
  * Copyright (c) 2002 by Holger Freyther (zecke@handhelds.org)
  *
  */
 
 #ifndef _OCONTACTACCESSBACKEND_H_
 #define _OCONTACTACCESSBACKEND_H_
 
-#include <opie2/ocontact.h>
+#include <opie2/opimcontact.h>
 #include <opie2/opimaccessbackend.h>
 
 #include <qregexp.h>
 
 namespace Opie {
 /**
  * This class represents the interface of all Contact Backends.
  * Derivates of this class will be used to access the contacts.
  * As implementation currently XML and vCard exist. This class needs to be implemented
  * if you want to provide your own storage.
  * In all queries a list of uids is passed on instead of loading the actual record!
  *
- * @see OContactAccessBackend_VCard
- * @see OContactAccessBackend_XML
+ * @see OPimContactAccessBackend_VCard
+ * @see OPimContactAccessBackend_XML
  */
-class OContactAccessBackend: public OPimAccessBackend<OContact> {
+class OPimContactAccessBackend: public OPimAccessBackend<OPimContact> {
  public:
 	/**
 	 * @todo make non line in regard to BC guide of KDE
 	 */
-	OContactAccessBackend() {}
+	OPimContactAccessBackend() {}
 	/**
 	 * @todo make non inline in regard to the BC guide of KDE
 	 */
-	virtual ~OContactAccessBackend() {}
+	virtual ~OPimContactAccessBackend() {}
 
 
 	/**
          * Return if database was changed externally.
 	 * This may just make sense on file based databases like a XML-File.
 	 * It is used to prevent to overwrite the current database content
 	 * if the file was already changed by something else !
 	 * If this happens, we have to reload before save our data.
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp b/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
index d0c8052..f121cc2 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_sql.cpp
@@ -34,18 +34,18 @@
 
 #include <qarray.h>
 #include <qdatetime.h>
 #include <qstringlist.h>
 
 #include <qpe/global.h>
 #include <qpe/recordfields.h>
 
-#include <opie2/ocontactfields.h>
-#include <opie2/oconversion.h>
+#include <opie2/opimcontactfields.h>
+#include <opie2/opimdateconversion.h>
 #include <opie2/osqldriver.h>
 #include <opie2/osqlresult.h>
 #include <opie2/osqlmanager.h>
 #include <opie2/osqlquery.h>
 
 
 
 
@@ -100,25 +100,25 @@ namespace Opie {
 	class LoadQuery : public OSQLQuery {
 	public:
 		LoadQuery();
 		~LoadQuery();
 		QString query()const;
 	};
 	
 	/**
-	 * inserts/adds a OContact to the table
+	 * inserts/adds a OPimContact to the table
 	 */
 	class InsertQuery : public OSQLQuery {
 	public:
-		InsertQuery(const OContact& );
+		InsertQuery(const OPimContact& );
 		~InsertQuery();
 		QString query()const;
 	private:
-		OContact m_contact;
+		OPimContact m_contact;
 	};
 	
 
 	/**
 	 * removes one from the table
 	 */
 	class RemoveQuery : public OSQLQuery {
 	public:
@@ -171,17 +171,17 @@ namespace Opie {
 	CreateQuery::CreateQuery() : OSQLQuery() {}
 	CreateQuery::~CreateQuery() {}
 	QString CreateQuery::query()const {
 		QString qu;
 #ifdef __STORE_HORIZONTAL_
 
 		qu += "create table addressbook( uid PRIMARY KEY ";
 
-		QStringList fieldList = OContactFields::untrfields( false );
+		QStringList fieldList = OPimContactFields::untrfields( false );
 		for ( QStringList::Iterator it = ++fieldList.begin(); it != fieldList.end(); ++it ){
 			qu += QString( ",\"%1\" VARCHAR(10)" ).arg( *it );
 		}
 		qu += " );";
 		
 		qu += "create table custom_data( uid INTEGER, id INTEGER, type VARCHAR, priority INTEGER, value VARCHAR, PRIMARY KEY /* identifier */ (uid, id) );";
 
 #else
@@ -218,39 +218,39 @@ namespace Opie {
 		qu += "select uid from addressbook where type = 'Last Name'";
 #  endif // __USE_SUPERFAST_LOADQUERY 
 #endif // __STORE_HORIZONTAL_
 		
 		return qu;
 	}
 	
 
-	InsertQuery::InsertQuery( const OContact& contact )
+	InsertQuery::InsertQuery( const OPimContact& contact )
 		: OSQLQuery(), m_contact( contact ) {
 	}
 
 	InsertQuery::~InsertQuery() {
 	}
 
 	/*
-	 * converts from a OContact to a query
+	 * converts from a OPimContact to a query
 	 */
 	QString InsertQuery::query()const{
 
 #ifdef __STORE_HORIZONTAL_
 		QString qu;
 		qu  += "insert into addressbook VALUES( " + 
 			QString::number( m_contact.uid() );
 
 		// Get all information out of the contact-class
 		// Remember: The category is stored in contactMap, too ! 
 		QMap<int, QString> contactMap = m_contact.toMap();
 		
-		QStringList fieldList = OContactFields::untrfields( false );
-		QMap<QString, int> translate = OContactFields::untrFieldsToId();
+		QStringList fieldList = OPimContactFields::untrfields( false );
+		QMap<QString, int> translate = OPimContactFields::untrFieldsToId();
 		for ( QStringList::Iterator it = ++fieldList.begin(); it != fieldList.end(); ++it ){
 			// Convert Column-String to Id and get value for this id..
 			// Hmmm.. Maybe not very cute solution..
 			int id = translate[*it];
 			switch ( id ){
 			case Qtopia::Birthday:{
 				// These entries should stored in a special format
 				// year-month-day
@@ -290,17 +290,17 @@ namespace Opie {
 #else
 		// Get all information out of the contact-class
 		// Remember: The category is stored in contactMap, too ! 
 		QMap<int, QString> contactMap = m_contact.toMap();
 		
 		QMap<QString, QString> addressbook_db;
 		
 		// Get the translation from the ID to the String
-		QMap<int, QString> transMap = OContactFields::idToUntrFields();
+		QMap<int, QString> transMap = OPimContactFields::idToUntrFields();
 		
 		for( QMap<int, QString>::Iterator it = contactMap.begin(); 
 		     it != contactMap.end(); ++it ){
 			switch ( it.key() ){
 			case Qtopia::Birthday:{
 				// These entries should stored in a special format
 				// year-month-day
 				QDate day = m_contact.birthday();
@@ -454,172 +454,172 @@ namespace Opie {
 
 };
 
 
 /* --------------------------------------------------------------------------- */
 
 namespace Opie {
 
-OContactAccessBackend_SQL::OContactAccessBackend_SQL ( const QString& /* appname */, 
+OPimContactAccessBackend_SQL::OPimContactAccessBackend_SQL ( const QString& /* appname */, 
 						       const QString& filename ): 
-	OContactAccessBackend(), m_changed(false), m_driver( NULL )
+	OPimContactAccessBackend(), m_changed(false), m_driver( NULL )
 {
-	qWarning("C'tor OContactAccessBackend_SQL starts");
+	qWarning("C'tor OPimContactAccessBackend_SQL starts");
 	QTime t;
 	t.start();
 
 	/* Expecting to access the default filename if nothing else is set */
 	if ( filename.isEmpty() ){
 		m_fileName = Global::applicationFileName( "addressbook","addressbook.db" );
 	} else
 		m_fileName = filename;
 
 	// Get the standart sql-driver from the OSQLManager..
 	OSQLManager man;
 	m_driver = man.standard();
 	m_driver->setUrl( m_fileName );	
 
 	load();
 
-	qWarning("C'tor OContactAccessBackend_SQL ends: %d ms", t.elapsed() );
+	qWarning("C'tor OPimContactAccessBackend_SQL ends: %d ms", t.elapsed() );
 }
 
-OContactAccessBackend_SQL::~OContactAccessBackend_SQL ()
+OPimContactAccessBackend_SQL::~OPimContactAccessBackend_SQL ()
 {
 	if( m_driver )
 		delete m_driver;
 }
 
-bool OContactAccessBackend_SQL::load ()
+bool OPimContactAccessBackend_SQL::load ()
 {
 	if (!m_driver->open() )
 		return false;
 
 	// Don't expect that the database exists.
 	// It is save here to create the table, even if it
 	// do exist. ( Is that correct for all databases ?? )
 	CreateQuery creat;
 	OSQLResult res = m_driver->query( &creat );
 
 	update();
 
 	return true;
 
 }
 
-bool OContactAccessBackend_SQL::reload()
+bool OPimContactAccessBackend_SQL::reload()
 {
 	return load();
 }
 
-bool OContactAccessBackend_SQL::save()
+bool OPimContactAccessBackend_SQL::save()
 {
 	return m_driver->close();  // Shouldn't m_driver->sync be better than close ? (eilers)
 }
 
 
-void OContactAccessBackend_SQL::clear ()
+void OPimContactAccessBackend_SQL::clear ()
 {
 	ClearQuery cle;
 	OSQLResult res = m_driver->query( &cle );
 
 	reload();
 }
 
-bool OContactAccessBackend_SQL::wasChangedExternally()
+bool OPimContactAccessBackend_SQL::wasChangedExternally()
 {
 	return false;
 }
 
-QArray<int> OContactAccessBackend_SQL::allRecords() const
+QArray<int> OPimContactAccessBackend_SQL::allRecords() const
 {
 
 	// FIXME: Think about cute handling of changed tables..
 	// Thus, we don't have to call update here...
  	if ( m_changed )  
-		((OContactAccessBackend_SQL*)this)->update();
+		((OPimContactAccessBackend_SQL*)this)->update();
 	
 	return m_uids;
 }
 
-bool OContactAccessBackend_SQL::add ( const OContact &newcontact )
+bool OPimContactAccessBackend_SQL::add ( const OPimContact &newcontact )
 {
 	InsertQuery ins( newcontact );
 	OSQLResult res = m_driver->query( &ins );
 
 	if ( res.state() == OSQLResult::Failure )
 		return false;
 
 	int c = m_uids.count();
 	m_uids.resize( c+1 );
 	m_uids[c] = newcontact.uid();
 	
 	return true;
 }
 
 
-bool OContactAccessBackend_SQL::remove ( int uid )
+bool OPimContactAccessBackend_SQL::remove ( int uid )
 {
 	RemoveQuery rem( uid );
 	OSQLResult res = m_driver->query(&rem );
 
 	if ( res.state() == OSQLResult::Failure )
 		return false;
 
 	m_changed = true;
 
 	return true;
 }
 
-bool OContactAccessBackend_SQL::replace ( const OContact &contact )
+bool OPimContactAccessBackend_SQL::replace ( const OPimContact &contact )
 {
 	if ( !remove( contact.uid() ) )
 		return false;
 	
 	return add( contact );
 }
 
 
-OContact OContactAccessBackend_SQL::find ( int uid ) const
+OPimContact OPimContactAccessBackend_SQL::find ( int uid ) const
 {
-	qWarning("OContactAccessBackend_SQL::find()");
+	qWarning("OPimContactAccessBackend_SQL::find()");
 	QTime t;
 	t.start();
 
-	OContact retContact( requestNonCustom( uid ) );
+	OPimContact retContact( requestNonCustom( uid ) );
 	retContact.setExtraMap( requestCustom( uid ) );
 
-	qWarning("OContactAccessBackend_SQL::find() needed: %d ms", t.elapsed() );
+	qWarning("OPimContactAccessBackend_SQL::find() needed: %d ms", t.elapsed() );
 	return retContact;
 }
 
 
 
-QArray<int> OContactAccessBackend_SQL::queryByExample ( const OContact &query, int settings, const QDateTime& d = QDateTime() )
+QArray<int> OPimContactAccessBackend_SQL::queryByExample ( const OPimContact &query, int settings, const QDateTime& d = QDateTime() )
 {
 	QString qu = "SELECT uid FROM addressbook WHERE";
 
 	QMap<int, QString> queryFields = query.toMap();
-	QStringList fieldList = OContactFields::untrfields( false );
-	QMap<QString, int> translate = OContactFields::untrFieldsToId();
+	QStringList fieldList = OPimContactFields::untrfields( false );
+	QMap<QString, int> translate = OPimContactFields::untrFieldsToId();
 
 	// Convert every filled field to a SQL-Query
 	bool isAnyFieldSelected = false;
 	for ( QStringList::Iterator it = ++fieldList.begin(); it != fieldList.end(); ++it ){
 		int id = translate[*it];
 		QString queryStr = queryFields[id];
 		if ( !queryStr.isEmpty() ){
 			isAnyFieldSelected = true;
 			switch( id ){
 			default:
 				// Switching between case sensitive and insensitive...
 				// LIKE is not case sensitive, GLOB is case sensitive
 				// Do exist a better solution to switch this ?
-				if ( settings & OContactAccess::IgnoreCase )
+				if ( settings & OPimContactAccess::IgnoreCase )
 					qu += "(\"" + *it + "\"" + " LIKE " + "'" 
 						+ queryStr.replace(QRegExp("\\*"),"%") + "'" + ") AND "; 
 				else
 					qu += "(\"" + *it + "\"" + " GLOB " + "'" 
 						+ queryStr + "'" + ") AND "; 
 					
 			}
 		}
@@ -638,77 +638,77 @@ QArray<int> OContactAccessBackend_SQL::queryByExample ( const OContact &query, i
 		return empty;
 	}
 
 	QArray<int> list = extractUids( res );
 
 	return list;		
 }
 
-QArray<int> OContactAccessBackend_SQL::matchRegexp(  const QRegExp &r ) const
+QArray<int> OPimContactAccessBackend_SQL::matchRegexp(  const QRegExp &r ) const
 {
 	QArray<int> nix(0);
 	return nix;
 }
 
-const uint OContactAccessBackend_SQL::querySettings()
+const uint OPimContactAccessBackend_SQL::querySettings()
 {
-	return OContactAccess::IgnoreCase 
-		|| OContactAccess::WildCards;
+	return OPimContactAccess::IgnoreCase 
+		|| OPimContactAccess::WildCards;
 }
 
-bool OContactAccessBackend_SQL::hasQuerySettings (uint querySettings) const
+bool OPimContactAccessBackend_SQL::hasQuerySettings (uint querySettings) const
 {
-	/* OContactAccess::IgnoreCase, DateDiff, DateYear, DateMonth, DateDay
+	/* OPimContactAccess::IgnoreCase, DateDiff, DateYear, DateMonth, DateDay
 	 * may be added with any of the other settings. IgnoreCase should never used alone.
 	 * Wildcards, RegExp, ExactMatch should never used at the same time...
 	 */
 
 	// Step 1: Check whether the given settings are supported by this backend
 	if ( ( querySettings & ( 
-				OContactAccess::IgnoreCase
-				| OContactAccess::WildCards
-// 				| OContactAccess::DateDiff
-// 				| OContactAccess::DateYear
-// 				| OContactAccess::DateMonth
-// 				| OContactAccess::DateDay
-// 				| OContactAccess::RegExp
-// 				| OContactAccess::ExactMatch
+				OPimContactAccess::IgnoreCase
+				| OPimContactAccess::WildCards
+// 				| OPimContactAccess::DateDiff
+// 				| OPimContactAccess::DateYear
+// 				| OPimContactAccess::DateMonth
+// 				| OPimContactAccess::DateDay
+// 				| OPimContactAccess::RegExp
+// 				| OPimContactAccess::ExactMatch
 			       ) ) != querySettings )
 		return false;
 
 	// Step 2: Check whether the given combinations are ok..
 
 	// IngoreCase alone is invalid
-	if ( querySettings == OContactAccess::IgnoreCase )
+	if ( querySettings == OPimContactAccess::IgnoreCase )
 		return false;
 
 	// WildCards, RegExp and ExactMatch should never used at the same time 
-	switch ( querySettings & ~( OContactAccess::IgnoreCase
-				    | OContactAccess::DateDiff
-				    | OContactAccess::DateYear
-				    | OContactAccess::DateMonth
-				    | OContactAccess::DateDay
+	switch ( querySettings & ~( OPimContactAccess::IgnoreCase
+				    | OPimContactAccess::DateDiff
+				    | OPimContactAccess::DateYear
+				    | OPimContactAccess::DateMonth
+				    | OPimContactAccess::DateDay
 				    )
 		 ){
-	case OContactAccess::RegExp:
+	case OPimContactAccess::RegExp:
 		return ( true );
-	case OContactAccess::WildCards:
+	case OPimContactAccess::WildCards:
 		return ( true );
-	case OContactAccess::ExactMatch:
+	case OPimContactAccess::ExactMatch:
 		return ( true );
 	case 0: // one of the upper removed bits were set..
 		return ( true );
 	default:
 		return ( false );
 	}
 
 }
 
-QArray<int> OContactAccessBackend_SQL::sorted( bool asc,  int , int ,  int )
+QArray<int> OPimContactAccessBackend_SQL::sorted( bool asc,  int , int ,  int )
 {
 	QTime t;
 	t.start();
 
 #ifdef __STORE_HORIZONTAL_
 	QString query = "SELECT uid FROM addressbook ";
 	query += "ORDER BY \"Last Name\" ";
 #else
@@ -730,17 +730,17 @@ QArray<int> OContactAccessBackend_SQL::sorted( bool asc,  int , int ,  int )
 
 	QArray<int> list = extractUids( res );
 
 	qWarning("sorted needed %d ms!", t.elapsed() );
 	return list;
 }
 
 
-void OContactAccessBackend_SQL::update()
+void OPimContactAccessBackend_SQL::update()
 {
 	qWarning("Update starts");
 	QTime t;
 	t.start();
 
 	// Now load the database set and extract the uid's
 	// which will be held locally
 
@@ -751,17 +751,17 @@ void OContactAccessBackend_SQL::update()
 
 	m_uids = extractUids( res );
 
 	m_changed = false;
 
 	qWarning("Update ends %d ms", t.elapsed() );
 }
 
-QArray<int> OContactAccessBackend_SQL::extractUids( OSQLResult& res ) const
+QArray<int> OPimContactAccessBackend_SQL::extractUids( OSQLResult& res ) const
 {
 	qWarning("extractUids");
 	QTime t;
 	t.start();
 	OSQLResultItem::ValueList list = res.results();
 	OSQLResultItem::ValueList::Iterator it;
 	QArray<int> ints(list.count() );
 	qWarning(" count = %d", list.count() );
@@ -773,17 +773,17 @@ QArray<int> OContactAccessBackend_SQL::extractUids( OSQLResult& res ) const
 	}
 	qWarning("extractUids ready: count2 = %d needs %d ms", i, t.elapsed() );
 
 	return ints;
 
 }
 
 #ifdef __STORE_HORIZONTAL_
-QMap<int, QString>  OContactAccessBackend_SQL::requestNonCustom( int uid ) const
+QMap<int, QString>  OPimContactAccessBackend_SQL::requestNonCustom( int uid ) const
 {
 	QTime t;
 	t.start();
 
 	QMap<int, QString> nonCustomMap;
 	
 	int t2needed = 0;
 	int t3needed = 0;
@@ -793,18 +793,18 @@ QMap<int, QString>  OContactAccessBackend_SQL::requestNonCustom( int uid ) const
 	OSQLResult res_noncustom = m_driver->query( &query );
 	t2needed = t2.elapsed();
 
 	OSQLResultItem resItem = res_noncustom.first();
 
 	QTime t3;
 	t3.start();
 	// Now loop through all columns
-	QStringList fieldList = OContactFields::untrfields( false );
-	QMap<QString, int> translate = OContactFields::untrFieldsToId();
+	QStringList fieldList = OPimContactFields::untrfields( false );
+	QMap<QString, int> translate = OPimContactFields::untrFieldsToId();
 	for ( QStringList::Iterator it = ++fieldList.begin(); it != fieldList.end(); ++it ){
 		// Get data for the selected column and store it with the
 		// corresponding id into the map..
 
 		int id =  translate[*it];
 		QString value = resItem.data( (*it) );
 		
 		// qWarning("Reading %s... found: %s", (*it).latin1(), value.latin1() );
@@ -815,17 +815,17 @@ QMap<int, QString>  OContactAccessBackend_SQL::requestNonCustom( int uid ) const
 			// Birthday and Anniversary are encoded special ( yyyy-mm-dd )
 			QStringList list = QStringList::split( '-', value );
 			QStringList::Iterator lit = list.begin();
 			int year  = (*lit).toInt();
 			int month = (*(++lit)).toInt();
 			int day   = (*(++lit)).toInt();
 			if ( ( day != 0 ) && ( month != 0 ) && ( year != 0 ) ){
 			     QDate date( year, month, day );
-			     nonCustomMap.insert( id, OConversion::dateToString( date ) );
+			     nonCustomMap.insert( id, OPimDateConversion::dateToString( date ) );
 			}
 		}
 			break;
 		case Qtopia::AddressCategory:
 			qWarning("Category is: %s", value.latin1() );
 		default:
 			nonCustomMap.insert( id, value );
 		}
@@ -838,17 +838,17 @@ QMap<int, QString>  OContactAccessBackend_SQL::requestNonCustom( int uid ) const
 	// qWarning("Adding UID: %s", resItem.data( "uid" ).latin1() );
 	qWarning("RequestNonCustom needed: insg.:%d ms, query: %d ms, mapping: %d ms", 
 		 t.elapsed(), t2needed, t3needed  );
 
 	return nonCustomMap;
 }
 #else
 
-QMap<int, QString>  OContactAccessBackend_SQL::requestNonCustom( int uid ) const
+QMap<int, QString>  OPimContactAccessBackend_SQL::requestNonCustom( int uid ) const
 {
 	QTime t;
 	t.start();
 
 	QMap<int, QString> nonCustomMap;
 	
 	int t2needed = 0;
 	QTime t2;
@@ -861,17 +861,17 @@ QMap<int, QString>  OContactAccessBackend_SQL::requestNonCustom( int uid ) const
 		qWarning("OSQLResult::Failure in find query !!");
 		QMap<int, QString> empty;
 		return empty;
 	}	
 
 	int t3needed = 0;
 	QTime t3;
 	t3.start();
-	QMap<QString, int> translateMap = OContactFields::untrFieldsToId();
+	QMap<QString, int> translateMap = OPimContactFields::untrFieldsToId();
 
 	OSQLResultItem::ValueList list = res_noncustom.results();
 	OSQLResultItem::ValueList::Iterator it = list.begin();
 	for ( ; it != list.end(); ++it ) {
 		if ( (*it).data("type") != "" ){
 			int typeId = translateMap[(*it).data( "type" )];
 			switch( typeId ){
 			case Qtopia::Birthday:
@@ -882,17 +882,17 @@ QMap<int, QString>  OContactAccessBackend_SQL::requestNonCustom( int uid ) const
 				int year  = (*lit).toInt();
 				qWarning("1. %s", (*lit).latin1());
 				int month = (*(++lit)).toInt();
 				qWarning("2. %s", (*lit).latin1());
 				int day   = (*(++lit)).toInt();
 				qWarning("3. %s", (*lit).latin1());
 				qWarning( "RequestNonCustom->Converting:%s to Year: %d, Month: %d, Day: %d ", (*it).data( "value" ).latin1(), year, month, day );
 				QDate date( year, month, day );
-				nonCustomMap.insert( typeId, OConversion::dateToString( date ) );
+				nonCustomMap.insert( typeId, OPimDateConversion::dateToString( date ) );
 			}
 				break;
 			default:
 				nonCustomMap.insert( typeId, 
 						     (*it).data( "value" ) );
 			}
 		}
 	}
@@ -901,17 +901,17 @@ QMap<int, QString>  OContactAccessBackend_SQL::requestNonCustom( int uid ) const
 	t3needed = t3.elapsed();
 
 	qWarning("RequestNonCustom needed: insg.:%d ms, query: %d ms, mapping: %d ms", t.elapsed(), t2needed, t3needed  );
 	return nonCustomMap;
 }
 
 #endif // __STORE_HORIZONTAL_
 
-QMap<QString, QString>  OContactAccessBackend_SQL::requestCustom( int uid ) const
+QMap<QString, QString>  OPimContactAccessBackend_SQL::requestCustom( int uid ) const
 {
 	QTime t;
 	t.start();
 
 	QMap<QString, QString> customMap;
 	
 	FindCustomQuery query( uid );
 	OSQLResult res_custom = m_driver->query( &query );
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_sql.h b/libopie2/opiepim/backend/ocontactaccessbackend_sql.h
index 55b95fd..58ae2ae 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_sql.h
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_sql.h
@@ -25,18 +25,18 @@
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 /*
  * SQL Backend for the OPIE-Contact Database.
  */
 
-#ifndef _OContactAccessBackend_SQL_
-#define _OContactAccessBackend_SQL_
+#ifndef _OPimContactAccessBackend_SQL_
+#define _OPimContactAccessBackend_SQL_
 
 #include <opie2/ocontactaccessbackend.h>
 #include <opie2/ocontactaccess.h>
 
 #include <qlist.h>
 #include <qdict.h>
 
 /* aren't in namespace Opie yet - alwin */
@@ -44,53 +44,53 @@ class OSQLDriver;
 class OSQLResult;
 class OSQLResultItem;
 
 namespace Opie {
 
 /* the default xml implementation */
 /**
  * This class is the SQL implementation of a Contact backend
- * it does implement everything available for OContact.
+ * it does implement everything available for OPimContact.
  * @see OPimAccessBackend for more information of available methods
  */
-class OContactAccessBackend_SQL : public OContactAccessBackend {
+class OPimContactAccessBackend_SQL : public OPimContactAccessBackend {
  public:
-	OContactAccessBackend_SQL ( const QString& appname, const QString& filename = QString::null );
+	OPimContactAccessBackend_SQL ( const QString& appname, const QString& filename = QString::null );
 
-	~OContactAccessBackend_SQL ();
+	~OPimContactAccessBackend_SQL ();
 
 	bool save();
 
 	bool load ();
 
 	void clear ();
 
 	bool wasChangedExternally();
 
 	QArray<int> allRecords() const;
 
-	OContact find ( int uid ) const;
+	OPimContact find ( int uid ) const;
 	// FIXME: Add lookahead-cache support !
-	//OContact find(int uid, const QArray<int>&, uint cur, Frontend::CacheDirection )const;
+	//OPimContact find(int uid, const QArray<int>&, uint cur, Frontend::CacheDirection )const;
 
-	QArray<int> queryByExample ( const OContact &query, int settings, 
+	QArray<int> queryByExample ( const OPimContact &query, int settings, 
 				     const QDateTime& d );
 
 	QArray<int> matchRegexp(  const QRegExp &r ) const;
 
 	const uint querySettings();
 
 	bool hasQuerySettings (uint querySettings) const;
 
 	// Currently only asc implemented..
 	QArray<int> sorted( bool asc,  int , int ,  int );
-	bool add ( const OContact &newcontact );
+	bool add ( const OPimContact &newcontact );
 
-	bool replace ( const OContact &contact );
+	bool replace ( const OPimContact &contact );
 
 	bool remove ( int uid );
 	bool reload();
 
  private:
 	QArray<int> extractUids( OSQLResult& res ) const;
 	QMap<int, QString>  requestNonCustom( int uid ) const;
 	QMap<QString, QString>  requestCustom( int uid ) const;
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_vcard.cpp b/libopie2/opiepim/backend/ocontactaccessbackend_vcard.cpp
index f85cf38..b569f8b 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_vcard.cpp
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_vcard.cpp
@@ -34,42 +34,42 @@
 #include "../../../../library/backend/qfiledirect_p.h"
 
 #include <qpe/timeconversion.h>
 
 #include <qfile.h>
 
 namespace Opie {
 
-OContactAccessBackend_VCard::OContactAccessBackend_VCard ( const QString& , const QString& filename ):
+OPimContactAccessBackend_VCard::OPimContactAccessBackend_VCard ( const QString& , const QString& filename ):
 	m_dirty( false ),
 	m_file( filename )
 {
 	load();
 }
 
 
-bool OContactAccessBackend_VCard::load ()
+bool OPimContactAccessBackend_VCard::load ()
 {
 	m_map.clear();
 	m_dirty = false;
 
 	VObject* obj = 0l;
 
 	if ( QFile::exists(m_file) ){
 		obj = Parse_MIME_FromFileName( QFile::encodeName(m_file).data() );
 		if ( !obj )
 			return false;
 	}else{
 		qWarning("File \"%s\" not found !", m_file.latin1() );
 		return false;
 	}
 
 	while ( obj ) {
-		OContact con = parseVObject( obj );
+		OPimContact con = parseVObject( obj );
 		/*
 		 * if uid is 0 assign a new one
 		 * this at least happens on
 		 * Nokia6210
 		 */
 		if ( con.uid() == 0 ){
 			con.setUid( 1 );
 			qWarning("assigned new uid %d",con.uid() );
@@ -80,133 +80,133 @@ bool OContactAccessBackend_VCard::load ()
 		VObject *t = obj;
 		obj = nextVObjectInList(obj);
 		cleanVObject( t );
 	}
 
 	return true;
 
 }
-bool OContactAccessBackend_VCard::reload()
+bool OPimContactAccessBackend_VCard::reload()
 {
 	return load();
 }
-bool OContactAccessBackend_VCard::save()
+bool OPimContactAccessBackend_VCard::save()
 {
 	if (!m_dirty )
 		return true;
 
 	QFileDirect file( m_file );
 	if (!file.open(IO_WriteOnly ) )
 		return false;
 
 	VObject *obj;
 	obj = newVObject( VCCalProp );
 	addPropValue( obj, VCVersionProp, "1.0" );
 
 	VObject *vo;
-	for(QMap<int, OContact>::ConstIterator it=m_map.begin(); it !=m_map.end(); ++it ){
+	for(QMap<int, OPimContact>::ConstIterator it=m_map.begin(); it !=m_map.end(); ++it ){
 		vo = createVObject( *it );
 		writeVObject( file.directHandle() , vo );
 		cleanVObject( vo );
 	}
 	cleanStrTbl();
 	deleteVObject( obj );
 
 	m_dirty = false;
 	return true;
 
 
 }
-void OContactAccessBackend_VCard::clear ()
+void OPimContactAccessBackend_VCard::clear ()
 {
 	m_map.clear();
 	m_dirty = true; // ??? sure ? (se)
 }
 
-bool OContactAccessBackend_VCard::add ( const OContact& newcontact )
+bool OPimContactAccessBackend_VCard::add ( const OPimContact& newcontact )
 {
 	m_map.insert( newcontact.uid(), newcontact );
 	m_dirty = true;
 	return true;
 }
 
-bool OContactAccessBackend_VCard::remove ( int uid )
+bool OPimContactAccessBackend_VCard::remove ( int uid )
 {
 	m_map.remove( uid );
 	m_dirty = true;
 	return true;
 }
 
-bool OContactAccessBackend_VCard::replace ( const OContact &contact )
+bool OPimContactAccessBackend_VCard::replace ( const OPimContact &contact )
 {
 	m_map.replace( contact.uid(), contact );
 	m_dirty = true;
 	return true;
 }
 
-OContact OContactAccessBackend_VCard::find ( int uid ) const
+OPimContact OPimContactAccessBackend_VCard::find ( int uid ) const
 {
     return m_map[uid];
 }
 
-QArray<int> OContactAccessBackend_VCard::allRecords() const
+QArray<int> OPimContactAccessBackend_VCard::allRecords() const
 {
 	QArray<int> ar( m_map.count() );
-	QMap<int, OContact>::ConstIterator it;
+	QMap<int, OPimContact>::ConstIterator it;
 	int i = 0;
 	for ( it = m_map.begin(); it != m_map.end(); ++it ) {
 		ar[i] = it.key();
 		i++;
 	}
 	return ar;
 }
 
 // Not implemented
-QArray<int> OContactAccessBackend_VCard::queryByExample ( const OContact&, int, const QDateTime& )
+QArray<int> OPimContactAccessBackend_VCard::queryByExample ( const OPimContact&, int, const QDateTime& )
 {
 	QArray<int> ar(0);
 	return ar;
 }
 
 // Not implemented
-QArray<int> OContactAccessBackend_VCard::matchRegexp(  const QRegExp&  ) const
+QArray<int> OPimContactAccessBackend_VCard::matchRegexp(  const QRegExp&  ) const
 {
 	QArray<int> ar(0);
 	return ar;
 }
 
-const uint OContactAccessBackend_VCard::querySettings()
+const uint OPimContactAccessBackend_VCard::querySettings()
 {
 	return 0; // No search possible
 }
 
-bool OContactAccessBackend_VCard::hasQuerySettings (uint ) const
+bool OPimContactAccessBackend_VCard::hasQuerySettings (uint ) const
 {
 	return false; // No search possible, therefore all settings invalid ;)
 }
 
-bool OContactAccessBackend_VCard::wasChangedExternally()
+bool OPimContactAccessBackend_VCard::wasChangedExternally()
 {
 	return false; // Don't expect concurrent access
 }
 
 // Not implemented
-QArray<int> OContactAccessBackend_VCard::sorted( bool , int, int, int )
+QArray<int> OPimContactAccessBackend_VCard::sorted( bool , int, int, int )
 {
 	QArray<int> ar(0);
 	return ar;
 }
 
 // *** Private stuff ***
 
 
-OContact OContactAccessBackend_VCard::parseVObject( VObject *obj )
+OPimContact OPimContactAccessBackend_VCard::parseVObject( VObject *obj )
 {
-	OContact c;
+	OPimContact c;
 
 	VObjectIterator it;
 	initPropIterator( &it, obj );
 	while( moreIteration( &it ) ) {
 		VObject *o = nextVObject( &it );
 		QCString name = vObjectName( o );
 		QCString value = vObjectStringZValue( o );
 		if ( name == VCNameProp ) {
@@ -422,17 +422,17 @@ OContact OContactAccessBackend_VCard::parseVObject( VObject *obj )
 		}
 #endif
 	}
 	c.setFileAs();
 	return c;
 }
 
 
-VObject* OContactAccessBackend_VCard::createVObject( const OContact &c )
+VObject* OPimContactAccessBackend_VCard::createVObject( const OPimContact &c )
 {
 	VObject *vcard = newVObject( VCCardProp );
 	safeAddPropValue( vcard, VCVersionProp, "2.1" );
 	safeAddPropValue( vcard, VCLastRevisedProp, TimeConversion::toISO8601( QDateTime::currentDateTime() ) );
 	safeAddPropValue( vcard, VCUniqueStringProp, QString::number(c.uid()) );
 
 	// full name
 	safeAddPropValue( vcard, VCFullNameProp, c.fullName() );
@@ -528,31 +528,31 @@ VObject* OContactAccessBackend_VCard::createVObject( const OContact &c )
 		safeAddPropValue( vcard, "X-Qtopia-Anniversary", convDateToVCardDate( c.anniversary() ) );
 	}
 	safeAddPropValue( vcard, "X-Qtopia-Nickname", c.nickname() );
 	safeAddPropValue( vcard, "X-Qtopia-Children", c.children() );
 
 	return vcard;
 }
 
-QString OContactAccessBackend_VCard::convDateToVCardDate( const QDate& d ) const
+QString OPimContactAccessBackend_VCard::convDateToVCardDate( const QDate& d ) const
 {
 		QString str_rfc2425 = QString("%1-%2-%3")
 			.arg( d.year() )
 			.arg( d.month(), 2 )
 			.arg( d.day(), 2 );
 		// Now replace spaces with "0"...
 		int pos = 0;
 		while ( ( pos = str_rfc2425.find (' ')  ) > 0 )
 			str_rfc2425.replace( pos, 1, "0" );
 
 		return str_rfc2425;
 }
 
-QDate OContactAccessBackend_VCard::convVCardDateToDate( const QString& datestr )
+QDate OPimContactAccessBackend_VCard::convVCardDateToDate( const QString& datestr )
 {
 	int monthPos = datestr.find('-');
 	int dayPos = datestr.find('-', monthPos+1 );
 	int sep_ignore = 1;
 	if ( monthPos == -1 || dayPos == -1 ) {
 		qDebug("fromString didn't find - in str = %s; mpos = %d ypos = %d", datestr.latin1(), monthPos, dayPos );
 		// Ok.. No "-" found, therefore we will try to read other format ( YYYYMMDD )
 		if ( datestr.length() == 8 ){
@@ -567,25 +567,25 @@ QDate OContactAccessBackend_VCard::convVCardDateToDate( const QString& datestr )
 	int y = datestr.left( monthPos ).toInt();
 	int m = datestr.mid( monthPos + sep_ignore, dayPos - monthPos - sep_ignore ).toInt();
 	int d = datestr.mid( dayPos + sep_ignore ).toInt();
 	qDebug("TimeConversion::fromString ymd = %s => %d %d %d; mpos = %d ypos = %d", datestr.latin1(), y, m, d, monthPos, dayPos);
 	QDate date ( y,m,d );
 	return date;
 }
 
-VObject* OContactAccessBackend_VCard::safeAddPropValue( VObject *o, const char *prop, const QString &value )
+VObject* OPimContactAccessBackend_VCard::safeAddPropValue( VObject *o, const char *prop, const QString &value )
 {
 	VObject *ret = 0;
 	if ( o && !value.isEmpty() )
 		ret = addPropValue( o, prop, value.latin1() );
 	return ret;
 }
 
-VObject* OContactAccessBackend_VCard::safeAddProp( VObject *o, const char *prop)
+VObject* OPimContactAccessBackend_VCard::safeAddProp( VObject *o, const char *prop)
 {
 	VObject *ret = 0;
 	if ( o )
 		ret = addProp( o, prop );
 	return ret;
 }
 
 }
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_vcard.h b/libopie2/opiepim/backend/ocontactaccessbackend_vcard.h
index 11be027..2a786af 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_vcard.h
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_vcard.h
@@ -27,59 +27,59 @@
                              Boston, MA 02111-1307, USA.
 */
 /*
  * VCard Backend for the OPIE-Contact Database.
  */
 #ifndef __OCONTACTACCESSBACKEND_VCARD_H_
 #define __OCONTACTACCESSBACKEND_VCARD_H_
 
-#include <opie2/ocontact.h>
+#include <opie2/opimcontact.h>
 
 #include <opie2/ocontactaccessbackend.h>
 
 class VObject;
 
 namespace Opie {
 /**
  * This is the vCard 2.1 implementation of the Contact Storage
- * @see OContactAccessBackend_XML
+ * @see OPimContactAccessBackend_XML
  * @see OPimAccessBackend
  */
-class OContactAccessBackend_VCard : public OContactAccessBackend {
+class OPimContactAccessBackend_VCard : public OPimContactAccessBackend {
  public:
-	OContactAccessBackend_VCard ( const QString& appname, const QString& filename = QString::null );
+	OPimContactAccessBackend_VCard ( const QString& appname, const QString& filename = QString::null );
 
 	bool load ();
 	bool reload();
 	bool save();
 	void clear ();
 
-	bool add ( const OContact& newcontact );
+	bool add ( const OPimContact& newcontact );
 	bool remove ( int uid );
-	bool replace ( const OContact& contact );
+	bool replace ( const OPimContact& contact );
 
-	OContact find ( int uid ) const;
+	OPimContact find ( int uid ) const;
 	QArray<int> allRecords() const;
-	QArray<int> queryByExample ( const OContact &query, int settings, const QDateTime& d = QDateTime() );
+	QArray<int> queryByExample ( const OPimContact &query, int settings, const QDateTime& d = QDateTime() );
 	QArray<int> matchRegexp(  const QRegExp &r ) const;
 
 	const uint querySettings();
 	bool hasQuerySettings (uint querySettings) const;
 	QArray<int> sorted( bool ascending, int sortOrder, int sortFilter, int cat );
 	bool wasChangedExternally();
 
 private:
-	OContact parseVObject( VObject* obj );
-	VObject* createVObject( const OContact& c );
+	OPimContact parseVObject( VObject* obj );
+	VObject* createVObject( const OPimContact& c );
 	QString convDateToVCardDate( const QDate& c ) const;
 	QDate convVCardDateToDate( const QString& datestr );
 	VObject *safeAddPropValue( VObject *o, const char* prop, const QString& value );
 	VObject *safeAddProp( VObject* o, const char* prop);
 
 	bool m_dirty : 1;
 	QString m_file;
-	QMap<int, OContact> m_map;
+	QMap<int, OPimContact> m_map;
 };
 
 }
 
 #endif
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_xml.cpp b/libopie2/opiepim/backend/ocontactaccessbackend_xml.cpp
index 07ad29a..0adba68 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_xml.cpp
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_xml.cpp
@@ -49,17 +49,17 @@
 
 #include <stdlib.h>
 #include <errno.h>
 
 using namespace Opie;
 
 
 namespace Opie {
-OContactAccessBackend_XML::OContactAccessBackend_XML ( const QString& appname, const QString& filename ):
+OPimContactAccessBackend_XML::OPimContactAccessBackend_XML ( const QString& appname, const QString& filename ):
 	m_changed( false )
 {
 	// Just m_contactlist should call delete if an entry
 	// is removed.
 	m_contactList.setAutoDelete( true );
 	m_uidToContact.setAutoDelete( false );
 
 	m_appName = appname;
@@ -73,17 +73,17 @@ OContactAccessBackend_XML::OContactAccessBackend_XML ( const QString& appname, c
 		m_fileName = Global::applicationFileName( "addressbook","addressbook.xml" );
 	} else
 		m_fileName = filename;
 
 	/* Load Database now */
 	load ();
 }
 
-bool OContactAccessBackend_XML::save()
+bool OPimContactAccessBackend_XML::save()
 {
 
 	if ( !m_changed )
 		return true;
 
 	QString strNewFile = m_fileName + ".new";
 	QFile f( strNewFile );
 	if ( !f.open( IO_WriteOnly|IO_Raw ) )
@@ -99,17 +99,17 @@ bool OContactAccessBackend_XML::save()
 		" </Groups>\n"
 		" <Contacts>\n";
 	QCString cstr = out.utf8();
 	f.writeBlock( cstr.data(), cstr.length() );
 	idx_offset += cstr.length();
 	out = "";
 
 	// Write all contacts
-	QListIterator<OContact> it( m_contactList );
+	QListIterator<OPimContact> it( m_contactList );
 	for ( ; it.current(); ++it ) {
 		// qWarning(" Uid %d at Offset: %x", (*it)->uid(), idx_offset );
 		out += "<Contact ";
 		(*it)->save( out );
 		out += "/>\n";
 		cstr = out.utf8();
 		total_written = f.writeBlock( cstr.data(), cstr.length() );
 		idx_offset += cstr.length();
@@ -143,17 +143,17 @@ bool OContactAccessBackend_XML::save()
 
 	/* The journalfile should be removed now... */
 	removeJournal();
 
 	m_changed = false;
 	return true;
 }
 
-bool OContactAccessBackend_XML::load ()
+bool OPimContactAccessBackend_XML::load ()
 {
 	m_contactList.clear();
 	m_uidToContact.clear();
 
 	/* Load XML-File and journal if it exists */
 	if ( !load ( m_fileName, false ) )
 		return false;
 	/* The returncode of the journalfile is ignored due to the
@@ -162,65 +162,65 @@ bool OContactAccessBackend_XML::load ()
 	 * Therefore we try to load it to get the changes before the #
 	 * crash happened...
 	 */
 	load (m_journalName, true);
 
 	return true;
 }
 
-void OContactAccessBackend_XML::clear ()
+void OPimContactAccessBackend_XML::clear ()
 {
 	m_contactList.clear();
 	m_uidToContact.clear();
 
 	m_changed = false;
 }
 
-bool OContactAccessBackend_XML::wasChangedExternally()
+bool OPimContactAccessBackend_XML::wasChangedExternally()
 {
 	QFileInfo fi( m_fileName );
 
 	QDateTime lastmod = fi.lastModified ();
 
 	return (lastmod != m_readtime);
 }
 
-QArray<int> OContactAccessBackend_XML::allRecords() const
+QArray<int> OPimContactAccessBackend_XML::allRecords() const
 {
 	QArray<int> uid_list( m_contactList.count() );
 
 	uint counter = 0;
-	QListIterator<OContact> it( m_contactList );
+	QListIterator<OPimContact> it( m_contactList );
 	for( ; it.current(); ++it ){
 		uid_list[counter++] = (*it)->uid();
 	}
 
 	return ( uid_list );
 }
 
-OContact OContactAccessBackend_XML::find ( int uid ) const
+OPimContact OPimContactAccessBackend_XML::find ( int uid ) const
 {
-	OContact foundContact; //Create empty contact
+	OPimContact foundContact; //Create empty contact
 
-	OContact* found = m_uidToContact.find( QString().setNum( uid ) );
+	OPimContact* found = m_uidToContact.find( QString().setNum( uid ) );
 
 	if ( found ){
 		foundContact = *found;
 	}
 
 	return ( foundContact );
 }
 
-QArray<int> OContactAccessBackend_XML::queryByExample ( const OContact &query, int settings,
+QArray<int> OPimContactAccessBackend_XML::queryByExample ( const OPimContact &query, int settings,
 							const QDateTime& d )
 {
 
 	QArray<int> m_currentQuery( m_contactList.count() );
-	QListIterator<OContact> it( m_contactList );
+	QListIterator<OPimContact> it( m_contactList );
 	uint arraycounter = 0;
 
 	for( ; it.current(); ++it ){
 		/* Search all fields and compare them with query object. Store them into list
 		 * if all fields matches.
 		 */
 		QDate* queryDate = 0l;
 		QDate* checkDate = 0l;
@@ -235,29 +235,29 @@ QArray<int> OContactAccessBackend_XML::queryByExample ( const OContact &query, i
 			case Qtopia::Anniversary:
 				if ( queryDate == 0l ){
 					queryDate = new QDate( query.anniversary() );
 					checkDate = new QDate( (*it)->anniversary() );
 				}
 
 				if ( queryDate->isValid() ){
 					if(  checkDate->isValid() ){
-						if ( settings & OContactAccess::DateYear ){
+						if ( settings & OPimContactAccess::DateYear ){
 							if ( queryDate->year() != checkDate->year() )
 								allcorrect = false;
 						}
-						if ( settings & OContactAccess::DateMonth ){
+						if ( settings & OPimContactAccess::DateMonth ){
 							if ( queryDate->month() != checkDate->month() )
 								allcorrect = false;
 						}
-						if ( settings & OContactAccess::DateDay ){
+						if ( settings & OPimContactAccess::DateDay ){
 							if ( queryDate->day() != checkDate->day() )
 								allcorrect = false;
 						}
-						if ( settings & OContactAccess::DateDiff ) {
+						if ( settings & OPimContactAccess::DateDiff ) {
 							QDate current;
 							// If we get an additional date, we
 							// will take this date instead of
 							// the current one..
 							if ( !d.date().isValid() )
 								current = QDate::currentDate();
 							else
 								current = d.date();
@@ -296,42 +296,42 @@ QArray<int> OContactAccessBackend_XML::queryByExample ( const OContact &query, i
 				delete queryDate;
 				queryDate = 0l;
 				delete checkDate;
 				checkDate = 0l;
 				break;
 			default:
 				/* Just compare fields which are not empty in the query object */
 				if ( !query.field(i).isEmpty() ){
-					switch ( settings & ~( OContactAccess::IgnoreCase
-							       | OContactAccess::DateDiff
-							       | OContactAccess::DateYear
-							       | OContactAccess::DateMonth
-							       | OContactAccess::DateDay
-							       | OContactAccess::MatchOne
+					switch ( settings & ~( OPimContactAccess::IgnoreCase
+							       | OPimContactAccess::DateDiff
+							       | OPimContactAccess::DateYear
+							       | OPimContactAccess::DateMonth
+							       | OPimContactAccess::DateDay
+							       | OPimContactAccess::MatchOne
 							       ) ){
 
-					case OContactAccess::RegExp:{
+					case OPimContactAccess::RegExp:{
 						QRegExp expr ( query.field(i),
-							       !(settings & OContactAccess::IgnoreCase),
+							       !(settings & OPimContactAccess::IgnoreCase),
 							       false );
 						if ( expr.find ( (*it)->field(i), 0 ) == -1 )
 							allcorrect = false;
 					}
 						break;
-					case OContactAccess::WildCards:{
+					case OPimContactAccess::WildCards:{
 						QRegExp expr ( query.field(i),
-							       !(settings & OContactAccess::IgnoreCase),
+							       !(settings & OPimContactAccess::IgnoreCase),
 							       true );
 						if ( expr.find ( (*it)->field(i), 0 ) == -1 )
 							allcorrect = false;
 					}
 						break;
-					case OContactAccess::ExactMatch:{
-						if (settings & OContactAccess::IgnoreCase){
+					case OPimContactAccess::ExactMatch:{
+						if (settings & OPimContactAccess::IgnoreCase){
 							if ( query.field(i).upper() !=
 							     (*it)->field(i).upper() )
 								allcorrect = false;
 						}else{
 							if ( query.field(i) != (*it)->field(i) )
 								allcorrect = false;
 						}
 					}
@@ -346,104 +346,104 @@ QArray<int> OContactAccessBackend_XML::queryByExample ( const OContact &query, i
 	}
 
 	// Shrink to fit..
 	m_currentQuery.resize(arraycounter);
 
 	return m_currentQuery;
 }
 
-QArray<int> OContactAccessBackend_XML::matchRegexp(  const QRegExp &r ) const
+QArray<int> OPimContactAccessBackend_XML::matchRegexp(  const QRegExp &r ) const
 {
 	QArray<int> m_currentQuery( m_contactList.count() );
-	QListIterator<OContact> it( m_contactList );
+	QListIterator<OPimContact> it( m_contactList );
 	uint arraycounter = 0;
 
 	for( ; it.current(); ++it ){
 		if ( (*it)->match( r ) ){
 			m_currentQuery[arraycounter++] = (*it)->uid();
 		}
 
 	}
 	// Shrink to fit..
 	m_currentQuery.resize(arraycounter);
 
 	return m_currentQuery;
 }
 
-const uint OContactAccessBackend_XML::querySettings()
+const uint OPimContactAccessBackend_XML::querySettings()
 {
-	return ( OContactAccess::WildCards
-		 | OContactAccess::IgnoreCase
-		 | OContactAccess::RegExp
-		 | OContactAccess::ExactMatch
-		 | OContactAccess::DateDiff
-		 | OContactAccess::DateYear
-		 | OContactAccess::DateMonth
-		 | OContactAccess::DateDay
+	return ( OPimContactAccess::WildCards
+		 | OPimContactAccess::IgnoreCase
+		 | OPimContactAccess::RegExp
+		 | OPimContactAccess::ExactMatch
+		 | OPimContactAccess::DateDiff
+		 | OPimContactAccess::DateYear
+		 | OPimContactAccess::DateMonth
+		 | OPimContactAccess::DateDay
 		 );
 }
 
-bool OContactAccessBackend_XML::hasQuerySettings (uint querySettings) const
+bool OPimContactAccessBackend_XML::hasQuerySettings (uint querySettings) const
 {
-	/* OContactAccess::IgnoreCase, DateDiff, DateYear, DateMonth, DateDay
+	/* OPimContactAccess::IgnoreCase, DateDiff, DateYear, DateMonth, DateDay
 	 * may be added with any of the other settings. IgnoreCase should never used alone.
 	 * Wildcards, RegExp, ExactMatch should never used at the same time...
 	 */
 
 	// Step 1: Check whether the given settings are supported by this backend
 	if ( ( querySettings & ( 
-				OContactAccess::IgnoreCase
-				| OContactAccess::WildCards
-				| OContactAccess::DateDiff
-				| OContactAccess::DateYear
-				| OContactAccess::DateMonth
-				| OContactAccess::DateDay
-				| OContactAccess::RegExp
-				| OContactAccess::ExactMatch
+				OPimContactAccess::IgnoreCase
+				| OPimContactAccess::WildCards
+				| OPimContactAccess::DateDiff
+				| OPimContactAccess::DateYear
+				| OPimContactAccess::DateMonth
+				| OPimContactAccess::DateDay
+				| OPimContactAccess::RegExp
+				| OPimContactAccess::ExactMatch
 			       ) ) != querySettings )
 		return false;
 
 	// Step 2: Check whether the given combinations are ok..
 
 	// IngoreCase alone is invalid
-	if ( querySettings == OContactAccess::IgnoreCase )
+	if ( querySettings == OPimContactAccess::IgnoreCase )
 		return false;
 
 	// WildCards, RegExp and ExactMatch should never used at the same time 
-	switch ( querySettings & ~( OContactAccess::IgnoreCase
-				    | OContactAccess::DateDiff
-				    | OContactAccess::DateYear
-				    | OContactAccess::DateMonth
-				    | OContactAccess::DateDay
+	switch ( querySettings & ~( OPimContactAccess::IgnoreCase
+				    | OPimContactAccess::DateDiff
+				    | OPimContactAccess::DateYear
+				    | OPimContactAccess::DateMonth
+				    | OPimContactAccess::DateDay
 				    )
 		 ){
-	case OContactAccess::RegExp:
+	case OPimContactAccess::RegExp:
 		return ( true );
-	case OContactAccess::WildCards:
+	case OPimContactAccess::WildCards:
 		return ( true );
-	case OContactAccess::ExactMatch:
+	case OPimContactAccess::ExactMatch:
 		return ( true );
 	case 0: // one of the upper removed bits were set..
 		return ( true );
 	default:
 		return ( false );
 	}
 }
 
 // Currently only asc implemented..
-QArray<int> OContactAccessBackend_XML::sorted( bool asc,  int , int ,  int )
+QArray<int> OPimContactAccessBackend_XML::sorted( bool asc,  int , int ,  int )
 {
 	QMap<QString, int> nameToUid;
 	QStringList names;
 	QArray<int> m_currentQuery( m_contactList.count() );
 
 	// First fill map and StringList with all Names
 	// Afterwards sort namelist and use map to fill array to return..
-	QListIterator<OContact> it( m_contactList );
+	QListIterator<OPimContact> it( m_contactList );
 	for( ; it.current(); ++it ){
 		names.append( (*it)->fileAs() + QString::number( (*it)->uid() ) );
 		nameToUid.insert( (*it)->fileAs() + QString::number( (*it)->uid() ), (*it)->uid() );
 	}
 	names.sort();
 
 	int i = 0;
 	if ( asc ){
@@ -453,80 +453,80 @@ QArray<int> OContactAccessBackend_XML::sorted( bool asc,  int , int ,  int )
 		for ( QStringList::Iterator it = names.end(); it != names.begin(); --it )
 			m_currentQuery[i++] = nameToUid[ (*it) ];
 	}
 
 	return m_currentQuery;
 
 }
 
-bool OContactAccessBackend_XML::add ( const OContact &newcontact )
+bool OPimContactAccessBackend_XML::add ( const OPimContact &newcontact )
 {
 	//qWarning("odefaultbackend: ACTION::ADD");
 	updateJournal (newcontact, ACTION_ADD);
 	addContact_p( newcontact );
 
 	m_changed = true;
 
 	return true;
 }
 
-bool OContactAccessBackend_XML::replace ( const OContact &contact )
+bool OPimContactAccessBackend_XML::replace ( const OPimContact &contact )
 {
 	m_changed = true;
 
-	OContact* found = m_uidToContact.find ( QString().setNum( contact.uid() ) );
+	OPimContact* found = m_uidToContact.find ( QString().setNum( contact.uid() ) );
 
 	if ( found ) {
-		OContact* newCont = new OContact( contact );
+		OPimContact* newCont = new OPimContact( contact );
 
 		updateJournal ( *newCont, ACTION_REPLACE);
 		m_contactList.removeRef ( found );
 		m_contactList.append ( newCont );
 		m_uidToContact.remove( QString().setNum( contact.uid() ) );
 		m_uidToContact.insert( QString().setNum( newCont->uid() ), newCont );
 
 		qWarning("Nur zur Sicherheit: %d == %d ?",contact.uid(), newCont->uid());
 
 		return true;
 	} else
 		return false;
 }
 
-bool OContactAccessBackend_XML::remove ( int uid )
+bool OPimContactAccessBackend_XML::remove ( int uid )
 {
 	m_changed = true;
 
-	OContact* found = m_uidToContact.find ( QString().setNum( uid ) );
+	OPimContact* found = m_uidToContact.find ( QString().setNum( uid ) );
 
 	if ( found ) {
 		updateJournal ( *found, ACTION_REMOVE);
 		m_contactList.removeRef ( found );
 		m_uidToContact.remove( QString().setNum( uid ) );
 
 		return true;
 	} else
 		return false;
 }
 
-bool OContactAccessBackend_XML::reload(){
+bool OPimContactAccessBackend_XML::reload(){
 	/* Reload is the same as load in this implementation */
 	return ( load() );
 }
 
-void OContactAccessBackend_XML::addContact_p( const OContact &newcontact )
+void OPimContactAccessBackend_XML::addContact_p( const OPimContact &newcontact )
 {
-	OContact* contRef = new OContact( newcontact );
+	OPimContact* contRef = new OPimContact( newcontact );
 
 	m_contactList.append ( contRef );
 	m_uidToContact.insert( QString().setNum( newcontact.uid() ), contRef );
 }
 
 /* This function loads the xml-database and the journalfile */
-bool OContactAccessBackend_XML::load( const QString filename, bool isJournal )
+bool OPimContactAccessBackend_XML::load( const QString filename, bool isJournal )
 {
 
 	/* We use the time of the last read to check if the file was
 	 * changed externally.
 	 */
 	if ( !isJournal ){
 		QFileInfo fi( filename );
 		m_readtime = fi.lastModified ();
@@ -585,50 +585,50 @@ bool OContactAccessBackend_XML::load( const QString filename, bool isJournal )
 	dict.insert( "Gender", new int(Qtopia::Gender) );
 	dict.insert( "Birthday", new int(Qtopia::Birthday) );
 	dict.insert( "Anniversary", new int(Qtopia::Anniversary) );
 	dict.insert( "Nickname", new int(Qtopia::Nickname) );
 	dict.insert( "Notes", new int(Qtopia::Notes) );
 	dict.insert( "action", new int(JOURNALACTION) );
 	dict.insert( "actionrow", new int(JOURNALROW) );
 
-	//qWarning( "OContactDefaultBackEnd::loading %s", filename.latin1() );
+	//qWarning( "OPimContactDefaultBackEnd::loading %s", filename.latin1() );
 
 	XMLElement *root = XMLElement::load( filename );
 	if(root != 0l ){ // start parsing
 		/* Parse all XML-Elements and put the data into the
 		 * Contact-Class
 		 */
 		XMLElement *element = root->firstChild();
-		//qWarning("OContactAccess::load tagName(): %s", root->tagName().latin1() );
+		//qWarning("OPimContactAccess::load tagName(): %s", root->tagName().latin1() );
 		element = element->firstChild();
 
 		/* Search Tag "Contacts" which is the parent of all Contacts */
 		while( element && !isJournal ){
 			if( element->tagName() != QString::fromLatin1("Contacts") ){
-				//qWarning ("OContactDefBack::Searching for Tag \"Contacts\"! Found: %s",
+				//qWarning ("OPimContactDefBack::Searching for Tag \"Contacts\"! Found: %s",
 				//	  element->tagName().latin1());
 				element = element->nextChild();
 			} else {
 				element = element->firstChild();
 				break;
 			}
 		}
 		/* Parse all Contacts and ignore unknown tags */
 		while( element ){
 			if( element->tagName() != QString::fromLatin1("Contact") ){
-				//qWarning ("OContactDefBack::Searching for Tag \"Contact\"! Found: %s",
+				//qWarning ("OPimContactDefBack::Searching for Tag \"Contact\"! Found: %s",
 				//	  element->tagName().latin1());
 				element = element->nextChild();
 				continue;
 			}
 			/* Found alement with tagname "contact", now parse and store all
 			 * attributes contained
 			 */
-			//qWarning("OContactDefBack::load element tagName() : %s",
+			//qWarning("OPimContactDefBack::load element tagName() : %s",
 			//	 element->tagName().latin1() );
 			QString dummy;
 			foundAction = false;
 
 			XMLElement::AttributeMap aMap = element->attributes();
 			XMLElement::AttributeMap::Iterator it;
 			contactMap.clear();
 			customMap.clear();
@@ -665,17 +665,17 @@ bool OContactAccessBackend_XML::load( const QString filename, bool isJournal )
 					journalKey = it.data().toInt();
 					break;
 				default: // no conversion needed add them to the map
 					contactMap.insert( *find, it.data() );
 					break;
 				}
 			}
 			/* now generate the Contact contact */
-			OContact contact( contactMap );
+			OPimContact contact( contactMap );
 
 			for (customIt = customMap.begin(); customIt != customMap.end(); ++customIt ) {
 				contact.setCustomField( customIt.key(),  customIt.data() );
 			}
 
 			if (foundAction){
 				foundAction = false;
 				switch ( action ) {
@@ -708,17 +708,17 @@ bool OContactAccessBackend_XML::load( const QString filename, bool isJournal )
 		qWarning("ODefBack::could not load");
 	}
 	delete root;
 	qWarning("returning from loading" );
 	return true;
 }
 
 
-void OContactAccessBackend_XML::updateJournal( const OContact& cnt,
+void OPimContactAccessBackend_XML::updateJournal( const OPimContact& cnt,
 					       journal_action action )
 {
 	QFile f( m_journalName );
 	bool created = !f.exists();
 	if ( !f.open(IO_WriteOnly|IO_Append) )
 		return;
 
 	QString buf;
@@ -736,16 +736,16 @@ void OContactAccessBackend_XML::updateJournal( const OContact& cnt,
 	buf = "<Contact ";
 	cnt.save( buf );
 	buf += " action=\"" + QString::number( (int)action ) + "\" ";
 	buf += "/>\n";
 	QCString cstr = buf.utf8();
 	f.writeBlock( cstr.data(), cstr.length() );
 }
 
-void OContactAccessBackend_XML::removeJournal()
+void OPimContactAccessBackend_XML::removeJournal()
 {
 	QFile f ( m_journalName );
 	if ( f.exists() )
 		f.remove();
 }
 
 }
diff --git a/libopie2/opiepim/backend/ocontactaccessbackend_xml.h b/libopie2/opiepim/backend/ocontactaccessbackend_xml.h
index f439c4c..eaea352 100644
--- a/libopie2/opiepim/backend/ocontactaccessbackend_xml.h
+++ b/libopie2/opiepim/backend/ocontactaccessbackend_xml.h
@@ -25,84 +25,84 @@
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 /*
  * XML Backend for the OPIE-Contact Database.
  */
 
-#ifndef _OContactAccessBackend_XML_
-#define _OContactAccessBackend_XML_
+#ifndef _OPimContactAccessBackend_XML_
+#define _OPimContactAccessBackend_XML_
 
 #include <opie2/ocontactaccessbackend.h>
 #include <opie2/ocontactaccess.h>
 
 #include <qlist.h>
 #include <qdict.h>
 
 namespace Opie {
 /* the default xml implementation */
 /**
  * This class is the XML implementation of a Contact backend
- * it does implement everything available for OContact.
+ * it does implement everything available for OPimContact.
  * @see OPimAccessBackend for more information of available methods
  */
-class OContactAccessBackend_XML : public OContactAccessBackend {
+class OPimContactAccessBackend_XML : public OPimContactAccessBackend {
  public:
-	OContactAccessBackend_XML ( const QString& appname, const QString& filename = QString::null );
+	OPimContactAccessBackend_XML ( const QString& appname, const QString& filename = QString::null );
 
 	bool save();
 
 	bool load ();
 
 	void clear ();
 
 	bool wasChangedExternally();
 
 	QArray<int> allRecords() const;
 
-	OContact find ( int uid ) const;
+	OPimContact find ( int uid ) const;
 
-	QArray<int> queryByExample ( const OContact &query, int settings, const QDateTime& d = QDateTime() );
+	QArray<int> queryByExample ( const OPimContact &query, int settings, const QDateTime& d = QDateTime() );
 
 	QArray<int> matchRegexp(  const QRegExp &r ) const;
 
 	const uint querySettings();
 
 	bool hasQuerySettings (uint querySettings) const;
 
 	// Currently only asc implemented..
 	QArray<int> sorted( bool asc,  int , int ,  int );
-	bool add ( const OContact &newcontact );
+	bool add ( const OPimContact &newcontact );
 
-	bool replace ( const OContact &contact );
+	bool replace ( const OPimContact &contact );
 
 	bool remove ( int uid );
 	bool reload();
 
  private:
 
 	enum journal_action { ACTION_ADD, ACTION_REMOVE, ACTION_REPLACE };
 
-	void addContact_p( const OContact &newcontact );
+	void addContact_p( const OPimContact &newcontact );
 
 	/* This function loads the xml-database and the journalfile */
 	bool load( const QString filename, bool isJournal );
 
 
-	void updateJournal( const OContact& cnt, journal_action action );
+	void updateJournal( const OPimContact& cnt, journal_action action );
 	void removeJournal();
 
  protected:
 	bool m_changed;
 	QString m_journalName;
 	QString m_fileName;
 	QString m_appName;
-	QList<OContact> m_contactList;
+	QList<OPimContact> m_contactList;
 	QDateTime m_readtime;
 
-	QDict<OContact> m_uidToContact;
+	QDict<OPimContact> m_uidToContact;
 };
 
 }
 
 #endif
diff --git a/libopie2/opiepim/backend/odatebookaccessbackend.cpp b/libopie2/opiepim/backend/odatebookaccessbackend.cpp
index 9bf4bf0..f3b7b5f 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend.cpp
+++ b/libopie2/opiepim/backend/odatebookaccessbackend.cpp
@@ -23,29 +23,29 @@
   -_. . .   )=.  =           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 <qtl.h>
 
-#include <opie2/orecur.h>
+#include <opie2/opimrecurrence.h>
 
 #include <opie2/odatebookaccessbackend.h>
 
 using namespace Opie;
 
 namespace {
 /* a small helper to get all NonRepeating events for a range of time */
-    void events( OEffectiveEvent::ValueList& tmpList, const OEvent::ValueList& events,
+    void events( OEffectiveEvent::ValueList& tmpList, const OPimEvent::ValueList& events,
                  const QDate& from, const QDate& to ) {
         QDateTime dtStart, dtEnd;
 
-        for ( OEvent::ValueList::ConstIterator it = events.begin(); it != events.end(); ++it ) {
+        for ( OPimEvent::ValueList::ConstIterator it = events.begin(); it != events.end(); ++it ) {
             dtStart = (*it).startDateTime();
             dtEnd   = (*it).endDateTime();
 
             /*
              * If in range
              */
             if (dtStart.date() >= from && dtEnd.date() <= to ) {
                 OEffectiveEvent eff;
@@ -86,23 +86,23 @@ namespace {
                         tmpList.append( eff );
                     }
                     dt = dt.addDays( 1 );
                 }
             }
         }
     }
 
-    void repeat( OEffectiveEvent::ValueList& tmpList, const OEvent::ValueList& list,
+    void repeat( OEffectiveEvent::ValueList& tmpList, const OPimEvent::ValueList& list,
                  const QDate& from, const QDate& to ) {
         QDate repeat;
-        for ( OEvent::ValueList::ConstIterator it = list.begin(); it != list.end(); ++it ) {
+        for ( OPimEvent::ValueList::ConstIterator it = list.begin(); it != list.end(); ++it ) {
             int dur = (*it).startDateTime().date().daysTo( (*it).endDateTime().date() );
             QDate itDate = from.addDays(-dur );
-            ORecur rec = (*it).recurrence();
+            OPimRecurrence rec = (*it).recurrence();
             if ( !rec.hasEndDate() || rec.endDate() > to ) {
                 rec.setEndDate( to );
                 rec.setHasEndDate( true );
             }
             while (rec.nextOcurrence(itDate, repeat ) ) {
                 if (repeat > to ) break;
                 OEffectiveEvent eff;
                 eff.setDate( repeat );
@@ -147,27 +147,27 @@ namespace {
             }
         }
     }
 }
 
 namespace Opie {
 
 ODateBookAccessBackend::ODateBookAccessBackend()
-    : OPimAccessBackend<OEvent>()
+    : OPimAccessBackend<OPimEvent>()
 {
 
 }
 ODateBookAccessBackend::~ODateBookAccessBackend() {
 
 }
 OEffectiveEvent::ValueList ODateBookAccessBackend::effectiveEvents( const QDate& from,
                                                                     const QDate& to ) {
     OEffectiveEvent::ValueList tmpList;
-    OEvent::ValueList list = directNonRepeats();
+    OPimEvent::ValueList list = directNonRepeats();
 
     events( tmpList, list, from, to );
     repeat( tmpList, directRawRepeats(),from,to );
 
     list = directRawRepeats();  // Useless, isn't it ? (eilers)
 
     qHeapSort( tmpList );
     return tmpList;
@@ -185,17 +185,17 @@ OEffectiveEvent::ValueList ODateBookAccessBackend::effectiveEvents( const QDateT
     }
 
     return tmpList;
 }
 
 OEffectiveEvent::ValueList ODateBookAccessBackend::effectiveNonRepeatingEvents( const QDate& from,
                                                                     const QDate& to ) {
     OEffectiveEvent::ValueList tmpList;
-    OEvent::ValueList list = directNonRepeats();
+    OPimEvent::ValueList list = directNonRepeats();
 
     events( tmpList, list, from, to );
 
     qHeapSort( tmpList );
     return tmpList;
 }
 
 OEffectiveEvent::ValueList ODateBookAccessBackend::effectiveNonRepeatingEvents( const QDateTime& dt ) {
diff --git a/libopie2/opiepim/backend/odatebookaccessbackend.h b/libopie2/opiepim/backend/odatebookaccessbackend.h
index 6853670..a9cce6a 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend.h
+++ b/libopie2/opiepim/backend/odatebookaccessbackend.h
@@ -27,25 +27,25 @@
                              Boston, MA 02111-1307, USA.
 */
 #ifndef OPIE_DATE_BOOK_ACCESS_BACKEND_H
 #define OPIE_DATE_BOOK_ACCESS_BACKEND_H
 
 #include <qarray.h>
 
 #include <opie2/opimaccessbackend.h>
-#include <opie2/oevent.h>
+#include <opie2/opimevent.h>
 
 namespace Opie {
 /**
  * This class is the interface to the storage of Events.
  * @see OPimAccessBackend
  *
  */
-class ODateBookAccessBackend : public OPimAccessBackend<OEvent> {
+class ODateBookAccessBackend : public OPimAccessBackend<OPimEvent> {
 public:
     typedef int UID;
 
     /**
      * c'tor without parameter
      */
     ODateBookAccessBackend();
     ~ODateBookAccessBackend();
@@ -71,22 +71,22 @@ public:
      */
     virtual QArray<UID> nonRepeats() const = 0;
 
     /**
      * If you do not want to implement the effectiveEvents methods below
      * you need to supply it with directNonRepeats.
      * This method can return empty lists if effectiveEvents is implememted
      */
-    virtual OEvent::ValueList directNonRepeats() = 0;
+    virtual OPimEvent::ValueList directNonRepeats() = 0;
 
     /**
      * Same as above but return raw repeats!
      */
-    virtual OEvent::ValueList directRawRepeats() = 0;
+    virtual OPimEvent::ValueList directRawRepeats() = 0;
 
     /* is implemented by default but you can reimplement it*/
     /**
      * Effective Events are special event occuring during a time frame. This method does calcualte
      * EffectiveEvents bases on the directNonRepeats and directRawRepeats. You may implement this method
      * yourself
      */
     virtual OEffectiveEvent::ValueList effectiveEvents( const QDate& from, const QDate& to );
diff --git a/libopie2/opiepim/backend/odatebookaccessbackend_sql.cpp b/libopie2/opiepim/backend/odatebookaccessbackend_sql.cpp
index e79696c..2ee76cc 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend_sql.cpp
+++ b/libopie2/opiepim/backend/odatebookaccessbackend_sql.cpp
@@ -38,17 +38,17 @@
 #include <qstringlist.h>
 
 #include <qpe/global.h>
 
 #include <opie2/osqldriver.h>
 #include <opie2/osqlmanager.h>
 #include <opie2/osqlquery.h>
 
-#include <opie2/orecur.h>
+#include <opie2/opimrecurrence.h>
 #include <opie2/odatebookaccessbackend_sql.h>
 
 namespace Opie {
 
 
 ODateBookAccessBackend_SQL::ODateBookAccessBackend_SQL( const QString& ,
                                                         const QString& fileName )
 	: ODateBookAccessBackend(), m_driver( NULL ) 
@@ -70,37 +70,37 @@ ODateBookAccessBackend_SQL::~ODateBookAccessBackend_SQL() {
 		delete m_driver;
 }
 
 void ODateBookAccessBackend_SQL::initFields()
 {
 
 	// This map contains the translation of the fieldtype id's to 
 	// the names of the table columns
-	m_fieldMap.insert( OEvent::FUid, "uid" );
-	m_fieldMap.insert( OEvent::FCategories, "Categories" );
-	m_fieldMap.insert( OEvent::FDescription, "Description" );
-	m_fieldMap.insert( OEvent::FLocation, "Location" );
-	m_fieldMap.insert( OEvent::FType, "Type" );
-	m_fieldMap.insert( OEvent::FAlarm, "Alarm" );
-	m_fieldMap.insert( OEvent::FSound, "Sound" );
-	m_fieldMap.insert( OEvent::FRType, "RType" );
-	m_fieldMap.insert( OEvent::FRWeekdays, "RWeekdays" );
-	m_fieldMap.insert( OEvent::FRPosition, "RPosition" );
-	m_fieldMap.insert( OEvent::FRFreq, "RFreq" );
-	m_fieldMap.insert( OEvent::FRHasEndDate, "RHasEndDate" );
-	m_fieldMap.insert( OEvent::FREndDate, "REndDate" );
-	m_fieldMap.insert( OEvent::FRCreated, "RCreated" );
-	m_fieldMap.insert( OEvent::FRExceptions, "RExceptions" );
-	m_fieldMap.insert( OEvent::FStart, "Start" );
-	m_fieldMap.insert( OEvent::FEnd, "End" );
-	m_fieldMap.insert( OEvent::FNote, "Note" );
-	m_fieldMap.insert( OEvent::FTimeZone, "TimeZone" );
-	m_fieldMap.insert( OEvent::FRecParent, "RecParent" );
-	m_fieldMap.insert( OEvent::FRecChildren, "Recchildren" );
+	m_fieldMap.insert( OPimEvent::FUid, "uid" );
+	m_fieldMap.insert( OPimEvent::FCategories, "Categories" );
+	m_fieldMap.insert( OPimEvent::FDescription, "Description" );
+	m_fieldMap.insert( OPimEvent::FLocation, "Location" );
+	m_fieldMap.insert( OPimEvent::FType, "Type" );
+	m_fieldMap.insert( OPimEvent::FAlarm, "Alarm" );
+	m_fieldMap.insert( OPimEvent::FSound, "Sound" );
+	m_fieldMap.insert( OPimEvent::FRType, "RType" );
+	m_fieldMap.insert( OPimEvent::FRWeekdays, "RWeekdays" );
+	m_fieldMap.insert( OPimEvent::FRPosition, "RPosition" );
+	m_fieldMap.insert( OPimEvent::FRFreq, "RFreq" );
+	m_fieldMap.insert( OPimEvent::FRHasEndDate, "RHasEndDate" );
+	m_fieldMap.insert( OPimEvent::FREndDate, "REndDate" );
+	m_fieldMap.insert( OPimEvent::FRCreated, "RCreated" );
+	m_fieldMap.insert( OPimEvent::FRExceptions, "RExceptions" );
+	m_fieldMap.insert( OPimEvent::FStart, "Start" );
+	m_fieldMap.insert( OPimEvent::FEnd, "End" );
+	m_fieldMap.insert( OPimEvent::FNote, "Note" );
+	m_fieldMap.insert( OPimEvent::FTimeZone, "TimeZone" );
+	m_fieldMap.insert( OPimEvent::FRecParent, "RecParent" );
+	m_fieldMap.insert( OPimEvent::FRecChildren, "Recchildren" );
 
 	// Create a map that maps the column name to the id
 	QMapConstIterator<int, QString> it;
 	for ( it = ++m_fieldMap.begin(); it != m_fieldMap.end(); ++it ){
 		m_reverseFieldMap.insert( it.data(), it.key() );
 	}
 	
 }
@@ -160,59 +160,59 @@ bool ODateBookAccessBackend_SQL::save()
 	return m_driver->close();  // Shouldn't m_driver->sync be better than close ? (eilers)
 }
 
 QArray<int> ODateBookAccessBackend_SQL::allRecords()const 
 {
 	return m_uids;
 }
 
-QArray<int> ODateBookAccessBackend_SQL::queryByExample(const OEvent&, int,  const QDateTime& ) {
+QArray<int> ODateBookAccessBackend_SQL::queryByExample(const OPimEvent&, int,  const QDateTime& ) {
 	return QArray<int>();
 }
 
 void ODateBookAccessBackend_SQL::clear() 
 {
 	QString qu = "drop table datebook;";
 	qu += "drop table custom_data;";
 
 	OSQLRawQuery raw( qu );
 	OSQLResult res = m_driver->query( &raw );
 
 	reload();
 }
 
 
-OEvent ODateBookAccessBackend_SQL::find( int uid ) const{
+OPimEvent ODateBookAccessBackend_SQL::find( int uid ) const{
 	QString qu = "select *";
 	qu += "from datebook where uid = " + QString::number(uid);
 
 	OSQLRawQuery raw( qu );
 	OSQLResult res = m_driver->query( &raw );
 
 	OSQLResultItem resItem = res.first();
 
 	// Create Map for date event and insert UID
 	QMap<int,QString> dateEventMap;
-	dateEventMap.insert( OEvent::FUid, QString::number( uid ) );
+	dateEventMap.insert( OPimEvent::FUid, QString::number( uid ) );
 
 	// Now insert the data out of the columns into the map.
 	QMapConstIterator<int, QString> it;
 	for ( it = ++m_fieldMap.begin(); it != m_fieldMap.end(); ++it ){
 		dateEventMap.insert( m_reverseFieldMap[*it], resItem.data( *it ) );
 	}
 
 	// Last step: Put map into date event and return it
-	OEvent retDate( dateEventMap );
+	OPimEvent retDate( dateEventMap );
 
 	return retDate;
 }
 
 // FIXME: Speed up update of uid's..
-bool ODateBookAccessBackend_SQL::add( const OEvent& ev ) 
+bool ODateBookAccessBackend_SQL::add( const OPimEvent& ev ) 
 {
 	QMap<int,QString> eventMap = ev.toMap();
 
 	QString qu = "insert into datebook VALUES( " + QString::number( ev.uid() );
 	QMap<int, QString>::Iterator it;
 	for ( it = ++m_fieldMap.begin(); it != m_fieldMap.end(); ++it ){
 		if ( !eventMap[it.key()].isEmpty() )
 			qu += QString( ",\"%1\"" ).arg( eventMap[it.key()] );
@@ -267,17 +267,17 @@ bool ODateBookAccessBackend_SQL::remove( int uid )
 	}
 
 	// Update list of uid's
 	update();
 
 	return true;
 }
 
-bool ODateBookAccessBackend_SQL::replace( const OEvent& ev ) 
+bool ODateBookAccessBackend_SQL::replace( const OPimEvent& ev ) 
 {
     remove( ev.uid() );
     return add( ev );
 }
 
 QArray<int> ODateBookAccessBackend_SQL::rawEvents()const 
 {
     return allRecords();
@@ -304,32 +304,32 @@ QArray<int> ODateBookAccessBackend_SQL::nonRepeats()const
 	if ( res.state() != OSQLResult::Success ){
 		QArray<int> nix;
 		return nix;
 	}
 	
 	return extractUids( res );
 }
 
-OEvent::ValueList ODateBookAccessBackend_SQL::directNonRepeats() 
+OPimEvent::ValueList ODateBookAccessBackend_SQL::directNonRepeats() 
 {
 	QArray<int> nonRepUids = nonRepeats();
-	OEvent::ValueList list;
+	OPimEvent::ValueList list;
 
 	for (uint i = 0; i < nonRepUids.count(); ++i ){
 		list.append( find( nonRepUids[i] ) );
 	}
 
 	return list;
 
 }
-OEvent::ValueList ODateBookAccessBackend_SQL::directRawRepeats() 
+OPimEvent::ValueList ODateBookAccessBackend_SQL::directRawRepeats() 
 {
 	QArray<int> rawRepUids = rawRepeats();
-	OEvent::ValueList list;
+	OPimEvent::ValueList list;
 
 	for (uint i = 0; i < rawRepUids.count(); ++i ){
 		list.append( find( rawRepUids[i] ) );
 	}
 
 	return list;
 }
 
diff --git a/libopie2/opiepim/backend/odatebookaccessbackend_sql.h b/libopie2/opiepim/backend/odatebookaccessbackend_sql.h
index 89939ef..cbfeb97 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend_sql.h
+++ b/libopie2/opiepim/backend/odatebookaccessbackend_sql.h
@@ -50,29 +50,29 @@ public:
     ~ODateBookAccessBackend_SQL();
 
     bool load();
     bool reload();
     bool save();
 
     QArray<int> allRecords()const;
     QArray<int> matchRegexp(const QRegExp &r) const;
-    QArray<int> queryByExample( const OEvent&, int, const QDateTime& d = QDateTime() );
-    OEvent find( int uid )const;
+    QArray<int> queryByExample( const OPimEvent&, int, const QDateTime& d = QDateTime() );
+    OPimEvent find( int uid )const;
     void clear();
-    bool add( const OEvent& ev );
+    bool add( const OPimEvent& ev );
     bool remove( int uid );
-    bool replace( const OEvent& ev );
+    bool replace( const OPimEvent& ev );
 
     QArray<UID> rawEvents()const;
     QArray<UID> rawRepeats()const;
     QArray<UID> nonRepeats()const;
 
-    OEvent::ValueList directNonRepeats();
-    OEvent::ValueList directRawRepeats();
+    OPimEvent::ValueList directNonRepeats();
+    OPimEvent::ValueList directRawRepeats();
 
 private:
     bool loadFile();
     QString m_fileName;
     QArray<int> m_uids;
 
     QMap<int, QString> m_fieldMap;
     QMap<QString, int> m_reverseFieldMap;
diff --git a/libopie2/opiepim/backend/odatebookaccessbackend_xml.cpp b/libopie2/opiepim/backend/odatebookaccessbackend_xml.cpp
index 0ebda98..77c0253 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend_xml.cpp
+++ b/libopie2/opiepim/backend/odatebookaccessbackend_xml.cpp
@@ -41,18 +41,18 @@
 #include <qasciidict.h>
 #include <qfile.h>
 
 #include <qtopia/global.h>
 #include <qtopia/stringutil.h>
 #include <qtopia/timeconversion.h>
 
 #include <opie2/opimnotifymanager.h>
-#include <opie2/orecur.h>
-#include <opie2/otimezone.h>
+#include <opie2/opimrecurrence.h>
+#include <opie2/opimtimezone.h>
 #include <opie2/odatebookaccessbackend_xml.h>
 
 using namespace Opie;
 
 namespace {
     // FROM TT again
 char *strstrlen(const char *haystack, int hLen, const char* needle, int nLen)
 {
@@ -76,20 +76,20 @@ char *strstrlen(const char *haystack, int hLen, const char* needle, int nLen)
 	hsearch--;
     }
     return ((char *)hsearch);
 }
 }
 
 namespace {
     time_t start, end, created, rp_end;
-    ORecur* rec;
-    ORecur* recur() {
+    OPimRecurrence* rec;
+    OPimRecurrence* recur() {
         if (!rec)
-            rec = new ORecur;
+            rec = new OPimRecurrence;
 
         return rec;
     }
     int alarmTime;
     int snd;
     enum Attribute{
         FDescription = 0,
         FLocation,
@@ -109,18 +109,18 @@ namespace {
 	FNote,
 	FCreated,      // Should't this be called FRCreated ?
         FTimeZone,
         FRecParent,
         FRecChildren,
         FExceptions
     };
 
-    // FIXME: Use OEvent::toMap() here !! (eilers)
-    inline void save( const OEvent& ev, QString& buf ) {
+    // FIXME: Use OPimEvent::toMap() here !! (eilers)
+    inline void save( const OPimEvent& ev, QString& buf ) {
         qWarning("Saving %d %s", ev.uid(), ev.description().latin1() );
         buf += " description=\"" + Qtopia::escapeString(ev.description() ) + "\"";
         if (!ev.location().isEmpty() )
             buf += " location=\"" + Qtopia::escapeString(ev.location() ) + "\"";
 
         buf += " categories=\""+ Qtopia::escapeString( Qtopia::Record::idsToString( ev.categories() ) ) + "\"";
         buf += " uid=\"" + QString::number( ev.uid() ) + "\"";
 
@@ -141,19 +141,19 @@ namespace {
             buf += ev.recurrence().toString();
         }
 
         /*
          * fscking timezones :) well, we'll first convert
          * the QDateTime to a QDateTime in UTC time
          * and then we'll create a nice time_t
          */
-        OTimeZone zone( ev.timeZone().isEmpty() ? OTimeZone::current() : ev.timeZone() );
-        buf += " start=\"" + QString::number( zone.fromUTCDateTime( zone.toDateTime( ev.startDateTime(), OTimeZone::utc() ) ) )  + "\"";
-        buf += " end=\""   + QString::number( zone.fromUTCDateTime( zone.toDateTime( ev.endDateTime()  , OTimeZone::utc() ) ) )   + "\"";
+        OPimTimeZone zone( ev.timeZone().isEmpty() ? OPimTimeZone::current() : ev.timeZone() );
+        buf += " start=\"" + QString::number( zone.fromUTCDateTime( zone.toDateTime( ev.startDateTime(), OPimTimeZone::utc() ) ) )  + "\"";
+        buf += " end=\""   + QString::number( zone.fromUTCDateTime( zone.toDateTime( ev.endDateTime()  , OPimTimeZone::utc() ) ) )   + "\"";
         if (!ev.note().isEmpty() ) {
             buf += " note=\"" + Qtopia::escapeString( ev.note() ) + "\"";
         }
 
         buf += " timezone=\"";
         if ( ev.timeZone().isEmpty() )
             buf += "None";
         else
@@ -172,18 +172,18 @@ namespace {
                 buf += QString::number( children[i] );
             }
             buf+= "\"";
         }
 
         // skip custom writing
     }
 
-    inline bool forAll( const QMap<int, OEvent>& list, QFile& file ) {
-        QMap<int, OEvent>::ConstIterator it;
+    inline bool forAll( const QMap<int, OPimEvent>& list, QFile& file ) {
+        QMap<int, OPimEvent>::ConstIterator it;
         QString buf;
         QCString str;
         int total_written;
         for ( it = list.begin(); it != list.end(); ++it ) {
             buf = "<event";
             save( it.data(), buf );
             buf += " />\n";
             str = buf.utf8();
@@ -259,108 +259,108 @@ bool ODateBookAccessBackend_XML::save() {
     }
 
     m_changed = false;
     return true;
 }
 QArray<int> ODateBookAccessBackend_XML::allRecords()const {
     QArray<int> ints( m_raw.count()+ m_rep.count() );
     uint i = 0;
-    QMap<int, OEvent>::ConstIterator it;
+    QMap<int, OPimEvent>::ConstIterator it;
 
     for ( it = m_raw.begin(); it != m_raw.end(); ++it ) {
         ints[i] = it.key();
         i++;
     }
     for ( it = m_rep.begin(); it != m_rep.end(); ++it ) {
         ints[i] = it.key();
         i++;
     }
 
     return ints;
 }
-QArray<int> ODateBookAccessBackend_XML::queryByExample(const OEvent&, int,  const QDateTime& ) {
+QArray<int> ODateBookAccessBackend_XML::queryByExample(const OPimEvent&, int,  const QDateTime& ) {
     return QArray<int>();
 }
 void ODateBookAccessBackend_XML::clear() {
     m_changed = true;
     m_raw.clear();
     m_rep.clear();
 }
-OEvent ODateBookAccessBackend_XML::find( int uid ) const{
+OPimEvent ODateBookAccessBackend_XML::find( int uid ) const{
     if ( m_raw.contains( uid ) )
         return m_raw[uid];
     else
         return m_rep[uid];
 }
-bool ODateBookAccessBackend_XML::add( const OEvent& ev ) {
+bool ODateBookAccessBackend_XML::add( const OPimEvent& ev ) {
     m_changed = true;
     if (ev.hasRecurrence() )
         m_rep.insert( ev.uid(), ev );
     else
         m_raw.insert( ev.uid(), ev );
 
     return true;
 }
 bool ODateBookAccessBackend_XML::remove( int uid ) {
     m_changed = true;
     m_rep.remove( uid );
     m_rep.remove( uid );
 
     return true;
 }
-bool ODateBookAccessBackend_XML::replace( const OEvent& ev ) {
+bool ODateBookAccessBackend_XML::replace( const OPimEvent& ev ) {
     replace( ev.uid() ); // ??? Shouldn't this be "remove( ev.uid() ) ??? (eilers)
     return add( ev );
 }
 QArray<int> ODateBookAccessBackend_XML::rawEvents()const {
     return allRecords();
 }
 QArray<int> ODateBookAccessBackend_XML::rawRepeats()const {
     QArray<int> ints( m_rep.count() );
     uint i = 0;
-    QMap<int, OEvent>::ConstIterator it;
+    QMap<int, OPimEvent>::ConstIterator it;
 
     for ( it = m_rep.begin(); it != m_rep.end(); ++it ) {
         ints[i] = it.key();
         i++;
     }
 
     return ints;
 }
 QArray<int> ODateBookAccessBackend_XML::nonRepeats()const {
     QArray<int> ints( m_raw.count() );
     uint i = 0;
-    QMap<int, OEvent>::ConstIterator it;
+    QMap<int, OPimEvent>::ConstIterator it;
 
     for ( it = m_raw.begin(); it != m_raw.end(); ++it ) {
         ints[i] = it.key();
         i++;
     }
 
     return ints;
 }
-OEvent::ValueList ODateBookAccessBackend_XML::directNonRepeats() {
-    OEvent::ValueList list;
-    QMap<int, OEvent>::ConstIterator it;
+OPimEvent::ValueList ODateBookAccessBackend_XML::directNonRepeats() {
+    OPimEvent::ValueList list;
+    QMap<int, OPimEvent>::ConstIterator it;
     for (it = m_raw.begin(); it != m_raw.end(); ++it )
         list.append( it.data() );
 
     return list;
 }
-OEvent::ValueList ODateBookAccessBackend_XML::directRawRepeats() {
-    OEvent::ValueList list;
-    QMap<int, OEvent>::ConstIterator it;
+OPimEvent::ValueList ODateBookAccessBackend_XML::directRawRepeats() {
+    OPimEvent::ValueList list;
+    QMap<int, OPimEvent>::ConstIterator it;
     for (it = m_rep.begin(); it != m_rep.end(); ++it )
         list.append( it.data() );
 
     return list;
 }
 
-// FIXME: Use OEvent::fromMap() (eilers)
+// FIXME: Use OPimEvent::fromMap() (eilers)
 bool ODateBookAccessBackend_XML::loadFile() {
     m_changed = false;
 
     int fd = ::open( QFile::encodeName(m_name).data(), O_RDONLY );
     if ( fd < 0 ) return false;
 
     struct stat attribute;
     if ( ::fstat(fd, &attribute ) == -1 ) {
@@ -409,17 +409,17 @@ bool ODateBookAccessBackend_XML::loadFile() {
     int *find;
     while ( (  point = ::strstrlen( dt+i, len -i, collectionString, strLen ) ) != 0  ) {
         i = point -dt;
         i+= strLen;
 
         alarmTime = -1;
         snd = 0; // silent
 
-        OEvent ev;
+        OPimEvent ev;
         rec = 0;
 
         while ( TRUE ) {
             while ( i < len && (dt[i] == ' ' || dt[i] == '\n' || dt[i] == '\r') )
 		++i;
 	    if ( i >= len-2 || (dt[i] == '/' && dt[i+1] == '>') )
 		break;
 
@@ -475,38 +475,38 @@ bool ODateBookAccessBackend_XML::loadFile() {
         delete rec;
     }
     ::munmap(map_addr, attribute.st_size );
     m_changed = false; // changed during add
 
     return true;
 }
 
-// FIXME: Use OEvent::fromMap() which makes this obsolete.. (eilers)
-void ODateBookAccessBackend_XML::finalizeRecord( OEvent& ev ) {
+// FIXME: Use OPimEvent::fromMap() which makes this obsolete.. (eilers)
+void ODateBookAccessBackend_XML::finalizeRecord( OPimEvent& ev ) {
     /* AllDay is alway in UTC */
     if ( ev.isAllDay() ) {
-        OTimeZone utc = OTimeZone::utc();
+        OPimTimeZone utc = OPimTimeZone::utc();
         ev.setStartDateTime( utc.fromUTCDateTime( start ) );
         ev.setEndDateTime  ( utc.fromUTCDateTime( end   ) );
         ev.setTimeZone( "UTC"); // make sure it is really utc
     }else {
         /* to current date time */
         // qWarning(" Start is %d", start );
-        OTimeZone zone( ev.timeZone().isEmpty() ? OTimeZone::current() : ev.timeZone() );
+        OPimTimeZone zone( ev.timeZone().isEmpty() ? OPimTimeZone::current() : ev.timeZone() );
         QDateTime date = zone.toDateTime( start );
         qWarning(" Start is %s", date.toString().latin1() );
-        ev.setStartDateTime( zone.toDateTime( date, OTimeZone::current() ) );
+        ev.setStartDateTime( zone.toDateTime( date, OPimTimeZone::current() ) );
 
         date = zone.toDateTime( end );
-        ev.setEndDateTime  ( zone.toDateTime( date, OTimeZone::current()   ) );
+        ev.setEndDateTime  ( zone.toDateTime( date, OPimTimeZone::current()   ) );
     }
     if ( rec && rec->doesRecur() ) {
-        OTimeZone utc = OTimeZone::utc();
-        ORecur recu( *rec ); // call copy c'tor;
+        OPimTimeZone utc = OPimTimeZone::utc();
+        OPimRecurrence recu( *rec ); // call copy c'tor;
         recu.setEndDate ( utc.fromUTCDateTime( rp_end ).date() );
         recu.setCreatedDateTime( utc.fromUTCDateTime( created ) );
         recu.setStart( ev.startDateTime().date() );
         ev.setRecurrence( recu );
     }
 
     if (alarmTime != -1 ) {
         QDateTime dt = ev.startDateTime().addSecs( -1*alarmTime*60 );
@@ -519,17 +519,17 @@ void ODateBookAccessBackend_XML::finalizeRecord( OEvent& ev ) {
     }
     qWarning("addind %d %s", ev.uid(), ev.description().latin1() );
     if ( ev.hasRecurrence() )
         m_rep.insert( ev.uid(), ev );
     else
         m_raw.insert( ev.uid(), ev );
 
 }
-void ODateBookAccessBackend_XML::setField( OEvent& e, int id, const QString& value) {
+void ODateBookAccessBackend_XML::setField( OPimEvent& e, int id, const QString& value) {
 //    qWarning(" setting %s", value.latin1() );
     switch( id ) {
     case FDescription:
         e.setDescription( value );
         break;
     case FLocation:
         e.setLocation( value );
         break;
@@ -549,27 +549,27 @@ void ODateBookAccessBackend_XML::setField( OEvent& e, int id, const QString& val
         alarmTime = value.toInt();
         break;
     case FSound:
         snd = value == "loud" ? OPimAlarm::Loud : OPimAlarm::Silent;
         break;
         // recurrence stuff
     case FRType:
         if ( value == "Daily" )
-            recur()->setType( ORecur::Daily );
+            recur()->setType( OPimRecurrence::Daily );
         else if ( value == "Weekly" )
-            recur()->setType( ORecur::Weekly);
+            recur()->setType( OPimRecurrence::Weekly);
         else if ( value == "MonthlyDay" )
-            recur()->setType( ORecur::MonthlyDay );
+            recur()->setType( OPimRecurrence::MonthlyDay );
         else if ( value == "MonthlyDate" )
-            recur()->setType( ORecur::MonthlyDate );
+            recur()->setType( OPimRecurrence::MonthlyDate );
         else if ( value == "Yearly" )
-            recur()->setType( ORecur::Yearly );
+            recur()->setType( OPimRecurrence::Yearly );
         else
-            recur()->setType( ORecur::NoRepeat );
+            recur()->setType( OPimRecurrence::NoRepeat );
         break;
     case FRWeekdays:
         recur()->setDays( value.toInt() );
         break;
     case FRPosition:
         recur()->setPosition( value.toInt() );
         break;
     case FRFreq:
@@ -622,17 +622,17 @@ void ODateBookAccessBackend_XML::setField( OEvent& e, int id, const QString& val
     default:
         break;
     }
 }
 QArray<int> ODateBookAccessBackend_XML::matchRegexp(  const QRegExp &r ) const
 {
     QArray<int> m_currentQuery( m_raw.count()+ m_rep.count() );
     uint arraycounter = 0;
-    QMap<int, OEvent>::ConstIterator it;
+    QMap<int, OPimEvent>::ConstIterator it;
 
     for ( it = m_raw.begin(); it != m_raw.end(); ++it )
         if ( it.data().match( r ) )
             m_currentQuery[arraycounter++] = it.data().uid();
     for ( it = m_rep.begin(); it != m_rep.end(); ++it )
         if ( it.data().match( r ) )
             m_currentQuery[arraycounter++] = it.data().uid();
 
diff --git a/libopie2/opiepim/backend/odatebookaccessbackend_xml.h b/libopie2/opiepim/backend/odatebookaccessbackend_xml.h
index 29f5f4f..6823ce6 100644
--- a/libopie2/opiepim/backend/odatebookaccessbackend_xml.h
+++ b/libopie2/opiepim/backend/odatebookaccessbackend_xml.h
@@ -47,38 +47,38 @@ public:
     ~ODateBookAccessBackend_XML();
 
     bool load();
     bool reload();
     bool save();
 
     QArray<int> allRecords()const;
     QArray<int> matchRegexp(const QRegExp &r) const;
-    QArray<int> queryByExample( const OEvent&, int, const QDateTime& d = QDateTime() );
-    OEvent find( int uid )const;
+    QArray<int> queryByExample( const OPimEvent&, int, const QDateTime& d = QDateTime() );
+    OPimEvent find( int uid )const;
     void clear();
-    bool add( const OEvent& ev );
+    bool add( const OPimEvent& ev );
     bool remove( int uid );
-    bool replace( const OEvent& ev );
+    bool replace( const OPimEvent& ev );
 
     QArray<UID> rawEvents()const;
     QArray<UID> rawRepeats()const;
     QArray<UID> nonRepeats()const;
 
-    OEvent::ValueList directNonRepeats();
-    OEvent::ValueList directRawRepeats();
+    OPimEvent::ValueList directNonRepeats();
+    OPimEvent::ValueList directRawRepeats();
 
 private:
     bool m_changed :1 ;
     bool loadFile();
-    inline void finalizeRecord( OEvent& ev );
-    inline void setField( OEvent&, int field, const QString& val );
+    inline void finalizeRecord( OPimEvent& ev );
+    inline void setField( OPimEvent&, int field, const QString& val );
     QString m_name;
-    QMap<int, OEvent> m_raw;
-    QMap<int, OEvent> m_rep;
+    QMap<int, OPimEvent> m_raw;
+    QMap<int, OPimEvent> m_rep;
 
     struct Data;
     Data* data;
     class Private;
     Private *d;
 };
 
 }
diff --git a/libopie2/opiepim/backend/opimaccessbackend.h b/libopie2/opiepim/backend/opimaccessbackend.h
index 505358e..0682063 100644
--- a/libopie2/opiepim/backend/opimaccessbackend.h
+++ b/libopie2/opiepim/backend/opimaccessbackend.h
@@ -27,17 +27,17 @@
                              Boston, MA 02111-1307, USA.
 */
 #ifndef OPIE_PIM_ACCESS_BACKEND
 #define OPIE_PIM_ACCESS_BACKEND
 
 #include <qarray.h>
 #include <qdatetime.h>
 
-#include <opie2/otemplatebase.h>
+#include <opie2/opimtemplatebase.h>
 #include <opie2/opimrecord.h>
 
 
 namespace Opie {
 class OPimAccessBackendPrivate;
 /**
  * OPimAccessBackend is the base class
  * for all private backends
diff --git a/libopie2/opiepim/backend/otodoaccessbackend.cpp b/libopie2/opiepim/backend/otodoaccessbackend.cpp
index d27f5ef..790a764 100644
--- a/libopie2/opiepim/backend/otodoaccessbackend.cpp
+++ b/libopie2/opiepim/backend/otodoaccessbackend.cpp
@@ -25,17 +25,17 @@
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 #include <opie2/otodoaccessbackend.h>
 
 namespace Opie {
-OTodoAccessBackend::OTodoAccessBackend()
-    : OPimAccessBackend<OTodo>()
+OPimTodoAccessBackend::OPimTodoAccessBackend()
+    : OPimAccessBackend<OPimTodo>()
 {
 }
-OTodoAccessBackend::~OTodoAccessBackend() {
+OPimTodoAccessBackend::~OPimTodoAccessBackend() {
 
 }
 
 }
diff --git a/libopie2/opiepim/backend/otodoaccessbackend.h b/libopie2/opiepim/backend/otodoaccessbackend.h
index 54b52cc..9dfda45 100644
--- a/libopie2/opiepim/backend/otodoaccessbackend.h
+++ b/libopie2/opiepim/backend/otodoaccessbackend.h
@@ -26,24 +26,24 @@
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 #ifndef OPIE_TODO_ACCESS_BACKEND_H
 #define OPIE_TODO_ACCESS_BACKEND_H
 
 #include <qbitarray.h>
 
-#include <opie2/otodo.h>
+#include <opie2/opimtodo.h>
 #include <opie2/opimaccessbackend.h>
 
 namespace Opie {
-class OTodoAccessBackend : public OPimAccessBackend<OTodo> {
+class OPimTodoAccessBackend : public OPimAccessBackend<OPimTodo> {
 public:
-    OTodoAccessBackend();
-    ~OTodoAccessBackend();
+    OPimTodoAccessBackend();
+    ~OPimTodoAccessBackend();
     virtual QArray<int> effectiveToDos( const QDate& start,
                                         const QDate& end,
                                         bool includeNoDates ) = 0;
     virtual QArray<int> overDue() = 0;
     virtual QArray<int> sorted( bool asc, int sortOrder, int sortFilter,
                                 int cat ) = 0;
     virtual void        removeAllCompleted() = 0;
     virtual QBitArray supports()const = 0;
diff --git a/libopie2/opiepim/backend/otodoaccesssql.cpp b/libopie2/opiepim/backend/otodoaccesssql.cpp
index 944f82a..72232e5 100644
--- a/libopie2/opiepim/backend/otodoaccesssql.cpp
+++ b/libopie2/opiepim/backend/otodoaccesssql.cpp
@@ -34,17 +34,17 @@
 #include <opie2/osqldriver.h>
 #include <opie2/osqlresult.h>
 #include <opie2/osqlmanager.h>
 #include <opie2/osqlquery.h>
 
 #include <opie2/otodoaccesssql.h>
 #include <opie2/opimstate.h>
 #include <opie2/opimnotifymanager.h>
-#include <opie2/orecur.h>
+#include <opie2/opimrecurrence.h>
 
 using namespace Opie;
 /*
  * first some query
  * CREATE query
  * LOAD query
  * INSERT
  * REMOVE
@@ -68,25 +68,25 @@ namespace {
     class LoadQuery : public OSQLQuery {
     public:
         LoadQuery();
         ~LoadQuery();
         QString query()const;
     };
 
     /**
-     * inserts/adds a OTodo to the table
+     * inserts/adds a OPimTodo to the table
      */
     class InsertQuery : public OSQLQuery {
     public:
-        InsertQuery(const OTodo& );
+        InsertQuery(const OPimTodo& );
         ~InsertQuery();
         QString query()const;
     private:
-        OTodo m_todo;
+        OPimTodo m_todo;
     };
 
     /**
      * removes one from the table
      */
     class RemoveQuery : public OSQLQuery {
     public:
         RemoveQuery(int uid );
@@ -147,17 +147,17 @@ namespace {
 
 
     CreateQuery::CreateQuery() : OSQLQuery() {}
     CreateQuery::~CreateQuery() {}
     QString CreateQuery::query()const {
         QString qu;
         qu += "create table todolist( uid PRIMARY KEY, categories, completed, ";
         qu += "description, summary, priority, DueDate, progress ,  state, ";
-	// This is the recurrance-stuff .. Exceptions are currently not supported (see ORecur.cpp) ! (eilers)
+	// This is the recurrance-stuff .. Exceptions are currently not supported (see OPimRecurrence.cpp) ! (eilers)
 	qu += "RType, RWeekdays, RPosition, RFreq, RHasEndDate, EndDate, Created, Exceptions, "; 
 	qu += "reminders, alarms, maintainer, startdate, completeddate);";
 	qu += "create table custom_data( uid INTEGER, id INTEGER, type VARCHAR(10), value VARCHAR(10), PRIMARY KEY /* identifier */ (uid, id) );";
         return qu;
     }
 
     LoadQuery::LoadQuery() : OSQLQuery() {}
     LoadQuery::~LoadQuery() {}
@@ -165,23 +165,23 @@ namespace {
         QString qu;
 	// We do not need "distinct" here. The primary key is always unique..
         //qu += "select distinct uid from todolist";
         qu += "select uid from todolist";
 
         return qu;
     }
 
-    InsertQuery::InsertQuery( const OTodo& todo )
+    InsertQuery::InsertQuery( const OPimTodo& todo )
         : OSQLQuery(), m_todo( todo ) {
     }
     InsertQuery::~InsertQuery() {
     }
     /*
-     * converts from a OTodo to a query
+     * converts from a OPimTodo to a query
      * we leave out X-Ref + Alarms
      */
     QString InsertQuery::query()const{
 
         int year, month, day;
         year = month = day = 0;
         if (m_todo.hasDueDate() ) {
             QDate date = m_todo.dueDate();
@@ -213,24 +213,24 @@ namespace {
 		+ "'" + m_todo.description()                      + "'" + ","
 		+ "'" + m_todo.summary()                          + "'" + "," 
 		+       QString::number(m_todo.priority() )             + ","
 		+ "'" + QString::number(year) + "-" 
 		+       QString::number(month)
 		+       "-" + QString::number( day )              + "'" + ","
 		+       QString::number( m_todo.progress() )            + ","
  		+       QString::number( m_todo.state().state() )       + ","
-		+ "'" + recMap[ ORecur::RType ]                   + "'" + ","
-		+ "'" + recMap[ ORecur::RWeekdays ]               + "'" + ","
-		+ "'" + recMap[ ORecur::RPosition ]               + "'" + ","
-		+ "'" + recMap[ ORecur::RFreq ]                   + "'" + ","
-		+ "'" + recMap[ ORecur::RHasEndDate ]             + "'" + ","
-		+ "'" + recMap[ ORecur::EndDate ]                 + "'" + ","
-		+ "'" + recMap[ ORecur::Created ]                 + "'" + ","
-		+ "'" + recMap[ ORecur::Exceptions ]              + "'" + ",";
+		+ "'" + recMap[ OPimRecurrence::RType ]                   + "'" + ","
+		+ "'" + recMap[ OPimRecurrence::RWeekdays ]               + "'" + ","
+		+ "'" + recMap[ OPimRecurrence::RPosition ]               + "'" + ","
+		+ "'" + recMap[ OPimRecurrence::RFreq ]                   + "'" + ","
+		+ "'" + recMap[ OPimRecurrence::RHasEndDate ]             + "'" + ","
+		+ "'" + recMap[ OPimRecurrence::EndDate ]                 + "'" + ","
+		+ "'" + recMap[ OPimRecurrence::Created ]                 + "'" + ","
+		+ "'" + recMap[ OPimRecurrence::Exceptions ]              + "'" + ",";
 	
 	if ( m_todo.hasNotifiers() ) {
 		OPimNotifyManager manager = m_todo.notifiers();
 		qu += "'" + manager.remindersToString()           + "'" + ","		
 			+ "'" + manager.alarmsToString()          + "'" + ",";
 	}
 	else{
 		qu += QString( "''" )                                   + ","
@@ -324,72 +324,72 @@ namespace {
             .arg(m_end.  year() ).arg(m_end.  month() ).arg(m_end.day() );
 
         return str;
     }
 };
 
 
 namespace Opie {
-OTodoAccessBackendSQL::OTodoAccessBackendSQL( const QString& file )
-    : OTodoAccessBackend(), m_dict(15), m_driver(NULL), m_dirty(true)
+OPimTodoAccessBackendSQL::OPimTodoAccessBackendSQL( const QString& file )
+    : OPimTodoAccessBackend(), m_dict(15), m_driver(NULL), m_dirty(true)
 {
     QString fi = file;
     if ( fi.isEmpty() )
         fi = Global::applicationFileName( "todolist", "todolist.db" );
     OSQLManager man;
     m_driver = man.standard();
     m_driver->setUrl(fi);
     // fillDict();
 }
 
-OTodoAccessBackendSQL::~OTodoAccessBackendSQL(){
+OPimTodoAccessBackendSQL::~OPimTodoAccessBackendSQL(){
 	if( m_driver )
 		delete m_driver;
 }
 
-bool OTodoAccessBackendSQL::load(){
+bool OPimTodoAccessBackendSQL::load(){
     if (!m_driver->open() )
         return false;
 
     CreateQuery creat;
     OSQLResult res = m_driver->query(&creat );
 
     m_dirty = true;
     return true;
 }
-bool OTodoAccessBackendSQL::reload(){
+bool OPimTodoAccessBackendSQL::reload(){
     return load();
 }
 
-bool OTodoAccessBackendSQL::save(){
+bool OPimTodoAccessBackendSQL::save(){
     return m_driver->close();  // Shouldn't m_driver->sync be better than close ? (eilers)
 }
-QArray<int> OTodoAccessBackendSQL::allRecords()const {
+QArray<int> OPimTodoAccessBackendSQL::allRecords()const {
     if (m_dirty )
         update();
 
     return m_uids;
 }
-QArray<int> OTodoAccessBackendSQL::queryByExample( const OTodo& , int, const QDateTime& ){
+QArray<int> OPimTodoAccessBackendSQL::queryByExample( const OPimTodo& , int, const QDateTime& ){
     QArray<int> ints(0);
     return ints;
 }
-OTodo OTodoAccessBackendSQL::find(int uid ) const{
+OPimTodo OPimTodoAccessBackendSQL::find(int uid ) const{
     FindQuery query( uid );
     return todo( m_driver->query(&query) );
 
 }
-OTodo OTodoAccessBackendSQL::find( int uid, const QArray<int>& ints,
+OPimTodo OPimTodoAccessBackendSQL::find( int uid, const QArray<int>& ints,
                                    uint cur, Frontend::CacheDirection dir ) const{
     uint CACHE = readAhead();
     qWarning("searching for %d", uid );
     QArray<int> search( CACHE );
     uint size =0;
-    OTodo to;
+    OPimTodo to;
 
     // we try to cache CACHE items
     switch( dir ) {
         /* forward */
     case 0: // FIXME: Not a good style to use magic numbers here (eilers)
         for (uint i = cur; i < ints.count() && size < CACHE; i++ ) {
             qWarning("size %d %d", size,  ints[i] );
             search[size] = ints[i];
@@ -407,69 +407,69 @@ OTodo OTodoAccessBackendSQL::find( int uid, const QArray<int>& ints,
     search.resize( size );
     FindQuery query( search );
     OSQLResult res = m_driver->query( &query  );
     if ( res.state() != OSQLResult::Success )
         return to;
 
     return todo( res );
 }
-void OTodoAccessBackendSQL::clear() {
+void OPimTodoAccessBackendSQL::clear() {
     ClearQuery cle;
     OSQLResult res = m_driver->query( &cle );
     CreateQuery qu;
     res = m_driver->query(&qu);
 }
-bool OTodoAccessBackendSQL::add( const OTodo& t) {
+bool OPimTodoAccessBackendSQL::add( const OPimTodo& t) {
     InsertQuery ins( t );
     OSQLResult res = m_driver->query( &ins );
 
     if ( res.state() == OSQLResult::Failure )
         return false;
     int c = m_uids.count();
     m_uids.resize( c+1 );
     m_uids[c] = t.uid();
 
     return true;
 }
-bool OTodoAccessBackendSQL::remove( int uid ) {
+bool OPimTodoAccessBackendSQL::remove( int uid ) {
     RemoveQuery rem( uid );
     OSQLResult res = m_driver->query(&rem );
 
     if ( res.state() == OSQLResult::Failure )
         return false;
 
     m_dirty = true;
     return true;
 }
 /*
  * FIXME better set query
  * but we need the cache for that
  * now we remove
  */
-bool OTodoAccessBackendSQL::replace( const OTodo& t) {
+bool OPimTodoAccessBackendSQL::replace( const OPimTodo& t) {
     remove( t.uid() );
     bool b= add(t);
     m_dirty = false; // we changed some stuff but the UID stayed the same
     return b;
 }
-QArray<int> OTodoAccessBackendSQL::overDue() {
+QArray<int> OPimTodoAccessBackendSQL::overDue() {
     OverDueQuery qu;
     return uids( m_driver->query(&qu ) );
 }
-QArray<int> OTodoAccessBackendSQL::effectiveToDos( const QDate& s,
+QArray<int> OPimTodoAccessBackendSQL::effectiveToDos( const QDate& s,
                                                    const QDate& t,
                                                    bool u) {
     EffQuery ef(s, t, u );
     return uids (m_driver->query(&ef) );
 }
 /*
  *
  */
-QArray<int> OTodoAccessBackendSQL::sorted( bool asc, int sortOrder,
+QArray<int> OPimTodoAccessBackendSQL::sorted( bool asc, int sortOrder,
                                            int sortFilter, int cat ) {
     qWarning("sorted %d, %d", asc, sortOrder );
     QString query;
     query = "select uid from todolist WHERE ";
 
     /*
      * Sort Filter stuff
      * not that straight forward
@@ -525,57 +525,57 @@ QArray<int> OTodoAccessBackendSQL::sorted( bool asc, int sortOrder,
         qWarning("not ascending!");
         query += " DESC";
     }
 
     qWarning( query );
     OSQLRawQuery raw(query );
     return uids( m_driver->query(&raw) );
 }
-bool OTodoAccessBackendSQL::date( QDate& da, const QString& str ) const{
+bool OPimTodoAccessBackendSQL::date( QDate& da, const QString& str ) const{
     if ( str == "0-0-0" )
         return false;
     else{
         int day, year, month;
         QStringList list = QStringList::split("-", str );
         year = list[0].toInt();
         month = list[1].toInt();
         day = list[2].toInt();
         da.setYMD( year, month, day );
         return true;
     }
 }
-OTodo OTodoAccessBackendSQL::todo( const OSQLResult& res) const{
+OPimTodo OPimTodoAccessBackendSQL::todo( const OSQLResult& res) const{
     if ( res.state() == OSQLResult::Failure ) {
-        OTodo to;
+        OPimTodo to;
         return to;
     }
 
     OSQLResultItem::ValueList list = res.results();
     OSQLResultItem::ValueList::Iterator it = list.begin();
     qWarning("todo1");
-    OTodo to = todo( (*it) );
+    OPimTodo to = todo( (*it) );
     cache( to );
     ++it;
 
     for ( ; it != list.end(); ++it ) {
         qWarning("caching");
         cache( todo( (*it) ) );
     }
     return to;
 }
-OTodo OTodoAccessBackendSQL::todo( OSQLResultItem& item )const {
+OPimTodo OPimTodoAccessBackendSQL::todo( OSQLResultItem& item )const {
     qWarning("todo");
     bool hasDueDate = false; QDate dueDate = QDate::currentDate();
     hasDueDate = date( dueDate, item.data("DueDate") );
     QStringList cats = QStringList::split(";", item.data("categories") );
 
     qWarning("Item is completed: %d", item.data("completed").toInt() );
 
-    OTodo to( (bool)item.data("completed").toInt(), item.data("priority").toInt(),
+    OPimTodo to( (bool)item.data("completed").toInt(), item.data("priority").toInt(),
               cats, item.data("summary"), item.data("description"),
               item.data("progress").toUShort(), hasDueDate, dueDate,
               item.data("uid").toInt() );
 
     bool isOk;
     int prioInt = QString( item.data("priority") ).toInt( &isOk );
     if ( isOk )
 	    to.setPriority( prioInt );
@@ -594,133 +594,133 @@ OTodo OTodoAccessBackendSQL::todo( OSQLResultItem& item )const {
     manager.alarmsFromString( item.data("alarms") );
     manager.remindersFromString( item.data("reminders") );
 
     OPimState pimState;
     pimState.setState( QString( item.data("state") ).toInt() );
     to.setState( pimState );
 
     QMap<int, QString> recMap;
-    recMap.insert( ORecur::RType      , item.data("RType") );
-    recMap.insert( ORecur::RWeekdays  , item.data("RWeekdays") );
-    recMap.insert( ORecur::RPosition  , item.data("RPosition") );
-    recMap.insert( ORecur::RFreq      , item.data("RFreq") );
-    recMap.insert( ORecur::RHasEndDate, item.data("RHasEndDate") );
-    recMap.insert( ORecur::EndDate    , item.data("EndDate") );
-    recMap.insert( ORecur::Created    , item.data("Created") );
-    recMap.insert( ORecur::Exceptions , item.data("Exceptions") );
+    recMap.insert( OPimRecurrence::RType      , item.data("RType") );
+    recMap.insert( OPimRecurrence::RWeekdays  , item.data("RWeekdays") );
+    recMap.insert( OPimRecurrence::RPosition  , item.data("RPosition") );
+    recMap.insert( OPimRecurrence::RFreq      , item.data("RFreq") );
+    recMap.insert( OPimRecurrence::RHasEndDate, item.data("RHasEndDate") );
+    recMap.insert( OPimRecurrence::EndDate    , item.data("EndDate") );
+    recMap.insert( OPimRecurrence::Created    , item.data("Created") );
+    recMap.insert( OPimRecurrence::Exceptions , item.data("Exceptions") );
     
-    ORecur recur;
+    OPimRecurrence recur;
     recur.fromMap( recMap );
     to.setRecurrence( recur );
 
     return to;
 }
-OTodo OTodoAccessBackendSQL::todo( int uid )const {
+OPimTodo OPimTodoAccessBackendSQL::todo( int uid )const {
     FindQuery find( uid );
     return todo( m_driver->query(&find) );
 }
 /*
  * update the dict
  */
-void OTodoAccessBackendSQL::fillDict() {
+void OPimTodoAccessBackendSQL::fillDict() {
     /* initialize dict */
     /*
      * UPDATE dict if you change anything!!!
      * FIXME: Isn't this dict obsolete ? (eilers)
      */
     m_dict.setAutoDelete( TRUE );
-    m_dict.insert("Categories" ,     new int(OTodo::Category)         );
-    m_dict.insert("Uid" ,            new int(OTodo::Uid)              );
-    m_dict.insert("HasDate" ,        new int(OTodo::HasDate)          );
-    m_dict.insert("Completed" ,      new int(OTodo::Completed)        );
-    m_dict.insert("Description" ,    new int(OTodo::Description)      );
-    m_dict.insert("Summary" ,        new int(OTodo::Summary)          );
-    m_dict.insert("Priority" ,       new int(OTodo::Priority)         );
-    m_dict.insert("DateDay" ,        new int(OTodo::DateDay)          );
-    m_dict.insert("DateMonth" ,      new int(OTodo::DateMonth)        );
-    m_dict.insert("DateYear" ,       new int(OTodo::DateYear)         );
-    m_dict.insert("Progress" ,       new int(OTodo::Progress)         );
-    m_dict.insert("Completed",       new int(OTodo::Completed)        ); // Why twice ? (eilers)
-    m_dict.insert("CrossReference",  new int(OTodo::CrossReference)   );
-//    m_dict.insert("HasAlarmDateTime",new int(OTodo::HasAlarmDateTime) ); // old stuff (eilers)
-//    m_dict.insert("AlarmDateTime",   new int(OTodo::AlarmDateTime)    ); // old stuff (eilers)
+    m_dict.insert("Categories" ,     new int(OPimTodo::Category)         );
+    m_dict.insert("Uid" ,            new int(OPimTodo::Uid)              );
+    m_dict.insert("HasDate" ,        new int(OPimTodo::HasDate)          );
+    m_dict.insert("Completed" ,      new int(OPimTodo::Completed)        );
+    m_dict.insert("Description" ,    new int(OPimTodo::Description)      );
+    m_dict.insert("Summary" ,        new int(OPimTodo::Summary)          );
+    m_dict.insert("Priority" ,       new int(OPimTodo::Priority)         );
+    m_dict.insert("DateDay" ,        new int(OPimTodo::DateDay)          );
+    m_dict.insert("DateMonth" ,      new int(OPimTodo::DateMonth)        );
+    m_dict.insert("DateYear" ,       new int(OPimTodo::DateYear)         );
+    m_dict.insert("Progress" ,       new int(OPimTodo::Progress)         );
+    m_dict.insert("Completed",       new int(OPimTodo::Completed)        ); // Why twice ? (eilers)
+    m_dict.insert("CrossReference",  new int(OPimTodo::CrossReference)   );
+//    m_dict.insert("HasAlarmDateTime",new int(OPimTodo::HasAlarmDateTime) ); // old stuff (eilers)
+//    m_dict.insert("AlarmDateTime",   new int(OPimTodo::AlarmDateTime)    ); // old stuff (eilers)
 }
 /*
  * need to be const so let's fool the
  * compiler :(
  */
-void OTodoAccessBackendSQL::update()const {
-    ((OTodoAccessBackendSQL*)this)->m_dirty = false;
+void OPimTodoAccessBackendSQL::update()const {
+    ((OPimTodoAccessBackendSQL*)this)->m_dirty = false;
     LoadQuery lo;
     OSQLResult res = m_driver->query(&lo);
     if ( res.state() != OSQLResult::Success )
         return;
 
-    ((OTodoAccessBackendSQL*)this)->m_uids = uids( res );
+    ((OPimTodoAccessBackendSQL*)this)->m_uids = uids( res );
 }
-QArray<int> OTodoAccessBackendSQL::uids( const OSQLResult& res) const{
+QArray<int> OPimTodoAccessBackendSQL::uids( const OSQLResult& res) const{
 
     OSQLResultItem::ValueList list = res.results();
     OSQLResultItem::ValueList::Iterator it;
     QArray<int> ints(list.count() );
     qWarning(" count = %d", list.count() );
 
     int i = 0;
     for (it = list.begin(); it != list.end(); ++it ) {
         ints[i] =  (*it).data("uid").toInt();
         i++;
     }
     return ints;
 }
 
-QArray<int> OTodoAccessBackendSQL::matchRegexp(  const QRegExp &r ) const
+QArray<int> OPimTodoAccessBackendSQL::matchRegexp(  const QRegExp &r ) const
 {
 
-#warning OTodoAccessBackendSQL::matchRegexp() not implemented !!
+#warning OPimTodoAccessBackendSQL::matchRegexp() not implemented !!
 
 #if 0
 
 	Copied from xml-backend by not adapted to sql (eilers)
 
 	QArray<int> m_currentQuery( m_events.count() );
 	uint arraycounter = 0;
 
 
 
-        QMap<int, OTodo>::ConstIterator it;
+        QMap<int, OPimTodo>::ConstIterator it;
         for (it = m_events.begin(); it != m_events.end(); ++it ) {
 		if ( it.data().match( r ) )
 			m_currentQuery[arraycounter++] = it.data().uid();
 
 	}
 	// Shrink to fit..
 	m_currentQuery.resize(arraycounter);
 
 	return m_currentQuery;
 #endif
 	QArray<int> empty;
 	return empty;
 }
-QBitArray OTodoAccessBackendSQL::supports()const {
+QBitArray OPimTodoAccessBackendSQL::supports()const {
 
 	return sup();
 }
 
-QBitArray OTodoAccessBackendSQL::sup() const{
+QBitArray OPimTodoAccessBackendSQL::sup() const{
 
-	QBitArray ar( OTodo::CompletedDate + 1 );
+	QBitArray ar( OPimTodo::CompletedDate + 1 );
 	ar.fill( true );
-	ar[OTodo::CrossReference] = false;
-	ar[OTodo::State ] = false;
-	ar[OTodo::Reminders] = false;
-	ar[OTodo::Notifiers] = false;
-	ar[OTodo::Maintainer] = false;
+	ar[OPimTodo::CrossReference] = false;
+	ar[OPimTodo::State ] = false;
+	ar[OPimTodo::Reminders] = false;
+	ar[OPimTodo::Notifiers] = false;
+	ar[OPimTodo::Maintainer] = false;
 	
 	return ar;
 }
 
-void OTodoAccessBackendSQL::removeAllCompleted(){
-#warning OTodoAccessBackendSQL::removeAllCompleted() not implemented !!
+void OPimTodoAccessBackendSQL::removeAllCompleted(){
+#warning OPimTodoAccessBackendSQL::removeAllCompleted() not implemented !!
 
 }
 
 }
diff --git a/libopie2/opiepim/backend/otodoaccesssql.h b/libopie2/opiepim/backend/otodoaccesssql.h
index 1a6f614..e945863 100644
--- a/libopie2/opiepim/backend/otodoaccesssql.h
+++ b/libopie2/opiepim/backend/otodoaccesssql.h
@@ -34,52 +34,52 @@
 #include <opie2/otodoaccessbackend.h>
 
 class OSQLDriver;
 class OSQLResult;
 class OSQLResultItem;
 
 namespace Opie {
 
-class OTodoAccessBackendSQL : public OTodoAccessBackend {
+class OPimTodoAccessBackendSQL : public OPimTodoAccessBackend {
 public:
-    OTodoAccessBackendSQL( const QString& file );
-    ~OTodoAccessBackendSQL();
+    OPimTodoAccessBackendSQL( const QString& file );
+    ~OPimTodoAccessBackendSQL();
 
     bool load();
     bool reload();
     bool save();
     QArray<int> allRecords()const;
 
-    QArray<int> queryByExample( const OTodo& t, int settings, const QDateTime& d = QDateTime() );
-    OTodo find(int uid)const;
-    OTodo find(int uid, const QArray<int>&, uint cur, Frontend::CacheDirection )const;
+    QArray<int> queryByExample( const OPimTodo& t, int settings, const QDateTime& d = QDateTime() );
+    OPimTodo find(int uid)const;
+    OPimTodo find(int uid, const QArray<int>&, uint cur, Frontend::CacheDirection )const;
     void clear();
-    bool add( const OTodo& t );
+    bool add( const OPimTodo& t );
     bool remove( int uid );
-    bool replace( const OTodo& t );
+    bool replace( const OPimTodo& t );
 
     QArray<int> overDue();
     QArray<int> effectiveToDos( const QDate& start,
                                 const QDate& end, bool includeNoDates );
     QArray<int> sorted(bool asc, int sortOrder, int sortFilter, int cat );
 
     QBitArray supports()const;
     QArray<int> matchRegexp(  const QRegExp &r ) const;
     void removeAllCompleted();
     
 
 private:
     void update()const;
     void fillDict();
     inline bool date( QDate& date, const QString& )const;
-    inline OTodo todo( const OSQLResult& )const;
-    inline OTodo todo( OSQLResultItem& )const;
+    inline OPimTodo todo( const OSQLResult& )const;
+    inline OPimTodo todo( OSQLResultItem& )const;
     inline QArray<int> uids( const OSQLResult& )const;
-    OTodo todo( int uid )const;
+    OPimTodo todo( int uid )const;
     QBitArray sup() const;
 
     QAsciiDict<int> m_dict;
     OSQLDriver* m_driver;
     QArray<int> m_uids;
     bool m_dirty : 1;
 };
 
diff --git a/libopie2/opiepim/backend/otodoaccessvcal.cpp b/libopie2/opiepim/backend/otodoaccessvcal.cpp
index e364ee2..0a1baf9 100644
--- a/libopie2/opiepim/backend/otodoaccessvcal.cpp
+++ b/libopie2/opiepim/backend/otodoaccessvcal.cpp
@@ -32,18 +32,18 @@
 #include <qtopia/timeconversion.h>
 #include <qtopia/private/qfiledirect_p.h>
 
 #include <opie2/otodoaccessvcal.h>
 
 using namespace Opie;
 
 namespace {
-    static OTodo eventByVObj( VObject *obj ){
-        OTodo event;
+    static OPimTodo eventByVObj( VObject *obj ){
+        OPimTodo event;
         VObject *ob;
         QCString name;
         // no uid, attendees, ... and no fun
         // description
         if( ( ob = isAPropertyOf( obj, VCDescriptionProp )) != 0 ){
             name = vObjectStringZValue( ob );
 #if 0
             event.setDescription( name );
@@ -86,17 +86,17 @@ namespace {
         if((ob = isAPropertyOf( obj, VCCategoriesProp )) != 0 ){
             name = vObjectStringZValue( ob );
             qWarning("Categories:%s", name.data() );
         }
 
         event.setUid( 1 );
         return event;
     };
-    static VObject *vobjByEvent( const OTodo &event )  {
+    static VObject *vobjByEvent( const OPimTodo &event )  {
         VObject *task = newVObject( VCTodoProp );
         if( task == 0 )
             return 0l;
 
         if( event.hasDueDate() ) {
             QTime time(0, 0, 0);
             QDateTime date(event.dueDate(), time );
             addPropValue( task, VCDueProp,
@@ -133,23 +133,23 @@ namespace {
         addPropValue( task, VCSummaryProp,
                       event.description().local8Bit() );
 #endif 
   return task;
 };
 }
 
 namespace Opie {
-OTodoAccessVCal::OTodoAccessVCal( const QString& path )
+OPimTodoAccessVCal::OPimTodoAccessVCal( const QString& path )
     : m_dirty(false), m_file( path )
 {
 }
-OTodoAccessVCal::~OTodoAccessVCal() {
+OPimTodoAccessVCal::~OPimTodoAccessVCal() {
 }
-bool OTodoAccessVCal::load() {
+bool OPimTodoAccessVCal::load() {
     m_map.clear();
     m_dirty = false;
 
     VObject* vcal = 0l;
     vcal = Parse_MIME_FromFileName( QFile::encodeName(m_file).data() );
     if (!vcal )
         return false;
 
@@ -158,125 +158,125 @@ bool OTodoAccessVCal::load() {
     VObject* vobj;
 
     initPropIterator(&it, vcal);
 
     while( moreIteration( &it ) ) {
         vobj = ::nextVObject( &it );
         QCString name = ::vObjectName( vobj );
         if( name == VCTodoProp ){
-            OTodo to = eventByVObj( vobj );
+            OPimTodo to = eventByVObj( vobj );
             m_map.insert( to.uid(), to );
         }
     }
 
     // Should I do a delete vcal?
 
     return true;
 }
-bool OTodoAccessVCal::reload() {
+bool OPimTodoAccessVCal::reload() {
     return load();
 }
-bool OTodoAccessVCal::save() {
+bool OPimTodoAccessVCal::save() {
     if (!m_dirty )
         return true;
 
     QFileDirect file( m_file );
     if (!file.open(IO_WriteOnly ) )
         return false;
 
     VObject *obj;
     obj = newVObject( VCCalProp );
     addPropValue( obj, VCVersionProp, "1.0" );
     VObject *vo;
-    for(QMap<int, OTodo>::ConstIterator it=m_map.begin(); it !=m_map.end(); ++it ){
+    for(QMap<int, OPimTodo>::ConstIterator it=m_map.begin(); it !=m_map.end(); ++it ){
         vo = vobjByEvent( it.data() );
         addVObjectProp(obj, vo );
     }
     writeVObject( file.directHandle(), obj );
     cleanVObject( obj );
     cleanStrTbl();
 
     m_dirty = false;
     return true;
 }
-void OTodoAccessVCal::clear() {
+void OPimTodoAccessVCal::clear() {
     m_map.clear();
     m_dirty = true;
 }
-bool OTodoAccessVCal::add( const OTodo& to ) {
+bool OPimTodoAccessVCal::add( const OPimTodo& to ) {
     m_map.insert( to.uid(), to );
     m_dirty = true;
     return true;
 }
-bool OTodoAccessVCal::remove( int uid ) {
+bool OPimTodoAccessVCal::remove( int uid ) {
     m_map.remove( uid );
     m_dirty = true;
     return true;
 }
-void OTodoAccessVCal::removeAllCompleted() {
-    for ( QMap<int, OTodo>::Iterator it = m_map.begin(); it != m_map.end(); ++it ) {
+void OPimTodoAccessVCal::removeAllCompleted() {
+    for ( QMap<int, OPimTodo>::Iterator it = m_map.begin(); it != m_map.end(); ++it ) {
         if ( (*it).isCompleted() )
             m_map.remove( it );
     }
 }
-bool OTodoAccessVCal::replace( const OTodo& to ) {
+bool OPimTodoAccessVCal::replace( const OPimTodo& to ) {
     m_map.replace( to.uid(), to );
     m_dirty = true;
     return true;
 }
-OTodo OTodoAccessVCal::find(int uid )const {
+OPimTodo OPimTodoAccessVCal::find(int uid )const {
     return m_map[uid];
 }
-QArray<int> OTodoAccessVCal::sorted( bool, int, int, int ) {
+QArray<int> OPimTodoAccessVCal::sorted( bool, int, int, int ) {
     QArray<int> ar(0);
     return ar;
 }
-QArray<int> OTodoAccessVCal::allRecords()const {
+QArray<int> OPimTodoAccessVCal::allRecords()const {
     QArray<int> ar( m_map.count() );
-    QMap<int, OTodo>::ConstIterator it;
+    QMap<int, OPimTodo>::ConstIterator it;
     int i = 0;
     for ( it = m_map.begin(); it != m_map.end(); ++it ) {
         ar[i] = it.key();
         i++;
     }
     return ar;
 }
-QArray<int> OTodoAccessVCal::matchRegexp(const QRegExp& /* r */)const {
+QArray<int> OPimTodoAccessVCal::matchRegexp(const QRegExp& /* r */)const {
     QArray<int> ar(0);
     return ar;
 }
-QArray<int> OTodoAccessVCal::queryByExample( const OTodo&, int, const QDateTime& ) {
+QArray<int> OPimTodoAccessVCal::queryByExample( const OPimTodo&, int, const QDateTime& ) {
     QArray<int> ar(0);
     return ar;
 }
-QArray<int> OTodoAccessVCal::effectiveToDos( const QDate& ,
+QArray<int> OPimTodoAccessVCal::effectiveToDos( const QDate& ,
                                              const QDate& ,
                                              bool  ) {
     QArray<int> ar(0);
     return ar;
 }
-QArray<int> OTodoAccessVCal::overDue() {
+QArray<int> OPimTodoAccessVCal::overDue() {
     QArray<int> ar(0);
     return ar;
 }
-QBitArray OTodoAccessVCal::supports()const {
+QBitArray OPimTodoAccessVCal::supports()const {
     static QBitArray ar = sup();
 
     return ar;
 }
-QBitArray OTodoAccessVCal::sup() {
-    QBitArray ar ( OTodo::CompletedDate +1 );
+QBitArray OPimTodoAccessVCal::sup() {
+    QBitArray ar ( OPimTodo::CompletedDate +1 );
     ar.fill( true );
 
-    ar[OTodo::CrossReference] = false;
-    ar[OTodo::State ] = false;
-    ar[OTodo::Reminders] = false;
-    ar[OTodo::Notifiers] = false;
-    ar[OTodo::Maintainer] = false;
-    ar[OTodo::Progress] = false;
-    ar[OTodo::Alarms ] = false;
-    ar[OTodo::Recurrence] = false;
+    ar[OPimTodo::CrossReference] = false;
+    ar[OPimTodo::State ] = false;
+    ar[OPimTodo::Reminders] = false;
+    ar[OPimTodo::Notifiers] = false;
+    ar[OPimTodo::Maintainer] = false;
+    ar[OPimTodo::Progress] = false;
+    ar[OPimTodo::Alarms ] = false;
+    ar[OPimTodo::Recurrence] = false;
 
     return ar;
 }
 
 }
diff --git a/libopie2/opiepim/backend/otodoaccessvcal.h b/libopie2/opiepim/backend/otodoaccessvcal.h
index f9323fb..1e106d3 100644
--- a/libopie2/opiepim/backend/otodoaccessvcal.h
+++ b/libopie2/opiepim/backend/otodoaccessvcal.h
@@ -28,45 +28,45 @@
 */
 #ifndef OPIE_OTODO_ACCESS_VCAL_H
 #define OPIE_OTODO_ACCESS_VCAL_H
 
 #include <opie2/otodoaccessbackend.h>
 
 namespace Opie {
 
-class OTodoAccessVCal : public OTodoAccessBackend {
+class OPimTodoAccessVCal : public OPimTodoAccessBackend {
 public:
-    OTodoAccessVCal(const QString& );
-    ~OTodoAccessVCal();
+    OPimTodoAccessVCal(const QString& );
+    ~OPimTodoAccessVCal();
 
     bool load();
     bool reload();
     bool save();
 
     QArray<int> allRecords()const;
     QArray<int> matchRegexp(const QRegExp &r) const;
-    QArray<int> queryByExample( const OTodo& t, int sort, const QDateTime& d = QDateTime() );
+    QArray<int> queryByExample( const OPimTodo& t, int sort, const QDateTime& d = QDateTime() );
     QArray<int> effectiveToDos( const QDate& start,
                                 const QDate& end,
                                 bool includeNoDates );
     QArray<int> overDue();
     QArray<int> sorted( bool asc, int sortOrder, int sortFilter,
                         int cat );
-    OTodo find(int uid)const;
+    OPimTodo find(int uid)const;
     void clear();
-    bool add( const OTodo& );
+    bool add( const OPimTodo& );
     bool remove( int uid );
-    bool replace( const OTodo& );
+    bool replace( const OPimTodo& );
 
     void removeAllCompleted();
     virtual QBitArray supports()const;
 
 private:
     static QBitArray sup();
     bool m_dirty : 1;
     QString m_file;
-    QMap<int, OTodo> m_map;
+    QMap<int, OPimTodo> m_map;
 };
 
 }
 
 #endif
diff --git a/libopie2/opiepim/backend/otodoaccessxml.cpp b/libopie2/opiepim/backend/otodoaccessxml.cpp
index 2d50ecd..cce6111 100644
--- a/libopie2/opiepim/backend/otodoaccessxml.cpp
+++ b/libopie2/opiepim/backend/otodoaccessxml.cpp
@@ -38,35 +38,35 @@
 
 #include <qfile.h>
 #include <qvector.h>
 
 #include <qpe/global.h>
 #include <qpe/stringutil.h>
 #include <qpe/timeconversion.h>
 
-#include <opie2/oconversion.h>
+#include <opie2/opimdateconversion.h>
 #include <opie2/opimstate.h>
-#include <opie2/otimezone.h>
+#include <opie2/opimtimezone.h>
 #include <opie2/opimnotifymanager.h>
-#include <opie2/orecur.h>
+#include <opie2/opimrecurrence.h>
 #include <opie2/otodoaccessxml.h>
 
 using namespace Opie;
 
 namespace {
     time_t rp_end;
-    ORecur* rec;
-    ORecur *recur() {
-        if (!rec ) rec = new ORecur;
+    OPimRecurrence* rec;
+    OPimRecurrence *recur() {
+        if (!rec ) rec = new OPimRecurrence;
         return rec;
     }
     int snd;
     enum MoreAttributes {
-        FRType = OTodo::CompletedDate + 2,
+        FRType = OPimTodo::CompletedDate + 2,
         FRWeekdays,
         FRPosition,
         FRFreq,
         FRHasEndDate,
         FREndDate,
         FRStart,
         FREnd
     };
@@ -93,57 +93,57 @@ char *strstrlen(const char *haystack, int hLen, const char* needle, int nLen)
 	hsearch--;
     }
     return ((char *)hsearch);
 }
 }
 
 namespace Opie {
 
-OTodoAccessXML::OTodoAccessXML( const QString& appName,
+OPimTodoAccessXML::OPimTodoAccessXML( const QString& appName,
                                 const QString& fileName )
-    : OTodoAccessBackend(), m_app( appName ),  m_opened( false ), m_changed( false )
+    : OPimTodoAccessBackend(), m_app( appName ),  m_opened( false ), m_changed( false )
 {
     if (!fileName.isEmpty() )
         m_file = fileName;
     else
         m_file = Global::applicationFileName( "todolist", "todolist.xml" );
 }
-OTodoAccessXML::~OTodoAccessXML() {
+OPimTodoAccessXML::~OPimTodoAccessXML() {
 
 }
-bool OTodoAccessXML::load() {
+bool OPimTodoAccessXML::load() {
     rec = 0;
     m_opened = true;
     m_changed = false;
     /* initialize dict */
     /*
      * UPDATE dict if you change anything!!!
      */
     QAsciiDict<int> dict(26);
     dict.setAutoDelete( TRUE );
-    dict.insert("Categories" ,     new int(OTodo::Category)         );
-    dict.insert("Uid" ,            new int(OTodo::Uid)              );
-    dict.insert("HasDate" ,        new int(OTodo::HasDate)          );
-    dict.insert("Completed" ,      new int(OTodo::Completed)        );
-    dict.insert("Description" ,    new int(OTodo::Description)      );
-    dict.insert("Summary" ,        new int(OTodo::Summary)          );
-    dict.insert("Priority" ,       new int(OTodo::Priority)         );
-    dict.insert("DateDay" ,        new int(OTodo::DateDay)          );
-    dict.insert("DateMonth" ,      new int(OTodo::DateMonth)        );
-    dict.insert("DateYear" ,       new int(OTodo::DateYear)         );
-    dict.insert("Progress" ,       new int(OTodo::Progress)         );
-    dict.insert("CompletedDate",   new int(OTodo::CompletedDate)    );
-    dict.insert("StartDate",       new int(OTodo::StartDate)        );
-    dict.insert("CrossReference",  new int(OTodo::CrossReference)   );
-    dict.insert("State",           new int(OTodo::State)            );
-    dict.insert("Alarms",          new int(OTodo::Alarms)           );
-    dict.insert("Reminders",       new int(OTodo::Reminders)        );
-    dict.insert("Notifiers",       new int(OTodo::Notifiers)        );
-    dict.insert("Maintainer",      new int(OTodo::Maintainer)       );
+    dict.insert("Categories" ,     new int(OPimTodo::Category)         );
+    dict.insert("Uid" ,            new int(OPimTodo::Uid)              );
+    dict.insert("HasDate" ,        new int(OPimTodo::HasDate)          );
+    dict.insert("Completed" ,      new int(OPimTodo::Completed)        );
+    dict.insert("Description" ,    new int(OPimTodo::Description)      );
+    dict.insert("Summary" ,        new int(OPimTodo::Summary)          );
+    dict.insert("Priority" ,       new int(OPimTodo::Priority)         );
+    dict.insert("DateDay" ,        new int(OPimTodo::DateDay)          );
+    dict.insert("DateMonth" ,      new int(OPimTodo::DateMonth)        );
+    dict.insert("DateYear" ,       new int(OPimTodo::DateYear)         );
+    dict.insert("Progress" ,       new int(OPimTodo::Progress)         );
+    dict.insert("CompletedDate",   new int(OPimTodo::CompletedDate)    );
+    dict.insert("StartDate",       new int(OPimTodo::StartDate)        );
+    dict.insert("CrossReference",  new int(OPimTodo::CrossReference)   );
+    dict.insert("State",           new int(OPimTodo::State)            );
+    dict.insert("Alarms",          new int(OPimTodo::Alarms)           );
+    dict.insert("Reminders",       new int(OPimTodo::Reminders)        );
+    dict.insert("Notifiers",       new int(OPimTodo::Notifiers)        );
+    dict.insert("Maintainer",      new int(OPimTodo::Maintainer)       );
     dict.insert("rtype",           new int(FRType)                  );
     dict.insert("rweekdays",       new int(FRWeekdays)              );
     dict.insert("rposition",       new int(FRPosition)              );
     dict.insert("rfreq",           new int(FRFreq)                  );
     dict.insert("start",           new int(FRStart)                 );
     dict.insert("rhasenddate",     new int(FRHasEndDate)            );
     dict.insert("enddt",           new int(FREndDate)               );
 
@@ -174,17 +174,17 @@ bool OTodoAccessXML::load() {
     char *point;
     const char* collectionString = "<Task ";
     int strLen = strlen(collectionString);
     while ( ( point = strstrlen( dt+i, len -i, collectionString, strLen ) ) != 0l ) {
         i = point -dt;
         i+= strLen;
         qWarning("Found a start at %d %d", i,  (point-dt) );
 
-        OTodo ev;
+        OPimTodo ev;
         m_year = m_month = m_day = 0;
 
         while ( TRUE ) {
             while ( i < len && (dt[i] == ' ' || dt[i] == '\n' || dt[i] == '\r') )
 		++i;
 	    if ( i >= len-2 || (dt[i] == '/' && dt[i+1] == '>') )
 		break;
 
@@ -237,54 +237,54 @@ bool OTodoAccessXML::load() {
         if (m_events.contains( ev.uid() ) || ev.uid() == 0) {
             ev.setUid( 1 );
             m_changed = true;
         }
         if ( ev.hasDueDate() ) {
             ev.setDueDate( QDate(m_year, m_month, m_day) );
         }
         if ( rec && rec->doesRecur() ) {
-            OTimeZone utc = OTimeZone::utc();
-            ORecur recu( *rec ); // call copy c'tor
+            OPimTimeZone utc = OPimTimeZone::utc();
+            OPimRecurrence recu( *rec ); // call copy c'tor
             recu.setEndDate( utc.fromUTCDateTime( rp_end ).date() );
             recu.setStart( ev.dueDate() );
             ev.setRecurrence( recu );
         }
         m_events.insert(ev.uid(), ev );
         m_year = m_month = m_day = -1;
         delete rec;
         rec = 0;
     }
 
     munmap(map_addr, attribut.st_size );
 
     qWarning("counts %d records loaded!", m_events.count() );
     return true;
 }
-bool OTodoAccessXML::reload() {
+bool OPimTodoAccessXML::reload() {
     m_events.clear();
     return load();
 }
-bool OTodoAccessXML::save() {
+bool OPimTodoAccessXML::save() {
 //    qWarning("saving");
     if (!m_opened || !m_changed ) {
 //        qWarning("not saving");
         return true;
     }
     QString strNewFile = m_file + ".new";
     QFile f( strNewFile );
     if (!f.open( IO_WriteOnly|IO_Raw ) )
         return false;
 
     int written;
     QString out;
     out = "<!DOCTYPE Tasks>\n<Tasks>\n";
 
     // for all todos
-    QMap<int, OTodo>::Iterator it;
+    QMap<int, OPimTodo>::Iterator it;
     for (it = m_events.begin(); it != m_events.end(); ++it ) {
         out+= "<Task " + toString( (*it) ) + " />\n";
         QCString cstr = out.utf8();
         written = f.writeBlock( cstr.data(),  cstr.length() );
 
         /* less written then we wanted */
         if ( written != (int)cstr.length() ) {
             f.close();
@@ -309,70 +309,70 @@ bool OTodoAccessXML::save() {
     if( ::rename( strNewFile.latin1(),  m_file.latin1() ) < 0 ) {
 //        qWarning("error renaming");
         QFile::remove( strNewFile );
     }
 
     m_changed = false;
     return true;
 }
-QArray<int> OTodoAccessXML::allRecords()const {
+QArray<int> OPimTodoAccessXML::allRecords()const {
     QArray<int> ids( m_events.count() );
-    QMap<int, OTodo>::ConstIterator it;
+    QMap<int, OPimTodo>::ConstIterator it;
     int i = 0;
 
     for ( it = m_events.begin(); it != m_events.end(); ++it ) {
         ids[i] = it.key();
         i++;
     }
     return ids;
 }
-QArray<int> OTodoAccessXML::queryByExample( const OTodo&, int, const QDateTime& ) {
+QArray<int> OPimTodoAccessXML::queryByExample( const OPimTodo&, int, const QDateTime& ) {
     QArray<int> ids(0);
     return ids;
 }
-OTodo OTodoAccessXML::find( int uid )const {
-    OTodo todo;
+OPimTodo OPimTodoAccessXML::find( int uid )const {
+    OPimTodo todo;
     todo.setUid( 0 ); // isEmpty()
-    QMap<int, OTodo>::ConstIterator it = m_events.find( uid );
+    QMap<int, OPimTodo>::ConstIterator it = m_events.find( uid );
     if ( it != m_events.end() )
         todo = it.data();
 
     return todo;
 }
-void OTodoAccessXML::clear() {
+void OPimTodoAccessXML::clear() {
     if (m_opened )
         m_changed = true;
 
     m_events.clear();
 }
-bool OTodoAccessXML::add( const OTodo& todo ) {
+bool OPimTodoAccessXML::add( const OPimTodo& todo ) {
 //    qWarning("add");
     m_changed = true;
     m_events.insert( todo.uid(), todo );
 
     return true;
 }
-bool OTodoAccessXML::remove( int uid ) {
+bool OPimTodoAccessXML::remove( int uid ) {
     m_changed = true;
     m_events.remove( uid );
 
     return true;
 }
-bool OTodoAccessXML::replace( const OTodo& todo) {
+bool OPimTodoAccessXML::replace( const OPimTodo& todo) {
     m_changed = true;
     m_events.replace( todo.uid(), todo );
 
     return true;
 }
-QArray<int> OTodoAccessXML::effectiveToDos( const QDate& start,
+QArray<int> OPimTodoAccessXML::effectiveToDos( const QDate& start,
                                             const QDate& end,
                                             bool includeNoDates ) {
     QArray<int> ids( m_events.count() );
-    QMap<int, OTodo>::Iterator it;
+    QMap<int, OPimTodo>::Iterator it;
 
     int i = 0;
     for ( it = m_events.begin(); it != m_events.end(); ++it ) {
         if ( !it.data().hasDueDate() ) {
             if ( includeNoDates ) {
                 ids[i] = it.key();
                 i++;
             }
@@ -380,111 +380,111 @@ QArray<int> OTodoAccessXML::effectiveToDos( const QDate& start,
                    it.data().dueDate() <= end ) {
             ids[i] = it.key();
             i++;
         }
     }
     ids.resize( i );
     return ids;
 }
-QArray<int> OTodoAccessXML::overDue() {
+QArray<int> OPimTodoAccessXML::overDue() {
     QArray<int> ids( m_events.count() );
     int i = 0;
 
-    QMap<int, OTodo>::Iterator it;
+    QMap<int, OPimTodo>::Iterator it;
     for ( it = m_events.begin(); it != m_events.end(); ++it ) {
         if ( it.data().isOverdue() ) {
             ids[i] = it.key();
             i++;
         }
     }
     ids.resize( i );
     return ids;
 }
 
 
 /* private */
-void OTodoAccessXML::todo( QAsciiDict<int>* dict, OTodo& ev,
+void OPimTodoAccessXML::todo( QAsciiDict<int>* dict, OPimTodo& ev,
                             const QCString& attr, const QString& val) {
 //    qWarning("parse to do from XMLElement" );
 
     int *find=0;
 
     find = (*dict)[ attr.data() ];
     if (!find ) {
 //            qWarning("Unknown option" + it.key() );
         ev.setCustomField( attr, val );
         return;
     }
 
     switch( *find ) {
-    case OTodo::Uid:
+    case OPimTodo::Uid:
         ev.setUid( val.toInt() );
         break;
-    case OTodo::Category:
+    case OPimTodo::Category:
         ev.setCategories( ev.idsFromString( val ) );
         break;
-    case OTodo::HasDate:
+    case OPimTodo::HasDate:
         ev.setHasDueDate( val.toInt() );
         break;
-    case OTodo::Completed:
+    case OPimTodo::Completed:
         ev.setCompleted( val.toInt() );
         break;
-    case OTodo::Description:
+    case OPimTodo::Description:
         ev.setDescription( val );
         break;
-    case OTodo::Summary:
+    case OPimTodo::Summary:
         ev.setSummary( val );
         break;
-    case OTodo::Priority:
+    case OPimTodo::Priority:
         ev.setPriority( val.toInt() );
         break;
-    case OTodo::DateDay:
+    case OPimTodo::DateDay:
         m_day = val.toInt();
         break;
-    case OTodo::DateMonth:
+    case OPimTodo::DateMonth:
         m_month = val.toInt();
         break;
-    case OTodo::DateYear:
+    case OPimTodo::DateYear:
         m_year = val.toInt();
         break;
-    case OTodo::Progress:
+    case OPimTodo::Progress:
         ev.setProgress( val.toInt() );
         break;
-    case OTodo::CompletedDate:
-        ev.setCompletedDate( OConversion::dateFromString( val ) );
+    case OPimTodo::CompletedDate:
+        ev.setCompletedDate( OPimDateConversion::dateFromString( val ) );
         break;
-    case OTodo::StartDate:
-        ev.setStartDate( OConversion::dateFromString( val ) );
+    case OPimTodo::StartDate:
+        ev.setStartDate( OPimDateConversion::dateFromString( val ) );
         break;
-    case OTodo::State:
+    case OPimTodo::State:
         ev.setState( val.toInt() );
         break;
-    case OTodo::Alarms:{
+    case OPimTodo::Alarms:{
         OPimNotifyManager &manager = ev.notifiers();
         QStringList als = QStringList::split(";", val );
         for (QStringList::Iterator it = als.begin(); it != als.end(); ++it ) {
             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] ), alarm[1].toInt() );
+            qWarning("alarm[0]: %s %s", alarm[0].latin1(), OPimDateConversion::dateTimeFromString( alarm[0] ).toString().latin1() );
+            OPimAlarm al( alarm[2].toInt(), OPimDateConversion::dateTimeFromString( alarm[0] ), alarm[1].toInt() );
             manager.add( al );
         }
     }
         break;
-    case OTodo::Reminders:{
+    case OPimTodo::Reminders:{
         OPimNotifyManager &manager = ev.notifiers();
         QStringList rems = QStringList::split(";", val );
         for (QStringList::Iterator it = rems.begin(); it != rems.end(); ++it ) {
             OPimReminder rem( (*it).toInt() );
             manager.add( rem );
         }
     }
         break;
-    case OTodo::CrossReference:
+    case OPimTodo::CrossReference:
     {
         /*
          * A cross refernce looks like
          * appname,id;appname,id
          * we need to split it up
          */
         QStringList  refs = QStringList::split(';', val );
         QStringList::Iterator strIt;
@@ -494,27 +494,27 @@ void OTodoAccessXML::todo( QAsciiDict<int>* dict, OTodo& ev,
                 ; // ev.addRelation( (*strIt).left(pos),  (*strIt).mid(pos+1).toInt() );
 
         }
         break;
     }
     /* Recurrence stuff below + post processing later */
     case FRType:
         if ( val == "Daily" )
-            recur()->setType( ORecur::Daily );
+            recur()->setType( OPimRecurrence::Daily );
         else if ( val == "Weekly" )
-            recur()->setType( ORecur::Weekly);
+            recur()->setType( OPimRecurrence::Weekly);
         else if ( val == "MonthlyDay" )
-            recur()->setType( ORecur::MonthlyDay );
+            recur()->setType( OPimRecurrence::MonthlyDay );
         else if ( val == "MonthlyDate" )
-            recur()->setType( ORecur::MonthlyDate );
+            recur()->setType( OPimRecurrence::MonthlyDate );
         else if ( val == "Yearly" )
-            recur()->setType( ORecur::Yearly );
+            recur()->setType( OPimRecurrence::Yearly );
         else
-            recur()->setType( ORecur::NoRepeat );
+            recur()->setType( OPimRecurrence::NoRepeat );
         break;
     case FRWeekdays:
         recur()->setDays( val.toInt() );
         break;
     case FRPosition:
         recur()->setPosition( val.toInt() );
         break;
     case FRFreq:
@@ -548,17 +548,17 @@ QString customToXml(const QMap<QString, QString>& customMap )
 	buf += "\" ";
     }
     return buf;
 }
 
 
 }
 
-QString OTodoAccessXML::toString( const OTodo& ev )const {
+QString OPimTodoAccessXML::toString( const OPimTodo& ev )const {
     QString str;
 
     str += "Completed=\"" + QString::number( ev.isCompleted() ) + "\" ";
     str += "HasDate=\"" + QString::number( ev.hasDueDate() ) + "\" ";
     str += "Priority=\"" + QString::number( ev.priority() ) + "\" ";
     str += "Progress=\"" + QString::number(ev.progress() ) + "\" ";
 
     str += "Categories=\"" + toString( ev.categories() ) + "\" ";
@@ -586,96 +586,96 @@ QString OTodoAccessXML::toString( const OTodo& ev )const {
     for (extIt = extras.begin(); extIt != extras.end(); ++extIt )
         str += extIt.key() + "=\"" +  extIt.data() + "\" ";
     */
     // cross refernce
     if ( ev.hasRecurrence() ) {
         str += ev.recurrence().toString();
     }
     if ( ev.hasStartDate() )
-        str += "StartDate=\""+ OConversion::dateToString( ev.startDate() ) +"\" ";
+        str += "StartDate=\""+ OPimDateConversion::dateToString( ev.startDate() ) +"\" ";
     if ( ev.hasCompletedDate() )
-        str += "CompletedDate=\""+ OConversion::dateToString( ev.completedDate() ) +"\" ";
+        str += "CompletedDate=\""+ OPimDateConversion::dateToString( ev.completedDate() ) +"\" ";
     if ( ev.hasState() )
         str += "State=\""+QString::number( ev.state().state() )+"\" ";
 
     /*
      * save reminders and notifiers!
      * DATE_TIME:DURATION:SOUND:NOT_USED_YET;OTHER_DATE_TIME:OTHER_DURATION:SOUND:....
      */
     if ( ev.hasNotifiers() ) {
         OPimNotifyManager manager = ev.notifiers();
         OPimNotifyManager::Alarms alarms = manager.alarms();
         if (!alarms.isEmpty() ) {
             QStringList als;
             OPimNotifyManager::Alarms::Iterator it = alarms.begin();
             for ( ; it != alarms.end(); ++it ) {
                 /* only if time is valid */
                 if ( (*it).dateTime().isValid() ) {
-                    als << OConversion::dateTimeToString( (*it).dateTime() )
+                    als << OPimDateConversion::dateTimeToString( (*it).dateTime() )
                         + ":" + QString::number( (*it).duration() )
                         + ":" + QString::number( (*it).sound() )
                         + ":";
                 }
             }
             // now write the list
             qWarning("als: %s", als.join("____________").latin1() );
             str += "Alarms=\""+als.join(";") +"\" ";
         }
 
         /*
-         * now the same for reminders but more easy. We just save the uid of the OEvent.
+         * now the same for reminders but more easy. We just save the uid of the OPimEvent.
          */
         OPimNotifyManager::Reminders reminders = manager.reminders();
         if (!reminders.isEmpty() ) {
             OPimNotifyManager::Reminders::Iterator it = reminders.begin();
             QStringList records;
             for ( ; it != reminders.end(); ++it ) {
                 records << QString::number( (*it).recordUid() );
             }
             str += "Reminders=\""+ records.join(";") +"\" ";
         }
     }
     str += customToXml( ev.toExtraMap() );
 
 
     return str;
 }
-QString OTodoAccessXML::toString( const QArray<int>& ints ) const {
+QString OPimTodoAccessXML::toString( const QArray<int>& ints ) const {
     return Qtopia::Record::idsToString( ints );
 }
 
 /* internal class for sorting
  *
  * Inspired by todoxmlio.cpp from TT
  */
 
-struct OTodoXMLContainer {
-    OTodo todo;
+struct OPimTodoXMLContainer {
+    OPimTodo todo;
 };
 
 namespace {
-    inline QString string( const OTodo& todo) {
+    inline QString string( const OPimTodo& todo) {
         return  todo.summary().isEmpty() ?
             todo.description().left(20 ) :
             todo.summary();
     }
-    inline int completed( const OTodo& todo1, const OTodo& todo2) {
+    inline int completed( const OPimTodo& todo1, const OPimTodo& todo2) {
         int ret = 0;
         if ( todo1.isCompleted() ) ret++;
         if ( todo2.isCompleted() ) ret--;
         return ret;
     }
-    inline int priority( const OTodo& t1, const OTodo& t2) {
+    inline int priority( const OPimTodo& t1, const OPimTodo& t2) {
         return ( t1.priority() - t2.priority() );
     }
-    inline int description( const OTodo& t1, const OTodo& t2) {
+    inline int description( const OPimTodo& t1, const OPimTodo& t2) {
         return QString::compare( string(t1), string(t2) );
     }
-    inline int deadline( const OTodo& t1, const OTodo& t2) {
+    inline int deadline( const OPimTodo& t1, const OPimTodo& t2) {
         int ret = 0;
         if ( t1.hasDueDate() &&
              t2.hasDueDate() )
             ret = t2.dueDate().daysTo( t1.dueDate() );
         else if ( t1.hasDueDate() )
             ret = -1;
         else if ( t2.hasDueDate() )
             ret = 1;
@@ -698,41 +698,41 @@ namespace {
    *
    *   0 if item1 == item2
    *
    *   > 0 (positive integer) if item1 > item2
    *
    *   < 0 (negative integer) if item1 < item2
    *
    */
-class OTodoXMLVector : public QVector<OTodoXMLContainer> {
+class OPimTodoXMLVector : public QVector<OPimTodoXMLContainer> {
 public:
-    OTodoXMLVector(int size, bool asc,  int sort)
-        : QVector<OTodoXMLContainer>( size )
+    OPimTodoXMLVector(int size, bool asc,  int sort)
+        : QVector<OPimTodoXMLContainer>( size )
         {
             setAutoDelete( true );
             m_asc = asc;
             m_sort = sort;
         }
         /* return the summary/description */
-    QString string( const OTodo& todo) {
+    QString string( const OPimTodo& todo) {
         return  todo.summary().isEmpty() ?
             todo.description().left(20 ) :
             todo.summary();
     }
     /**
      * we take the sortorder( switch on it )
      *
      */
     int compareItems( Item d1, Item d2 ) {
         bool seComp, sePrio, seDesc, seDeadline;
         seComp = sePrio = seDeadline = seDesc = false;
         int ret =0;
-        OTodoXMLContainer* con1 = (OTodoXMLContainer*)d1;
-        OTodoXMLContainer* con2 = (OTodoXMLContainer*)d2;
+        OPimTodoXMLContainer* con1 = (OPimTodoXMLContainer*)d1;
+        OPimTodoXMLContainer* con2 = (OPimTodoXMLContainer*)d2;
 
         /* same item */
         if ( con1->todo.uid() == con2->todo.uid() )
             return 0;
 
         switch ( m_sort ) {
             /* completed */
         case 0: {
@@ -811,20 +811,20 @@ public:
         return 0;
     }
  private:
     bool m_asc;
     int m_sort;
 
 };
 
-QArray<int> OTodoAccessXML::sorted( bool asc,  int sortOrder,
+QArray<int> OPimTodoAccessXML::sorted( bool asc,  int sortOrder,
                                     int sortFilter,  int cat ) {
-    OTodoXMLVector vector(m_events.count(), asc,sortOrder );
-    QMap<int, OTodo>::Iterator it;
+    OPimTodoXMLVector vector(m_events.count(), asc,sortOrder );
+    QMap<int, OPimTodo>::Iterator it;
     int item = 0;
 
     bool bCat = sortFilter & 1 ? true : false;
     bool bOnly = sortFilter & 2 ? true : false;
     bool comp = sortFilter & 4 ? true : false;
     for ( it = m_events.begin(); it != m_events.end(); ++it ) {
 
         /* show category */
@@ -846,60 +846,60 @@ QArray<int> OTodoAccessXML::sorted( bool asc,  int sortOrder,
             continue;
         }
 
         if ((*it).isCompleted() && comp ) {
             continue;
         }
 
 
-        OTodoXMLContainer* con = new OTodoXMLContainer();
+        OPimTodoXMLContainer* con = new OPimTodoXMLContainer();
         con->todo = (*it);
         vector.insert(item, con );
         item++;
     }
     vector.resize( item );
     /* sort it now */
     vector.sort();
     /* now get the uids */
     QArray<int> array( vector.count() );
     for (uint i= 0; i < vector.count(); i++ ) {
         array[i] = ( vector.at(i) )->todo.uid();
     }
     return array;
 };
-void OTodoAccessXML::removeAllCompleted() {
-    QMap<int, OTodo> events = m_events;
-    for ( QMap<int, OTodo>::Iterator it = m_events.begin(); it != m_events.end(); ++it ) {
+void OPimTodoAccessXML::removeAllCompleted() {
+    QMap<int, OPimTodo> events = m_events;
+    for ( QMap<int, OPimTodo>::Iterator it = m_events.begin(); it != m_events.end(); ++it ) {
         if ( (*it).isCompleted() )
             events.remove( it.key() );
     }
     m_events = events;
 }
-QBitArray OTodoAccessXML::supports()const {
+QBitArray OPimTodoAccessXML::supports()const {
     static QBitArray ar = sup();
     return ar;
 }
-QBitArray OTodoAccessXML::sup() {
-    QBitArray ar( OTodo::CompletedDate +1 );
+QBitArray OPimTodoAccessXML::sup() {
+    QBitArray ar( OPimTodo::CompletedDate +1 );
     ar.fill( true );
-    ar[OTodo::CrossReference] = false;
-    ar[OTodo::State ] = false;
-    ar[OTodo::Reminders] = false;
-    ar[OTodo::Notifiers] = false;
-    ar[OTodo::Maintainer] = false;
+    ar[OPimTodo::CrossReference] = false;
+    ar[OPimTodo::State ] = false;
+    ar[OPimTodo::Reminders] = false;
+    ar[OPimTodo::Notifiers] = false;
+    ar[OPimTodo::Maintainer] = false;
 
     return ar;
 }
-QArray<int> OTodoAccessXML::matchRegexp(  const QRegExp &r ) const
+QArray<int> OPimTodoAccessXML::matchRegexp(  const QRegExp &r ) const
 {
 	QArray<int> m_currentQuery( m_events.count() );
 	uint arraycounter = 0;
 
-        QMap<int, OTodo>::ConstIterator it;
+        QMap<int, OPimTodo>::ConstIterator it;
         for (it = m_events.begin(); it != m_events.end(); ++it ) {
 		if ( it.data().match( r ) )
 			m_currentQuery[arraycounter++] = it.data().uid();
 
 	}
 	// Shrink to fit..
 	m_currentQuery.resize(arraycounter);
 
diff --git a/libopie2/opiepim/backend/otodoaccessxml.h b/libopie2/opiepim/backend/otodoaccessxml.h
index d634398..3a51543 100644
--- a/libopie2/opiepim/backend/otodoaccessxml.h
+++ b/libopie2/opiepim/backend/otodoaccessxml.h
@@ -32,58 +32,58 @@
 #include <qasciidict.h>
 #include <qmap.h>
 
 #include <opie2/otodoaccessbackend.h>
 
 namespace Opie {
     class XMLElement;
 
-class OTodoAccessXML : public OTodoAccessBackend {
+class OPimTodoAccessXML : public OPimTodoAccessBackend {
 public:
     /**
      * fileName if Empty we will use the default path
      */
-    OTodoAccessXML( const QString& appName,
+    OPimTodoAccessXML( const QString& appName,
                     const QString& fileName = QString::null );
-    ~OTodoAccessXML();
+    ~OPimTodoAccessXML();
 
     bool load();
     bool reload();
     bool save();
 
     QArray<int> allRecords()const;
     QArray<int> matchRegexp(const QRegExp &r) const;
-    QArray<int> queryByExample( const OTodo&, int querysettings, const QDateTime& d = QDateTime() );
-    OTodo find( int uid )const;
+    QArray<int> queryByExample( const OPimTodo&, int querysettings, const QDateTime& d = QDateTime() );
+    OPimTodo find( int uid )const;
     void clear();
-    bool add( const OTodo& );
+    bool add( const OPimTodo& );
     bool remove( int uid );
     void removeAllCompleted();
-    bool replace( const OTodo& );
+    bool replace( const OPimTodo& );
 
     /* our functions */
     QArray<int> effectiveToDos( const QDate& start,
                                 const QDate& end,
                                 bool includeNoDates );
     QArray<int> overDue();
     QArray<int> sorted( bool asc,  int sortOrder,
                         int sortFilter, int cat );
     QBitArray supports()const;
 private:
     static QBitArray sup();
-    void todo( QAsciiDict<int>*, OTodo&,const QCString&,const QString& );
-    QString toString( const OTodo& )const;
+    void todo( QAsciiDict<int>*, OPimTodo&,const QCString&,const QString& );
+    QString toString( const OPimTodo& )const;
     QString toString( const QArray<int>& ints ) const;
-    QMap<int, OTodo> m_events;
+    QMap<int, OPimTodo> m_events;
     QString m_file;
     QString m_app;
     bool m_opened : 1;
     bool m_changed : 1;
-    class OTodoAccessXMLPrivate;
-    OTodoAccessXMLPrivate* d;
+    class OPimTodoAccessXMLPrivate;
+    OPimTodoAccessXMLPrivate* d;
     int m_year, m_month, m_day;
 
 };
 
 };
 
 #endif
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,21 +1,23 @@
-HEADERS += core/oconversion.h \
+HEADERS += \
+        core/opimdateconversion.h \
         core/opimcache.h \
         core/opimmaintainer.h \
         core/opimresolver.h \
         core/opimstate.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
@@ -50,103 +50,103 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <stdlib.h>
 
 #include <opie2/ocontactaccessbackend_xml.h>
 
 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 */
 	QCopChannel *dbchannel = new QCopChannel( "QPE/PIM", this );
 	connect( dbchannel, SIGNAL(received(const QCString &, const QByteArray &)),
                this, SLOT(copMessage( const QCString &, const QByteArray &)) );
 	if ( autosync ){
 		QCopChannel *syncchannel = new QCopChannel( "QPE/Sync", this );
 		connect( syncchannel, SIGNAL(received(const QCString &, const QByteArray &)),
 			 this, SLOT(copMessage( const QCString &, const QByteArray &)) );
 	}
 
 
 }
-OContactAccess::~OContactAccess ()
+OPimContactAccess::~OPimContactAccess ()
 {
 	/* The user may forget to save the changed database, therefore try to
 	 * do it for him..
 	 */
 	save();
 	// delete m_backEnd; is done by template..
 }
 
 
-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.
 	 */
 	QCopEnvelope e( "QPE/PIM", "addressbookUpdated()" );
 
 	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
@@ -36,52 +36,52 @@
 
 #include <qobject.h>
 
 #include <qpe/qcopenvelope_qws.h>
 
 #include <qvaluelist.h>
 #include <qfileinfo.h>
 
-#include <opie2/ocontact.h>
+#include <opie2/opimcontact.h>
 #include <opie2/ocontactaccessbackend.h>
 #include <opie2/opimaccesstemplate.h>
 
 namespace Opie {
 /**
  * Class to access the contacts database.
  * This is just a frontend for the real database handling which is
  * done by the backend.
  * This class is used to access the Contacts on a system. This class as any OPIE PIM
  * class is backend independent.
  * @author Stefan Eilers, Holger Freyther
  * @see OPimAccessTemplate
  */
-class OContactAccess: public QObject, public OPimAccessTemplate<OContact>
+class OPimContactAccess: public QObject, public OPimAccessTemplate<OPimContact>
 {
     Q_OBJECT
 
  public:
 	/**
          * Create Database with contacts (addressbook).
 	 * @param appname Name of application which wants access to the database
 	 * (i.e. "todolist")
 	 * @param filename The name of the database file. If not set, the default one
 	 * is used.
 	 * @param backend Pointer to an alternative Backend. If not set, we will use
 	 * the default backend.
 	 * @param handlesync If <b>true</b> the database stores the current state
 	 * automatically if it receives the signals <i>flush()</i> and <i>reload()</i>
 	 * which are used before and after synchronisation. If the application wants
 	 * to react itself, it should be disabled by setting it to <b>false</b>
-	 * @see 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.
 	 * Note: <i>query_IgnoreCase</i> just make sense with one of the other attributes !
 	 * @see queryByExample()
 	 */
 	enum QuerySettings {
 		WildCards  = 0x0001,
@@ -130,23 +130,23 @@ class OContactAccess: public QObject, public OPimAccessTemplate<OContact>
 
  signals:
 	/* Signal is emitted if the database was changed. Therefore
 	 * we may need to reload to stay consistent.
 	 * @param which Pointer to the database who created this event. This pointer
 	 * is useful if an application has to handle multiple databases at the same time.
 	 * @see reload()
 	 */
-	void signalChanged ( const 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:
 	void copMessage( const QCString &msg, const QByteArray &data );
 
  private:
         class Private;
 	Private *d;
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
@@ -33,17 +33,17 @@ namespace Opie {
 /**
  * Simple constructor
  * It takes a ODateBookAccessBackend as parent. If it is 0 the default implementation
  * will be used!
  * @param back The backend to be used or 0 for the default backend
  * @param ac What kind of access is intended
  */
 ODateBookAccess::ODateBookAccess( ODateBookAccessBackend* back, enum Access ac )
-    : OPimAccessTemplate<OEvent>( back )
+    : OPimAccessTemplate<OPimEvent>( back )
 {
     if (!back )
         back = OBackendFactory<ODateBookAccessBackend>::Default("datebook", QString::null );
 
     m_backEnd = back;
     setBackEnd( m_backEnd );
 }
 ODateBookAccess::~ODateBookAccess() {
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
@@ -27,29 +27,29 @@
                              Boston, MA 02111-1307, USA.
 */
 #ifndef OPIE_DATE_BOOK_ACCESS_H
 #define OPIE_DATE_BOOK_ACCESS_H
 
 #include "odatebookaccessbackend.h"
 #include "opimaccesstemplate.h"
 
-#include <opie2/oevent.h>
+#include <opie2/opimevent.h>
 
 namespace Opie {
 /**
  * This is the object orientated datebook database. It'll use OBackendFactory
  * to query for a backend.
  * All access to the datebook should be done via this class.
  * Make sure to load and save the datebook this is not part of
  * destructing and creating the object
  *
  * @author Holger Freyther, Stefan Eilers
  */
-class ODateBookAccess : public OPimAccessTemplate<OEvent> {
+class ODateBookAccess : public OPimAccessTemplate<OPimEvent> {
 public:
     ODateBookAccess( ODateBookAccessBackend* = 0l, enum Access acc = Random );
     ~ODateBookAccess();
 
     /* return all events */
     List rawEvents()const;
 
     /* return repeating events */
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
@@ -28,20 +28,20 @@
 */
 #ifndef OPIE_PIM_ACCESS_TEMPLATE_H
 #define OPIE_PIM_ACCESS_TEMPLATE_H
 
 #include <qarray.h>
 
 #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 {
 
 class OPimAccessTemplatePrivate;
 /**
  * Thats the frontend to our OPIE PIM
  * Library. Either you want to use it's
  * interface or you want to implement
@@ -52,17 +52,17 @@ class OPimAccessTemplatePrivate;
 
 template <class T = OPimRecord >
 class OPimAccessTemplate : public OTemplateBase<T> {
 public:
     enum Access {
         Random = 0,
         SortedAccess
     };
-    typedef ORecordList<T> List;
+    typedef OPimRecordList<T> List;
     typedef OPimAccessBackend<T> BackEnd;
     typedef OPimCache<T> Cache;
 
     /**
      * c'tor BackEnd
      * enum Access a small hint on how to handle the backend
      */
     OPimAccessTemplate( BackEnd* end);
diff --git a/libopie2/opiepim/ocontact.cpp b/libopie2/opiepim/core/opimcontact.cpp
index fa5313f..a5df597 100644
--- a/libopie2/opiepim/ocontact.cpp
+++ b/libopie2/opiepim/core/opimcontact.cpp
@@ -24,21 +24,21 @@
     --        :-=`           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 "ocontact.h"
+#include "opimcontact.h"
 
 /* OPIE */
 #include <opie2/opimresolver.h>
-#include <opie2/oconversion.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>
@@ -60,25 +60,25 @@
 */
 
 
 namespace Opie
 {
 /*!
   Creates a new, empty contact.
 */
-OContact::OContact():OPimRecord(), mMap(), d( 0 )
+OPimContact::OPimContact():OPimRecord(), mMap(), d( 0 )
 {}
 
 /*!
   \internal
   Creates a new contact.  The properties of the contact are
   set from \a fromMap.
 */
-OContact::OContact( const QMap<int, QString> &fromMap ):OPimRecord(), mMap( fromMap ), d( 0 )
+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 ) )
@@ -91,366 +91,366 @@ OContact::OContact( const QMap<int, QString> &fromMap ):OPimRecord(), mMap( from
 
     //     if ( !uidStr.isEmpty() )
     // 	setUid( uidStr.toInt() );
 }
 
 /*!
   Destroys a contact.
 */
-OContact::~OContact()
+OPimContact::~OPimContact()
 {}
 
-/*! \fn void OContact::setTitle( const QString &str )
+/*! \fn void OPimContact::setTitle( const QString &str )
   Sets the title of the contact to \a str.
 */
 
-/*! \fn void OContact::setFirstName( const QString &str )
+/*! \fn void OPimContact::setFirstName( const QString &str )
   Sets the first name of the contact to \a str.
 */
 
-/*! \fn void OContact::setMiddleName( const QString &str )
+/*! \fn void OPimContact::setMiddleName( const QString &str )
   Sets the middle name of the contact to \a str.
 */
 
-/*! \fn void OContact::setLastName( const QString &str )
+/*! \fn void OPimContact::setLastName( const QString &str )
   Sets the last name of the contact to \a str.
 */
 
-/*! \fn void OContact::setSuffix( const QString &str )
+/*! \fn void OPimContact::setSuffix( const QString &str )
   Sets the suffix of the contact to \a str.
 */
 
-/*! \fn void OContact::setFileAs( const QString &str )
+/*! \fn void OPimContact::setFileAs( const QString &str )
   Sets the contact to filed as \a str.
 */
 
-/*! \fn void OContact::setDefaultEmail( const QString &str )
+/*! \fn void OPimContact::setDefaultEmail( const QString &str )
   Sets the default email of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomeStreet( const QString &str )
+/*! \fn void OPimContact::setHomeStreet( const QString &str )
   Sets the home street address of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomeCity( const QString &str )
+/*! \fn void OPimContact::setHomeCity( const QString &str )
   Sets the home city of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomeState( const QString &str )
+/*! \fn void OPimContact::setHomeState( const QString &str )
   Sets the home state of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomeZip( const QString &str )
+/*! \fn void OPimContact::setHomeZip( const QString &str )
   Sets the home zip code of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomeCountry( const QString &str )
+/*! \fn void OPimContact::setHomeCountry( const QString &str )
   Sets the home country of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomePhone( const QString &str )
+/*! \fn void OPimContact::setHomePhone( const QString &str )
   Sets the home phone number of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomeFax( const QString &str )
+/*! \fn void OPimContact::setHomeFax( const QString &str )
   Sets the home fax number of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomeMobile( const QString &str )
+/*! \fn void OPimContact::setHomeMobile( const QString &str )
   Sets the home mobile phone number of the contact to \a str.
 */
 
-/*! \fn void OContact::setHomeWebpage( const QString &str )
+/*! \fn void OPimContact::setHomeWebpage( const QString &str )
   Sets the home webpage of the contact to \a str.
 */
 
-/*! \fn void OContact::setCompany( const QString &str )
+/*! \fn void OPimContact::setCompany( const QString &str )
   Sets the company for contact to \a str.
 */
 
-/*! \fn void OContact::setJobTitle( const QString &str )
+/*! \fn void OPimContact::setJobTitle( const QString &str )
   Sets the job title of the contact to \a str.
 */
 
-/*! \fn void OContact::setDepartment( const QString &str )
+/*! \fn void OPimContact::setDepartment( const QString &str )
   Sets the department for contact to \a str.
 */
 
-/*! \fn void OContact::setOffice( const QString &str )
+/*! \fn void OPimContact::setOffice( const QString &str )
   Sets the office for contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessStreet( const QString &str )
+/*! \fn void OPimContact::setBusinessStreet( const QString &str )
   Sets the business street address of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessCity( const QString &str )
+/*! \fn void OPimContact::setBusinessCity( const QString &str )
   Sets the business city of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessState( const QString &str )
+/*! \fn void OPimContact::setBusinessState( const QString &str )
   Sets the business state of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessZip( const QString &str )
+/*! \fn void OPimContact::setBusinessZip( const QString &str )
   Sets the business zip code of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessCountry( const QString &str )
+/*! \fn void OPimContact::setBusinessCountry( const QString &str )
   Sets the business country of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessPhone( const QString &str )
+/*! \fn void OPimContact::setBusinessPhone( const QString &str )
   Sets the business phone number of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessFax( const QString &str )
+/*! \fn void OPimContact::setBusinessFax( const QString &str )
   Sets the business fax number of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessMobile( const QString &str )
+/*! \fn void OPimContact::setBusinessMobile( const QString &str )
   Sets the business mobile phone number of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessPager( const QString &str )
+/*! \fn void OPimContact::setBusinessPager( const QString &str )
   Sets the business pager number of the contact to \a str.
 */
 
-/*! \fn void OContact::setBusinessWebpage( const QString &str )
+/*! \fn void OPimContact::setBusinessWebpage( const QString &str )
   Sets the business webpage of the contact to \a str.
 */
 
-/*! \fn void OContact::setProfession( const QString &str )
+/*! \fn void OPimContact::setProfession( const QString &str )
   Sets the profession of the contact to \a str.
 */
 
-/*! \fn void OContact::setAssistant( const QString &str )
+/*! \fn void OPimContact::setAssistant( const QString &str )
   Sets the assistant of the contact to \a str.
 */
 
-/*! \fn void OContact::setManager( const QString &str )
+/*! \fn void OPimContact::setManager( const QString &str )
   Sets the manager of the contact to \a str.
 */
 
-/*! \fn void OContact::setSpouse( const QString &str )
+/*! \fn void OPimContact::setSpouse( const QString &str )
   Sets the spouse of the contact to \a str.
 */
 
-/*! \fn void OContact::setGender( const QString &str )
+/*! \fn void OPimContact::setGender( const QString &str )
   Sets the gender of the contact to \a str.
 */
 
-/*! \fn void OContact::setNickname( const QString &str )
+/*! \fn void OPimContact::setNickname( const QString &str )
   Sets the nickname of the contact to \a str.
 */
 
-/*! \fn void OContact::setNotes( const QString &str )
+/*! \fn void OPimContact::setNotes( const QString &str )
   Sets the notes about the contact to \a str.
 */
 
-/*! \fn QString OContact::title() const
+/*! \fn QString OPimContact::title() const
   Returns the title of the contact.
 */
 
-/*! \fn QString OContact::firstName() const
+/*! \fn QString OPimContact::firstName() const
   Returns the first name of the contact.
 */
 
-/*! \fn QString OContact::middleName() const
+/*! \fn QString OPimContact::middleName() const
   Returns the middle name of the contact.
 */
 
-/*! \fn QString OContact::lastName() const
+/*! \fn QString OPimContact::lastName() const
   Returns the last name of the contact.
 */
 
-/*! \fn QString OContact::suffix() const
+/*! \fn QString OPimContact::suffix() const
   Returns the suffix of the contact.
 */
 
-/*! \fn QString OContact::fileAs() const
+/*! \fn QString OPimContact::fileAs() const
   Returns the string the contact is filed as.
 */
 
-/*! \fn QString OContact::defaultEmail() const
+/*! \fn QString OPimContact::defaultEmail() const
   Returns the default email address of the contact.
 */
 
-/*! \fn QString OContact::emails() const
+/*! \fn QString OPimContact::emails() const
   Returns the list of email address for a contact separated by ';'s in a single
   string.
 */
 
-/*! \fn QString OContact::homeStreet() const
+/*! \fn QString OPimContact::homeStreet() const
   Returns the home street address of the contact.
 */
 
-/*! \fn QString OContact::homeCity() const
+/*! \fn QString OPimContact::homeCity() const
   Returns the home city of the contact.
 */
 
-/*! \fn QString OContact::homeState() const
+/*! \fn QString OPimContact::homeState() const
   Returns the home state of the contact.
 */
 
-/*! \fn QString OContact::homeZip() const
+/*! \fn QString OPimContact::homeZip() const
   Returns the home zip of the contact.
 */
 
-/*! \fn QString OContact::homeCountry() const
+/*! \fn QString OPimContact::homeCountry() const
   Returns the home country of the contact.
 */
 
-/*! \fn QString OContact::homePhone() const
+/*! \fn QString OPimContact::homePhone() const
   Returns the home phone number of the contact.
 */
 
-/*! \fn QString OContact::homeFax() const
+/*! \fn QString OPimContact::homeFax() const
   Returns the home fax number of the contact.
 */
 
-/*! \fn QString OContact::homeMobile() const
+/*! \fn QString OPimContact::homeMobile() const
   Returns the home mobile number of the contact.
 */
 
-/*! \fn QString OContact::homeWebpage() const
+/*! \fn QString OPimContact::homeWebpage() const
   Returns the home webpage of the contact.
 */
 
-/*! \fn QString OContact::company() const
+/*! \fn QString OPimContact::company() const
   Returns the company for the contact.
 */
 
-/*! \fn QString OContact::department() const
+/*! \fn QString OPimContact::department() const
   Returns the department for the contact.
 */
 
-/*! \fn QString OContact::office() const
+/*! \fn QString OPimContact::office() const
   Returns the office for the contact.
 */
 
-/*! \fn QString OContact::jobTitle() const
+/*! \fn QString OPimContact::jobTitle() const
   Returns the job title of the contact.
 */
 
-/*! \fn QString OContact::profession() const
+/*! \fn QString OPimContact::profession() const
   Returns the profession of the contact.
 */
 
-/*! \fn QString OContact::assistant() const
+/*! \fn QString OPimContact::assistant() const
   Returns the assistant of the contact.
 */
 
-/*! \fn QString OContact::manager() const
+/*! \fn QString OPimContact::manager() const
   Returns the manager of the contact.
 */
 
-/*! \fn QString OContact::businessStreet() const
+/*! \fn QString OPimContact::businessStreet() const
   Returns the business street address of the contact.
 */
 
-/*! \fn QString OContact::businessCity() const
+/*! \fn QString OPimContact::businessCity() const
   Returns the business city of the contact.
 */
 
-/*! \fn QString OContact::businessState() const
+/*! \fn QString OPimContact::businessState() const
   Returns the business state of the contact.
 */
 
-/*! \fn QString OContact::businessZip() const
+/*! \fn QString OPimContact::businessZip() const
   Returns the business zip of the contact.
 */
 
-/*! \fn QString OContact::businessCountry() const
+/*! \fn QString OPimContact::businessCountry() const
   Returns the business country of the contact.
 */
 
-/*! \fn QString OContact::businessPhone() const
+/*! \fn QString OPimContact::businessPhone() const
   Returns the business phone number of the contact.
 */
 
-/*! \fn QString OContact::businessFax() const
+/*! \fn QString OPimContact::businessFax() const
   Returns the business fax number of the contact.
 */
 
-/*! \fn QString OContact::businessMobile() const
+/*! \fn QString OPimContact::businessMobile() const
   Returns the business mobile number of the contact.
 */
 
-/*! \fn QString OContact::businessPager() const
+/*! \fn QString OPimContact::businessPager() const
   Returns the business pager number of the contact.
 */
 
-/*! \fn QString OContact::businessWebpage() const
+/*! \fn QString OPimContact::businessWebpage() const
   Returns the business webpage of the contact.
 */
 
-/*! \fn QString OContact::spouse() const
+/*! \fn QString OPimContact::spouse() const
   Returns the spouse of the contact.
 */
 
-/*! \fn QString OContact::gender() const
+/*! \fn QString OPimContact::gender() const
   Returns the gender of the contact.
 */
 
-/*! \fn QString OContact::nickname() const
+/*! \fn QString OPimContact::nickname() const
   Returns the nickname of the contact.
 */
 
-/*! \fn QString OContact::children() const
+/*! \fn QString OPimContact::children() const
   Returns the children of the contact.
 */
 
-/*! \fn QString OContact::notes() const
+/*! \fn QString OPimContact::notes() const
   Returns the notes relating to the the contact.
 */
 
-/*! \fn QString OContact::groups() const
+/*! \fn QString OPimContact::groups() const
   \internal
   Returns the groups for the contact.
 */
 
-/*! \fn QStringList OContact::groupList() const
+/*! \fn QStringList OPimContact::groupList() const
   \internal
 */
 
-/*! \fn QString OContact::field(int) const
+/*! \fn QString OPimContact::field(int) const
   \internal
 */
 
-/*! \fn void OContact::saveJournal( journal_action, const QString & = QString::null )
+/*! \fn void OPimContact::saveJournal( journal_action, const QString & = QString::null )
   \internal
 */
 
-/*! \fn void OContact::setUid( int id )
+/*! \fn void OPimContact::setUid( int id )
   \internal
   Sets the uid for this record to \a id.
 */
 
-/*! \enum OContact::journal_action
+/*! \enum OPimContact::journal_action
   \internal
 */
 
 /*!
   \internal
 */
-QMap<int, QString> OContact::toMap() const
+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 OContact::toRichText() const
+QString OPimContact::toRichText() const
 {
     QString text;
     QString value, comp, state;
     QString str;
     bool marker = false;
 
     Config cfg( "qpe" );
     cfg.setGroup( "Appearance" );
@@ -775,49 +775,49 @@ QString OContact::toRichText() const
         text += "<br>" + tmp + "<br>";
     }
     return text;
 }
 
 /*!
   \internal
 */
-void OContact::insert( int key, const QString &v )
+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 OContact::replace( int key, const QString & v )
+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 OContact::find( int key ) const
+QString OPimContact::find( int key ) const
 {
     return mMap[ key ];
 }
 
 /*!
   \internal
 */
-QString OContact::displayAddress( const QString &street,
+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";
@@ -832,37 +832,37 @@ QString OContact::displayAddress( const QString &street,
         s += "\n";
     s += country;
     return s;
 }
 
 /*!
   \internal
 */
-QString OContact::displayBusinessAddress() const
+QString OPimContact::displayBusinessAddress() const
 {
     return displayAddress( businessStreet(), businessCity(),
                            businessState(), businessZip(),
                            businessCountry() );
 }
 
 /*!
   \internal
 */
-QString OContact::displayHomeAddress() const
+QString OPimContact::displayHomeAddress() const
 {
     return displayAddress( homeStreet(), homeCity(),
                            homeState(), homeZip(),
                            homeCountry() );
 }
 
 /*!
   Returns the full name of the contact
 */
-QString OContact::fullName() const
+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;
@@ -891,49 +891,49 @@ QString OContact::fullName() const
         name += suffix;
     }
     return name.simplifyWhiteSpace();
 }
 
 /*!
   Returns a list of the names of the children of the contact.
 */
-QStringList OContact::childrenList() const
+QStringList OPimContact::childrenList() const
 {
     return QStringList::split( " ", find( Qtopia::Children ) );
 }
 
-/*! \fn void OContact::insertEmail( const QString &email )
+/*! \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 OContact::removeEmail( const QString &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 OContact::clearEmails()
+/*! \fn void OPimContact::clearEmails()
 
   Clears the email list.
  */
 
-/*! \fn void OContact::insertEmails( const QStringList &emailList )
+/*! \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 OContact::emailList() const
+QStringList OPimContact::emailList() const
 {
     QString emailStr = emails();
 
     QStringList r;
     if ( !emailStr.isEmpty() )
     {
         qDebug( " emailstr " );
         QStringList l = QStringList::split( emailSeparator(), emailStr );
@@ -945,17 +945,17 @@ QStringList OContact::emailList() const
 }
 
 /*!
   \overload
 
   Generates the string for the contact to be filed as from the first,
   middle and last name of the contact.
 */
-void OContact::setFileAs()
+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() )
@@ -970,17 +970,17 @@ void OContact::setFileAs()
 
     replace( Qtopia::FileAs, fileas );
 }
 
 /*!
   \internal
   Appends the contact information to \a buf.
 */
-void OContact::save( QString &buf ) const
+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();
@@ -1003,17 +1003,17 @@ void OContact::save( QString &buf ) const
 
 
 /*!
   \internal
   Returns the list of fields belonging to a contact
   Never change order of this list ! It has to be regarding
   enum AddressBookFields !!
 */
-QStringList OContact::fields()
+QStringList OPimContact::fields()
 {
     QStringList list;
 
     list.append( "Title" );  // Not Used!
     list.append( "FirstName" );
     list.append( "MiddleName" );
     list.append( "LastName" );
     list.append( "Suffix" );
@@ -1066,37 +1066,37 @@ QStringList OContact::fields()
     return list;
 }
 
 
 /*!
   Sets the list of email address for contact to those contained in \a str.
   Email address should be separated by ';'s.
 */
-void OContact::setEmails( const QString &str )
+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 OContact::setChildren( const QString &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 OContact::match( const QRegExp &r ) const
+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 )
@@ -1105,105 +1105,105 @@ bool OContact::match( const QRegExp &r ) const
             match = true;
             break;
         }
     }
     return match;
 }
 
 
-QString OContact::toShortText() const
+QString OPimContact::toShortText() const
 {
     return ( fullName() );
 }
 
 
-QString OContact::type() const
+QString OPimContact::type() const
 {
-    return QString::fromLatin1( "OContact" );
+    return QString::fromLatin1( "OPimContact" );
 }
 
 
-class QString OContact::recordField( int pos ) const
+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 OContact::setBirthday( const QDate& date )
+/*! \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 OContact::setBirthday( const QDate &v )
+void OPimContact::setBirthday( const QDate &v )
 {
     if ( v.isNull() )
     {
         qWarning( "Remove Birthday" );
         replace( Qtopia::Birthday, QString::null );
         return ;
     }
 
     if ( v.isValid() )
-        replace( Qtopia::Birthday, OConversion::dateToString( v ) );
+        replace( Qtopia::Birthday, OPimDateConversion::dateToString( v ) );
 
 }
 
 
-/*! \fn void OContact::setAnniversary( const QDate &date )
+/*! \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 OContact::setAnniversary( const QDate &v )
+void OPimContact::setAnniversary( const QDate &v )
 {
     if ( v.isNull() )
     {
         qWarning( "Remove Anniversary" );
         replace( Qtopia::Anniversary, QString::null );
         return ;
     }
 
     if ( v.isValid() )
-        replace( Qtopia::Anniversary, OConversion::dateToString( v ) );
+        replace( Qtopia::Anniversary, OPimDateConversion::dateToString( v ) );
 }
 
 
-/*! \fn QDate OContact::birthday() const
+/*! \fn QDate OPimContact::birthday() const
   Returns the birthday of the contact.
 */
-QDate OContact::birthday() const
+QDate OPimContact::birthday() const
 {
     QString str = find( Qtopia::Birthday );
     // qWarning ("Birthday %s", str.latin1() );
     if ( !str.isEmpty() )
-        return OConversion::dateFromString ( str );
+        return OPimDateConversion::dateFromString ( str );
     else
         return QDate();
 }
 
 
-/*! \fn QDate OContact::anniversary() const
+/*! \fn QDate OPimContact::anniversary() const
   Returns the anniversary of the contact.
 */
-QDate OContact::anniversary() const
+QDate OPimContact::anniversary() const
 {
     QDate empty;
     QString str = find( Qtopia::Anniversary );
     // qWarning ("Anniversary %s", str.latin1() );
     if ( !str.isEmpty() )
-        return OConversion::dateFromString ( str );
+        return OPimDateConversion::dateFromString ( str );
     else
         return empty;
 }
 
 
-void OContact::insertEmail( const QString &v )
+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() )
     {
@@ -1217,17 +1217,17 @@ void OContact::insertEmail( const QString &v )
         return ;
     if ( !emailsStr.isEmpty() )
         emailsStr += emailSeparator();
     emailsStr += e;
     replace( Qtopia::Emails, emailsStr );
 }
 
 
-        void OContact::removeEmail( const QString &v )
+        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 ) )
@@ -1247,47 +1247,47 @@ void OContact::insertEmail( const QString &v )
         if ( !emails.count() )
             clearEmails();
         else // setDefaultEmail will remove e from the list
             setDefaultEmail( emails.first() );
     }
 }
 
 
-void OContact::clearEmails()
+void OPimContact::clearEmails()
 {
     mMap.remove( Qtopia::DefaultEmail );
     mMap.remove( Qtopia::Emails );
 }
 
 
-void OContact::setDefaultEmail( const QString &v )
+void OPimContact::setDefaultEmail( const QString &v )
 {
     QString e = v.simplifyWhiteSpace();
 
-    //qDebug("OContact::setDefaultEmail %s", e.latin1());
+    //qDebug("OPimContact::setDefaultEmail %s", e.latin1());
     replace( Qtopia::DefaultEmail, e );
 
     if ( !e.isEmpty() )
         insertEmail( e );
 
 }
 
 
-void OContact::insertEmails( const QStringList &v )
+void OPimContact::insertEmails( const QStringList &v )
 {
     for ( QStringList::ConstIterator it = v.begin(); it != v.end(); ++it )
         insertEmail( *it );
 }
 
 
-int OContact::rtti()
+int OPimContact::rtti()
 {
     return OPimResolver::AddressBook;
 }
 
 
-void OContact::setUid( int i )
+void OPimContact::setUid( int i )
 {
     OPimRecord::setUid( i );
     replace( Qtopia::AddressUid , QString::number( i ) );
 }
 }
diff --git a/libopie2/opiepim/ocontact.h b/libopie2/opiepim/core/opimcontact.h
index 445fd7d..c08f7ed 100644
--- a/libopie2/opiepim/ocontact.h
+++ b/libopie2/opiepim/core/opimcontact.h
@@ -41,33 +41,33 @@
 #if defined(QPC_TEMPLATEDLL)
 // MOC_SKIP_BEGIN
 QPC_TEMPLATEEXTERN template class QPC_EXPORT QMap<int, QString>;
 // MOC_SKIP_END
 #endif
 
 namespace Opie
 {
-class OContactPrivate;
+class OPimContactPrivate;
 
 /**
- * OContact class represents a specialised PIM Record for contacts.
+ * 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 OContact : public OPimRecord
+class QPC_EXPORT OPimContact : public OPimRecord
 {
     friend class DataSet;
 
   public:
-    OContact();
-    OContact( const QMap<int, QString> &fromMap );
-    virtual ~OContact();
+    OPimContact();
+    OPimContact( const QMap<int, QString> &fromMap );
+    virtual ~OPimContact();
 
     enum DateFormat{
         Zip_City_State = 0,
         City_State_Zip
     };
 
     /*
      * do we need to inline them
@@ -227,30 +227,30 @@ class QPC_EXPORT OContact : public OPimRecord
 
     // 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 OContactAccessBackend_XML;
+    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;
-    OContactPrivate *d;
+    OPimContactPrivate *d;
 };
 
 }
 
 #endif
diff --git a/libopie2/opiepim/ocontactfields.cpp b/libopie2/opiepim/core/opimcontactfields.cpp
index bec00f7..4b0ba3b 100644
--- a/libopie2/opiepim/ocontactfields.cpp
+++ b/libopie2/opiepim/core/opimcontactfields.cpp
@@ -22,35 +22,35 @@
  -.   .:....=;==+<;          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 "ocontactfields.h"
+#include "opimcontactfields.h"
 
 /* OPIE */
-#include <opie2/ocontact.h>
+#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 OContactFields::personalfields( bool sorted, bool translated )
+QStringList OPimContactFields::personalfields( bool sorted, bool translated )
 {
     QStringList list;
     QMap<int, QString> mapIdToStr;
     if ( translated )
         mapIdToStr = idToTrFields();
     else
         mapIdToStr = idToUntrFields();
 
@@ -74,17 +74,17 @@ QStringList OContactFields::personalfields( bool sorted, bool translated )
     if ( sorted ) list.sort();
     return list;
 }
 
 /*!
   \internal
   Returns a list of details field names for a contact.
 */
-QStringList OContactFields::detailsfields( bool sorted, bool translated )
+QStringList OPimContactFields::detailsfields( bool sorted, bool translated )
 {
     QStringList list;
     QMap<int, QString> mapIdToStr;
     if ( translated )
         mapIdToStr = idToTrFields();
     else
         mapIdToStr = idToUntrFields();
 
@@ -103,17 +103,17 @@ QStringList OContactFields::detailsfields( bool sorted, bool translated )
     if ( sorted ) list.sort();
     return list;
 }
 
 /*!
   \internal
   Returns a list of phone field names for a contact.
 */
-QStringList OContactFields::phonefields( bool sorted, bool translated )
+QStringList OPimContactFields::phonefields( bool sorted, bool translated )
 {
     QStringList list;
     QMap<int, QString> mapIdToStr;
     if ( translated )
         mapIdToStr = idToTrFields();
     else
         mapIdToStr = idToUntrFields();
 
@@ -136,17 +136,17 @@ QStringList OContactFields::phonefields( bool sorted, bool translated )
 
     return list;
 }
 
 /*!
   \internal
   Returns a list of field names for a contact.
 */
-QStringList OContactFields::fields( bool sorted, bool translated )
+QStringList OPimContactFields::fields( bool sorted, bool translated )
 {
     QStringList list;
     QMap<int, QString> mapIdToStr;
     if ( translated )
         mapIdToStr = idToTrFields();
     else
         mapIdToStr = idToUntrFields();
 
@@ -173,90 +173,90 @@ QStringList OContactFields::fields( bool sorted, bool translated )
     return list;
 }
 
 
 /*!
   \internal
   Returns an untranslated list of personal field names for a contact.
 */
-QStringList OContactFields::untrpersonalfields( bool sorted )
+QStringList OPimContactFields::untrpersonalfields( bool sorted )
 {
     return personalfields( sorted, false );
 }
 
 
 /*!
   \internal
   Returns a translated list of personal field names for a contact.
 */
-QStringList OContactFields::trpersonalfields( bool sorted )
+QStringList OPimContactFields::trpersonalfields( bool sorted )
 {
     return personalfields( sorted, true );
 }
 
 
 /*!
   \internal
   Returns an untranslated list of details field names for a contact.
 */
-QStringList OContactFields::untrdetailsfields( bool sorted )
+QStringList OPimContactFields::untrdetailsfields( bool sorted )
 {
     return detailsfields( sorted, false );
 }
 
 
 /*!
   \internal
   Returns a translated list of details field names for a contact.
 */
-QStringList OContactFields::trdetailsfields( bool sorted )
+QStringList OPimContactFields::trdetailsfields( bool sorted )
 {
     return detailsfields( sorted, true );
 }
 
 
 /*!
   \internal
   Returns a translated list of phone field names for a contact.
 */
-QStringList OContactFields::trphonefields( bool sorted )
+QStringList OPimContactFields::trphonefields( bool sorted )
 {
     return phonefields( sorted, true );
 }
 
 /*!
   \internal
   Returns an untranslated list of phone field names for a contact.
 */
-QStringList OContactFields::untrphonefields( bool sorted )
+QStringList OPimContactFields::untrphonefields( bool sorted )
 {
     return phonefields( sorted, false );
 }
 
 
 /*!
   \internal
   Returns a translated list of field names for a contact.
 */
-QStringList OContactFields::trfields( bool sorted )
+QStringList OPimContactFields::trfields( bool sorted )
 {
     return fields( sorted, true );
 }
 
 /*!
   \internal
   Returns an untranslated list of field names for a contact.
 */
-QStringList OContactFields::untrfields( bool sorted )
+QStringList OPimContactFields::untrfields( bool sorted )
 {
     return fields( sorted, false );
 }
 
-QMap<int, QString> OContactFields::idToTrFields()
+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" ) );
@@ -312,17 +312,17 @@ QMap<int, QString> OContactFields::idToTrFields()
 
     // other
     ret_map.insert( Qtopia::Notes, QObject::tr( "Notes" ) );
 
 
     return ret_map;
 }
 
-QMap<int, QString> OContactFields::idToUntrFields()
+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" );
@@ -379,87 +379,87 @@ QMap<int, QString> OContactFields::idToUntrFields()
     // other
     ret_map.insert( Qtopia::Notes, "Notes" );
     ret_map.insert( Qtopia::Groups, "Groups" );
 
 
     return ret_map;
 }
 
-QMap<QString, int> OContactFields::trFieldsToId()
+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> OContactFields::untrFieldsToId()
+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;
 }
 
 
-OContactFields::OContactFields() :
+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 );
 }
 
-OContactFields::~OContactFields()
+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 OContactFields::saveToRecord( OContact &cnt )
+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 OContactFields::loadFromRecord( const OContact &cnt )
+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 );
@@ -470,31 +470,31 @@ void OContactFields::loadFromRecord( const OContact &cnt )
     {
         fieldOrder = globalFieldOrder;
     }
 
 
     qDebug( "effective fieldOrder in loadFromRecord >%s<", fieldOrder.latin1() );
 }
 
-void OContactFields::setFieldOrder( int num, int index )
+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 OContactFields::getFieldOrder( int num, int defIndex )
+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;
diff --git a/libopie2/opiepim/ocontactfields.h b/libopie2/opiepim/core/opimcontactfields.h
index 9e89532..3aa3894 100644
--- a/libopie2/opiepim/ocontactfields.h
+++ b/libopie2/opiepim/core/opimcontactfields.h
@@ -28,33 +28,33 @@
 */
 
 #ifndef OCONTACTFIELDS_H
 #define OCONTACTFIELDS_H
 
 class QStringList;
 
 /* OPIE */
-#include <opie2/ocontact.h>
+#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 OContactFields
+class OPimContactFields
 {
 
   public:
-    OContactFields();
-    ~OContactFields();
+    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.
@@ -63,19 +63,19 @@ class OContactFields
      * @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( OContact& );
+    void saveToRecord( OPimContact& );
     /** Get Fieldorder from contact. */
-    void loadFromRecord( const OContact& );
+    void loadFromRecord( const OPimContact& );
 
   private:
     QString fieldOrder;
     QString globalFieldOrder;
     bool changedFieldOrder;
 
   public:
     static QStringList personalfields( bool sorted = true, bool translated = false );
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
@@ -22,23 +22,23 @@ _;:,     .>    :=|.         This program is free software; you can
  -_. . .   )=.  =           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.

 */

 

 /* 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;

 

     // ISO format in year, month, day (YYYYMMDD); e.g. 20021231

     QString year = QString::number( d.year() );

     QString month = QString::number( d.month() );

     month = month.rightJustify( 2, '0' );

@@ -47,17 +47,17 @@ QString OConversion::dateToString( const QDate &d )
 

     QString str = year + month + day;

     //qDebug( "\tPimContact dateToStr = %s", str.latin1() );

 

     return str;

 }

 

 

-QDate OConversion::dateFromString( const QString& s )

+QDate OPimDateConversion::dateFromString( const QString& s )

 {

     QDate date;

 

     if ( s.isEmpty() )

         return date;

 

     // Be backward compatible to old Opie format:

     // Try to load old format. If it fails, try new ISO-Format!

@@ -94,17 +94,17 @@ QDate OConversion::dateFromString( const QString& s )
         qWarning( "PimContact date is not valid" );

         return date;

     }

 

     return date;

 }

 

 

-QString OConversion::dateTimeToString( const QDateTime& dt )

+QString OPimDateConversion::dateTimeToString( const QDateTime& dt )

 {

     if ( !dt.isValid() || dt.isNull() )

         return QString::null;

 

     QString year = QString::number( dt.date().year() );

     QString month = QString::number( dt.date().month() );

     QString day = QString::number( dt.date().day() );

 

@@ -117,17 +117,17 @@ QString OConversion::dateTimeToString( const QDateTime& dt )
     hour = hour. rightJustify( 2, '0' );

     min = min. rightJustify( 2, '0' );

     sec = sec. rightJustify( 2, '0' );

 

     return day + month + year + hour + min + sec;

 }

 

 

-QDateTime OConversion::dateTimeFromString( const QString& str )

+QDateTime OPimDateConversion::dateTimeFromString( const QString& str )

 {

 

     if ( str.isEmpty() )

         return QDateTime();

     int day = str.mid( 0, 2 ).toInt();

     int month = str.mid( 2, 2 ).toInt();

     int year = str.mid( 4, 4 ).toInt();

     int hour = str.mid( 8, 2 ).toInt();

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
@@ -30,17 +30,17 @@
 #ifndef OCONVERSION_H
 #define OCONVERSION_H
 
 /* QT */
 #include <qdatetime.h>
 
 namespace Opie {
 
-class OConversion
+class OPimDateConversion
 {
 public:
     static QString dateToString( const QDate &d );
     static QDate dateFromString( const QString &datestr );
 
     /**
      * simple function to store DateTime as string and read from string
      * no timezone changing is done
diff --git a/libopie2/opiepim/oevent.cpp b/libopie2/opiepim/core/opimevent.cpp
index d9cee2b..3ddbf85 100644
--- a/libopie2/opiepim/oevent.cpp
+++ b/libopie2/opiepim/core/opimevent.cpp
@@ -22,20 +22,20 @@
  -.   .:....=;==+<;          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 "oevent.h"
+#include "opimevent.h"
 
 /* OPIE */
-#include <opie2/orecur.h>
+#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>
@@ -65,34 +65,34 @@ int OCalendarHelper::ocurrence( const QDate& date )
     // 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 = ORecur::MON;
-    while ( !( i & day ) && i <= ORecur::SUN )
+    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 OEvent::Data : public QShared
+struct OPimEvent::Data : public QShared
 {
     Data() : QShared()
     {
         child = 0;
         recur = 0;
         manager = 0;
         isAllDay = false;
         parent = 0;
@@ -100,266 +100,266 @@ struct OEvent::Data : public QShared
     ~Data()
     {
         delete manager;
         delete recur;
     }
     QString description;
     QString location;
     OPimNotifyManager* manager;
-    ORecur* recur;
+    OPimRecurrence* recur;
     QString note;
     QDateTime created;
     QDateTime start;
     QDateTime end;
 bool isAllDay : 1;
     QString timezone;
     QArray<int>* child;
     int parent;
 };
 
 
-OEvent::OEvent( int uid )
+OPimEvent::OPimEvent( int uid )
         : OPimRecord( uid )
 {
     data = new Data;
 }
 
 
-OEvent::OEvent( const OEvent& ev )
+OPimEvent::OPimEvent( const OPimEvent& ev )
         : OPimRecord( ev ), data( ev.data )
 {
     data->ref();
 }
 
 
-OEvent::OEvent( const QMap<int, QString> map )
+OPimEvent::OPimEvent( const QMap<int, QString> map )
         : OPimRecord( 0 )
 {
     data = new Data;
 
     fromMap( map );
 }
 
 
-OEvent::~OEvent()
+OPimEvent::~OPimEvent()
 {
     if ( data->deref() )
     {
         delete data;
         data = 0;
     }
 }
 
 
-OEvent& OEvent::operator=( const OEvent& ev )
+OPimEvent& OPimEvent::operator=( const OPimEvent& ev )
 {
     if ( this == &ev ) return * this;
 
     OPimRecord::operator=( ev );
     ev.data->ref();
     deref();
     data = ev.data;
 
 
     return *this;
 }
 
 
-QString OEvent::description() const
+QString OPimEvent::description() const
 {
     return data->description;
 }
 
 
-void OEvent::setDescription( const QString& description )
+void OPimEvent::setDescription( const QString& description )
 {
     changeOrModify();
     data->description = description;
 }
 
 
-void OEvent::setLocation( const QString& loc )
+void OPimEvent::setLocation( const QString& loc )
 {
     changeOrModify();
     data->location = loc;
 }
 
 
-QString OEvent::location() const
+QString OPimEvent::location() const
 {
     return data->location;
 }
 
 
-OPimNotifyManager &OEvent::notifiers() const
+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 OEvent::hasNotifiers() const
+bool OPimEvent::hasNotifiers() const
 {
     if ( !data->manager )
         return false;
     if ( data->manager->reminders().isEmpty() &&
             data->manager->alarms().isEmpty() )
         return false;
 
     return true;
 }
 
 
-ORecur OEvent::recurrence() const
+OPimRecurrence OPimEvent::recurrence() const
 {
     if ( !data->recur )
-        data->recur = new ORecur;
+        data->recur = new OPimRecurrence;
 
     return *data->recur;
 }
 
 
-void OEvent::setRecurrence( const ORecur& rec )
+void OPimEvent::setRecurrence( const OPimRecurrence& rec )
 {
     changeOrModify();
     if ( data->recur )
         ( *data->recur ) = rec;
     else
-        data->recur = new ORecur( rec );
+        data->recur = new OPimRecurrence( rec );
 }
 
 
-bool OEvent::hasRecurrence() const
+bool OPimEvent::hasRecurrence() const
 {
     if ( !data->recur ) return false;
     return data->recur->doesRecur();
 }
 
 
-QString OEvent::note() const
+QString OPimEvent::note() const
 {
     return data->note;
 }
 
 
-void OEvent::setNote( const QString& note )
+void OPimEvent::setNote( const QString& note )
 {
     changeOrModify();
     data->note = note;
 }
 
 
-QDateTime OEvent::createdDateTime() const
+QDateTime OPimEvent::createdDateTime() const
 {
     return data->created;
 }
 
 
-void OEvent::setCreatedDateTime( const QDateTime& time )
+void OPimEvent::setCreatedDateTime( const QDateTime& time )
 {
     changeOrModify();
     data->created = time;
 }
 
 
-QDateTime OEvent::startDateTime() const
+QDateTime OPimEvent::startDateTime() const
 {
     if ( data->isAllDay )
         return QDateTime( data->start.date(), QTime( 0, 0, 0 ) );
     return data->start;
 }
 
 
-QDateTime OEvent::startDateTimeInZone() const
+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 == OTimeZone::current().timeZone() ) return startDateTime();
+    if ( data->timezone.isEmpty() || data->isAllDay || data->timezone == OPimTimeZone::current().timeZone() ) return startDateTime();
 
-    OTimeZone zone( data->timezone );
-    return zone.toDateTime( data->start, OTimeZone::current() );
+    OPimTimeZone zone( data->timezone );
+    return zone.toDateTime( data->start, OPimTimeZone::current() );
 }
 
 
-void OEvent::setStartDateTime( const QDateTime& dt )
+void OPimEvent::setStartDateTime( const QDateTime& dt )
 {
     changeOrModify();
     data->start = dt;
 }
 
 
-QDateTime OEvent::endDateTime() const
+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 OEvent::endDateTimeInZone() const
+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 == OTimeZone::current().timeZone() ) return endDateTime();
+    if ( data->timezone.isEmpty() || data->isAllDay || data->timezone == OPimTimeZone::current().timeZone() ) return endDateTime();
 
-    OTimeZone zone( data->timezone );
-    return zone.toDateTime( data->end, OTimeZone::current() );
+    OPimTimeZone zone( data->timezone );
+    return zone.toDateTime( data->end, OPimTimeZone::current() );
 }
 
 
-void OEvent::setEndDateTime( const QDateTime& dt )
+void OPimEvent::setEndDateTime( const QDateTime& dt )
 {
     changeOrModify();
     data->end = dt;
 }
 
 
-bool OEvent::isMultipleDay() const
+bool OPimEvent::isMultipleDay() const
 {
     return data->end.date().day() - data->start.date().day();
 }
 
 
-bool OEvent::isAllDay() const
+bool OPimEvent::isAllDay() const
 {
     return data->isAllDay;
 }
 
 
-void OEvent::setAllDay( bool allDay )
+void OPimEvent::setAllDay( bool allDay )
 {
     changeOrModify();
     data->isAllDay = allDay;
     if ( allDay ) data->timezone = "UTC";
 }
 
 
-void OEvent::setTimeZone( const QString& tz )
+void OPimEvent::setTimeZone( const QString& tz )
 {
     changeOrModify();
     data->timezone = tz;
 }
 
 
-QString OEvent::timeZone() const
+QString OPimEvent::timeZone() const
 {
     if ( data->isAllDay ) return QString::fromLatin1( "UTC" );
     return data->timezone;
 }
 
 
-bool OEvent::match( const QRegExp& re ) const
+bool OPimEvent::match( const QRegExp& re ) const
 {
     if ( re.match( data->description ) != -1 )
     {
         setLastHitField( Qtopia::DatebookDescription );
         return true;
     }
     if ( re.match( data->note ) != -1 )
     {
@@ -380,17 +380,17 @@ bool OEvent::match( const QRegExp& re ) const
     {
         setLastHitField( Qtopia::EndDateTime );
         return true;
     }
     return false;
 }
 
 
-QString OEvent::toRichText() const
+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]" ), "" );
@@ -449,17 +449,17 @@ QString OEvent::toRichText() const
         text += note();
         //         text += Qtopia::escapeString(note() ).
         //                 replace(QRegExp( "[\n]"),  "<br>" ) + "<br>";
     }
     return text;
 }
 
 
-QString OEvent::toShortText() const
+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 += " ";
@@ -467,60 +467,60 @@ QString OEvent::toShortText() const
     text += ":";
     text += QString::number( startDateTime().time().minute() );
     text += " - ";
     text += description();
     return text;
 }
 
 
-QString OEvent::type() const
+QString OPimEvent::type() const
 {
-    return QString::fromLatin1( "OEvent" );
+    return QString::fromLatin1( "OPimEvent" );
 }
 
 
-QString OEvent::recordField( int /*id */ ) const
+QString OPimEvent::recordField( int /*id */ ) const
 {
     return QString::null;
 }
 
 
-int OEvent::rtti()
+int OPimEvent::rtti()
 {
     return OPimResolver::DateBook;
 }
 
 
-bool OEvent::loadFromStream( QDataStream& )
+bool OPimEvent::loadFromStream( QDataStream& )
 {
     return true;
 }
 
 
-bool OEvent::saveToStream( QDataStream& ) const
+bool OPimEvent::saveToStream( QDataStream& ) const
 {
     return true;
 }
 
 
-void OEvent::changeOrModify()
+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 ORecur( *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;
@@ -531,222 +531,222 @@ void OEvent::changeOrModify()
             d2->child->detach();
         }
 
         data = d2;
     }
 }
 
 
-void OEvent::deref()
+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> OEvent::toMap() const
+QMap<int, QString> OPimEvent::toMap() const
 {
     QMap<int, QString> retMap;
 
-    retMap.insert( OEvent::FUid, QString::number( uid() ) );
-    retMap.insert( OEvent::FCategories, Qtopia::escapeString( Qtopia::Record::idsToString( categories() ) ) );
-    retMap.insert( OEvent::FDescription, Qtopia::escapeString( description() ) );
-    retMap.insert( OEvent::FLocation, Qtopia::escapeString( location() ) );
-    retMap.insert( OEvent::FType, isAllDay() ? "AllDay" : "" );
+    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( OEvent::FAlarm, QString::number( alarm.dateTime().secsTo( startDateTime() ) / 60 ) );
-    retMap.insert( OEvent::FSound, ( alarm.sound() == OPimAlarm::Loud ) ? "loud" : "silent" );
-
-    OTimeZone zone( timeZone().isEmpty() ? OTimeZone::current() : timeZone() );
-    retMap.insert( OEvent::FStart, QString::number( zone.fromUTCDateTime( zone.toDateTime( startDateTime(), OTimeZone::utc() ) ) ) );
-    retMap.insert( OEvent::FEnd, QString::number( zone.fromUTCDateTime( zone.toDateTime( endDateTime(), OTimeZone::utc() ) ) ) );
-    retMap.insert( OEvent::FNote, Qtopia::escapeString( note() ) );
-    retMap.insert( OEvent::FTimeZone, timeZone().isEmpty() ? QString( "None" ) : timeZone() );
+    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( OEvent::FRecParent, QString::number( 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( OEvent::FRecChildren, buf );
+        retMap.insert( OPimEvent::FRecChildren, buf );
     }
 
     // Add recurrence stuff
     if ( hasRecurrence() )
     {
-        ORecur recur = recurrence();
+        OPimRecurrence recur = recurrence();
         QMap<int, QString> recFields = recur.toMap();
-        retMap.insert( OEvent::FRType, recFields[ ORecur::RType ] );
-        retMap.insert( OEvent::FRWeekdays, recFields[ ORecur::RWeekdays ] );
-        retMap.insert( OEvent::FRPosition, recFields[ ORecur::RPosition ] );
-        retMap.insert( OEvent::FRFreq, recFields[ ORecur::RFreq ] );
-        retMap.insert( OEvent::FRHasEndDate, recFields[ ORecur::RHasEndDate ] );
-        retMap.insert( OEvent::FREndDate, recFields[ ORecur::EndDate ] );
-        retMap.insert( OEvent::FRCreated, recFields[ ORecur::Created ] );
-        retMap.insert( OEvent::FRExceptions, recFields[ ORecur::Exceptions ] );
+        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
     {
-        ORecur recur = recurrence();
+        OPimRecurrence recur = recurrence();
         QMap<int, QString> recFields = recur.toMap();
-        retMap.insert( OEvent::FRType, recFields[ ORecur::RType ] );
+        retMap.insert( OPimEvent::FRType, recFields[ OPimRecurrence::RType ] );
     }
 
     return retMap;
 }
 
 
-void OEvent::fromMap( const QMap<int, QString>& map )
+void OPimEvent::fromMap( const QMap<int, QString>& map )
 {
 
     // We just want to set the UID if it is really stored.
-    if ( !map[ OEvent::FUid ].isEmpty() )
-        setUid( map[ OEvent::FUid ].toInt() );
+    if ( !map[ OPimEvent::FUid ].isEmpty() )
+        setUid( map[ OPimEvent::FUid ].toInt() );
 
-    setCategories( idsFromString( map[ OEvent::FCategories ] ) );
-    setDescription( map[ OEvent::FDescription ] );
-    setLocation( map[ OEvent::FLocation ] );
+    setCategories( idsFromString( map[ OPimEvent::FCategories ] ) );
+    setDescription( map[ OPimEvent::FDescription ] );
+    setLocation( map[ OPimEvent::FLocation ] );
 
-    if ( map[ OEvent::FType ] == "AllDay" )
+    if ( map[ OPimEvent::FType ] == "AllDay" )
         setAllDay( true );
     else
         setAllDay( false );
 
     int alarmTime = -1;
-    if ( !map[ OEvent::FAlarm ].isEmpty() )
-        alarmTime = map[ OEvent::FAlarm ].toInt();
+    if ( !map[ OPimEvent::FAlarm ].isEmpty() )
+        alarmTime = map[ OPimEvent::FAlarm ].toInt();
 
-    int sound = ( ( map[ OEvent::FSound ] == "loud" ) ? OPimAlarm::Loud : OPimAlarm::Silent );
+    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[ OEvent::FTimeZone ].isEmpty() && ( map[ OEvent::FTimeZone ] != "None" ) )
+    if ( !map[ OPimEvent::FTimeZone ].isEmpty() && ( map[ OPimEvent::FTimeZone ] != "None" ) )
     {
-        setTimeZone( map[ OEvent::FTimeZone ] );
+        setTimeZone( map[ OPimEvent::FTimeZone ] );
     }
 
-    time_t start = ( time_t ) map[ OEvent::FStart ].toLong();
-    time_t end = ( time_t ) map[ OEvent::FEnd ].toLong();
+    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() )
     {
-        OTimeZone utc = OTimeZone::utc();
+        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 );
-        OTimeZone zone( timeZone().isEmpty() ? OTimeZone::current() : timeZone() );
+        OPimTimeZone zone( timeZone().isEmpty() ? OPimTimeZone::current() : timeZone() );
         QDateTime date = zone.toDateTime( start );
         qWarning( " Start is %s", date.toString().latin1() );
-        setStartDateTime( zone.toDateTime( date, OTimeZone::current() ) );
+        setStartDateTime( zone.toDateTime( date, OPimTimeZone::current() ) );
 
         date = zone.toDateTime( end );
-        setEndDateTime ( zone.toDateTime( date, OTimeZone::current() ) );
+        setEndDateTime ( zone.toDateTime( date, OPimTimeZone::current() ) );
     }
 
-    if ( !map[ OEvent::FRecParent ].isEmpty() )
-        setParent( map[ OEvent::FRecParent ].toInt() );
+    if ( !map[ OPimEvent::FRecParent ].isEmpty() )
+        setParent( map[ OPimEvent::FRecParent ].toInt() );
 
-    if ( !map[ OEvent::FRecChildren ].isEmpty() )
+    if ( !map[ OPimEvent::FRecChildren ].isEmpty() )
     {
-        QStringList list = QStringList::split( ' ', map[ OEvent::FRecChildren ] );
+        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 ORecur-Object using fromMap..
-    if ( !map[ OEvent::FRType ].isEmpty() )
+    // Fill recurrence stuff and put it directly into the OPimRecurrence-Object using fromMap..
+    if ( !map[ OPimEvent::FRType ].isEmpty() )
     {
         QMap<int, QString> recFields;
-        recFields.insert( ORecur::RType, map[ OEvent::FRType ] );
-        recFields.insert( ORecur::RWeekdays, map[ OEvent::FRWeekdays ] );
-        recFields.insert( ORecur::RPosition, map[ OEvent::FRPosition ] );
-        recFields.insert( ORecur::RFreq, map[ OEvent::FRFreq ] );
-        recFields.insert( ORecur::RHasEndDate, map[ OEvent::FRHasEndDate ] );
-        recFields.insert( ORecur::EndDate, map[ OEvent::FREndDate ] );
-        recFields.insert( ORecur::Created, map[ OEvent::FRCreated ] );
-        recFields.insert( ORecur::Exceptions, map[ OEvent::FRExceptions ] );
-        ORecur recur( 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 OEvent::parent() const
+int OPimEvent::parent() const
 {
     return data->parent;
 }
 
 
-void OEvent::setParent( int uid )
+void OPimEvent::setParent( int uid )
 {
     changeOrModify();
     data->parent = uid;
 }
 
 
-QArray<int> OEvent::children() const
+QArray<int> OPimEvent::children() const
 {
     if ( !data->child ) return QArray<int>();
     else
         return data->child->copy();
 }
 
 
-void OEvent::setChildren( const QArray<int>& arr )
+void OPimEvent::setChildren( const QArray<int>& arr )
 {
     changeOrModify();
     if ( data->child ) delete data->child;
 
     data->child = new QArray<int>( arr );
     data->child->detach();
 }
 
 
-void OEvent::addChild( int uid )
+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 OEvent::removeChild( int 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++ )
     {
@@ -759,34 +759,34 @@ void OEvent::removeChild( int uid )
     ( *data->child ) = newAr;
 }
 
 
 struct OEffectiveEvent::Data : public QShared
 {
     Data() : QShared()
     {}
-    OEvent event;
+    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 OEvent& ev, const QDate& startDate,
+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
@@ -839,17 +839,17 @@ void OEffectiveEvent::setStartTime( const QTime& ti )
 
 void OEffectiveEvent::setEndTime( const QTime& en )
 {
     changeOrModify();
     data->end = en;
 }
 
 
-void OEffectiveEvent::setEvent( const OEvent& ev )
+void OEffectiveEvent::setEvent( const OPimEvent& ev )
 {
     changeOrModify();
     data->event = ev;
 }
 
 
 void OEffectiveEvent::setDate( const QDate& da )
 {
@@ -885,17 +885,17 @@ QString OEffectiveEvent::location() const
 
 
 QString OEffectiveEvent::note() const
 {
     return data->event.note();
 }
 
 
-OEvent OEffectiveEvent::event() const
+OPimEvent OEffectiveEvent::event() const
 {
     return data->event;
 }
 
 
 QTime OEffectiveEvent::startTime() const
 {
     return data->start;
diff --git a/libopie2/opiepim/oevent.h b/libopie2/opiepim/core/opimevent.h
index dc5e4d6..949f263 100644
--- a/libopie2/opiepim/oevent.h
+++ b/libopie2/opiepim/core/opimevent.h
@@ -27,17 +27,17 @@
                              Boston, MA 02111-1307, USA.
 */
 // CONTAINS GPLed code of TT
 
 #ifndef OEVENT_H
 #define OEVENT_H
 
 /* OPIE */
-#include <opie2/otimezone.h>
+#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>
@@ -56,27 +56,27 @@ struct OCalendarHelper
     static int dayOfWeek( char day );
 
     /** returns the diff of month */
     static int monthDiff( const QDate& first, const QDate& second );
 
 };
 
 class OPimNotifyManager;
-class ORecur;
+class OPimRecurrence;
 
 /**
  * This is the container for all Events. It encapsules all
  * available information for a single Event
  * @short container for events.
  */
-class OEvent : public OPimRecord
+class OPimEvent : public OPimRecord
 {
   public:
-    typedef QValueList<OEvent> ValueList;
+    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,
@@ -96,44 +96,44 @@ class OEvent : public OPimRecord
         FEnd,
         FNote,
         FTimeZone,
         FRecParent,
         FRecChildren,
     };
 
     /**
-     * Start with an Empty OEvent. UID == 0 means that it is empty
+     * Start with an Empty OPimEvent. UID == 0 means that it is empty
      */
-    OEvent( int uid = 0 );
+    OPimEvent( int uid = 0 );
 
     /**
      * copy c'tor
      */
-    OEvent( const OEvent& );
+    OPimEvent( const OPimEvent& );
 
     /**
-     * Create OEvent, initialized by map
+     * Create OPimEvent, initialized by map
      * @see enum RecordFields
      */
-    OEvent( const QMap<int, QString> map );
-    ~OEvent();
-    OEvent &operator=( const OEvent& );
+    OPimEvent( const QMap<int, QString> map );
+    ~OPimEvent();
+    OPimEvent &operator=( const OPimEvent& );
 
     QString description() const;
     void setDescription( const QString& description );
 
     QString location() const;
     void setLocation( const QString& loc );
 
     bool hasNotifiers() const;
     OPimNotifyManager &notifiers() const;
 
-    ORecur recurrence() const;
-    void setRecurrence( const ORecur& );
+    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 );
@@ -164,17 +164,17 @@ class OEvent : public OPimRecord
     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 OEvent */
+    /** return the parent OPimEvent */
     int parent() const;
     void setParent( int uid );
 
 
     /* needed reimp */
     QString toRichText() const;
     QString toShortText() const;
     QString type() const;
@@ -183,22 +183,22 @@ class OEvent : public OPimRecord
     void fromMap( const QMap<int, QString>& map );
     QString recordField( int ) const;
 
     static int rtti();
 
     bool loadFromStream( QDataStream& );
     bool saveToStream( QDataStream& ) const;
 
-    /*    bool operator==( const OEvent& );
-        bool operator!=( const OEvent& );
-        bool operator<( const OEvent& );
-        bool operator<=( const OEvent& );
-        bool operator>( const OEvent& );
-        bool operator>=(const OEvent& );
+    /*    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;
@@ -221,32 +221,32 @@ class OEffectiveEvent
     // 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 OEvent& event, const QDate& startDate, Position pos = StartEnd );
+    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 OEvent& );
+    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;
-    OEvent event() const;
+    OPimEvent event() const;
     QTime startTime() const;
     QTime endTime() const;
     QDate date() const;
 
     /* return the length in hours */
     int length() const;
     int size() const;
 
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
@@ -133,17 +133,17 @@ class OPimAlarm : public OPimNotify
     Private* d;
 
 };
 
 /**
  * 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
 {
   public:
     /**
      * c'tor of a reminder
      * @param uid The uid of the Record inside the Datebook
      * @param start the StartDate invalid for all day...
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
@@ -25,17 +25,17 @@
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 #include "opimnotifymanager.h"
 
 /* OPIE */
-#include <opie2/oconversion.h>
+#include <opie2/opimdateconversion.h>
 
 /* QT */
 #include <qstringlist.h>
 
 namespace Opie
 {
 
 OPimNotifyManager::OPimNotifyManager( const Reminders& rem, const Alarms& al )
@@ -179,17 +179,17 @@ QString OPimNotifyManager::alarmsToString() const
     {
         QStringList als;
         OPimNotifyManager::Alarms::Iterator it = alarms.begin();
         for ( ; it != alarms.end(); ++it )
         {
             /* 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() )
                 + ":";
             }
         }
         // now write the list
         qWarning( "als: %s", als.join( "____________" ).latin1() );
         str = als.join( ";" );
@@ -222,18 +222,18 @@ QString OPimNotifyManager::remindersToString() const
 void OPimNotifyManager::alarmsFromString( const QString& str )
 {
     QStringList als = QStringList::split( ";", str );
     for ( QStringList::Iterator it = als.begin(); it != als.end(); ++it )
     {
         QStringList alarm = QStringList::split( ":", ( *it ), TRUE ); // allow empty
         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 );
     }
 }
 
 
 void OPimNotifyManager::remindersFromString( const QString& str )
 {
diff --git a/libopie2/opiepim/orecordlist.h b/libopie2/opiepim/core/opimrecordlist.h
index 1742dcc..b23138d 100644
--- a/libopie2/opiepim/orecordlist.h
+++ b/libopie2/opiepim/core/opimrecordlist.h
@@ -26,67 +26,67 @@
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 
 #ifndef ORECORDLIST_H
 #define ORECORDLIST_H
 
 /* OPIE */
-#include <opie2/otemplatebase.h>
+#include <opie2/opimtemplatebase.h>
 #include <opie2/opimrecord.h>
 
 /* QT */
 #include <qarray.h>
 
 namespace Opie
 {
 
-class ORecordListIteratorPrivate;
+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 ORecordList;
+template <class T> class OPimRecordList;
 template <class T = OPimRecord>
-class ORecordListIterator
+class OPimRecordListIterator
 {
-    friend class ORecordList<T>;
+    friend class OPimRecordList<T>;
 
   public:
     typedef OTemplateBase<T> Base;
 
     /**
      * The c'tor used internally from
-     * ORecordList
+     * OPimRecordList
      */
-    ORecordListIterator( const QArray<int>, const Base* );
+    OPimRecordListIterator( const QArray<int>, const Base* );
 
     /**
      * The standard c'tor
      */
-    ORecordListIterator();
-    ~ORecordListIterator();
+    OPimRecordListIterator();
+    ~OPimRecordListIterator();
 
-    ORecordListIterator( const ORecordListIterator& );
-    ORecordListIterator &operator=( const ORecordListIterator& );
+    OPimRecordListIterator( const OPimRecordListIterator& );
+    OPimRecordListIterator &operator=( const OPimRecordListIterator& );
 
     /**
      * a * operator ;)
      * use it like this T = (*it);
      */
     T operator*();
-    ORecordListIterator &operator++();
-    ORecordListIterator &operator--();
+    OPimRecordListIterator &operator++();
+    OPimRecordListIterator &operator--();
 
-    bool operator==( const ORecordListIterator& it );
-    bool operator!=( const ORecordListIterator& it );
+    bool operator==( const OPimRecordListIterator& it );
+    bool operator!=( const OPimRecordListIterator& it );
 
     /**
      * the current item
      */
     uint current() const;
 
     /**
      * the number of items
@@ -102,40 +102,40 @@ class ORecordListIterator
     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 */
-    ORecordListIteratorPrivate *d;
+    OPimRecordListIteratorPrivate *d;
 };
 
 
-class ORecordListPrivate;
+class OPimRecordListPrivate;
 /**
  * The recordlist used as a return type
  * from OPimAccessTemplate
  */
 template <class T = OPimRecord >
-class ORecordList
+class OPimRecordList
 {
   public:
     typedef OTemplateBase<T> Base;
-    typedef ORecordListIterator<T> Iterator;
+    typedef OPimRecordListIterator<T> Iterator;
 
     /**
      * c'tor
      */
-    ORecordList ()
+    OPimRecordList ()
     {}
-    ORecordList( const QArray<int>& ids,
+    OPimRecordList( const QArray<int>& ids,
                  const Base* );
-    ~ORecordList();
+    ~OPimRecordList();
 
     /**
      * the first iterator
      */
     Iterator begin();
 
     /**
      * the end
@@ -157,229 +157,229 @@ class ORecordList
 
     /*
       ConstIterator begin()const;
       ConstIterator end()const;
     */
   private:
     QArray<int> m_ids;
     const Base* m_acc;
-    ORecordListPrivate *d;
+    OPimRecordListPrivate *d;
 };
 
 
 /* ok now implement it  */
 template <class T>
-ORecordListIterator<T>::ORecordListIterator()
+OPimRecordListIterator<T>::OPimRecordListIterator()
 {
     m_current = 0;
     m_temp = 0l;
     m_end = true;
     m_record = T();
     /* forward */
     m_direction = TRUE;
 }
 
 
 template <class T>
-ORecordListIterator<T>::~ORecordListIterator()
+OPimRecordListIterator<T>::~OPimRecordListIterator()
 {
     /* nothing to delete */
 }
 
 
 template <class T>
-ORecordListIterator<T>::ORecordListIterator( const ORecordListIterator<T>& it )
+OPimRecordListIterator<T>::OPimRecordListIterator( const OPimRecordListIterator<T>& it )
 {
-    //    qWarning("ORecordListIterator copy c'tor");
+    //    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>
-ORecordListIterator<T> &ORecordListIterator<T>::operator=( const ORecordListIterator<T>& it )
+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 ORecordListIterator<T>::operator*()
+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>
-ORecordListIterator<T> &ORecordListIterator<T>::operator++()
+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>
-ORecordListIterator<T> &ORecordListIterator<T>::operator--()
+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 ORecordListIterator<T>::operator==( const ORecordListIterator<T>& it )
+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 ORecordListIterator<T>::operator!=( const ORecordListIterator<T>& it )
+bool OPimRecordListIterator<T>::operator!=( const OPimRecordListIterator<T>& it )
 {
     return !( *this == it );
 }
 
 
 template <class T>
-ORecordListIterator<T>::ORecordListIterator( const QArray<int> uids,
+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 ORecordListIterator<T>::current() const
+uint OPimRecordListIterator<T>::current() const
 {
     return m_current;
 }
 
 
 template <class T>
-void ORecordListIterator<T>::setCurrent( uint cur )
+void OPimRecordListIterator<T>::setCurrent( uint cur )
 {
     if ( cur < m_uids.count() )
     {
         m_end = false;
         m_current = cur;
     }
 }
 template <class T>
-uint ORecordListIterator<T>::count() const
+uint OPimRecordListIterator<T>::count() const
 {
     return m_uids.count();
 }
 
 
 template <class T>
-ORecordList<T>::ORecordList( const QArray<int>& ids,
+OPimRecordList<T>::OPimRecordList( const QArray<int>& ids,
                              const Base* acc )
         : m_ids( ids ), m_acc( acc )
 {}
 
 
 template <class T>
-ORecordList<T>::~ORecordList()
+OPimRecordList<T>::~OPimRecordList()
 {
     /* nothing to do here */
 }
 
 
 template <class T>
-typename ORecordList<T>::Iterator ORecordList<T>::begin()
+typename OPimRecordList<T>::Iterator OPimRecordList<T>::begin()
 {
     Iterator it( m_ids, m_acc );
     return it;
 }
 
 
 template <class T>
-typename ORecordList<T>::Iterator ORecordList<T>::end()
+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 ORecordList<T>::count() const
+uint OPimRecordList<T>::count() const
 {
     return m_ids.count();
 }
 
 
 template <class T>
-T ORecordList<T>::operator[] ( uint i )
+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 ORecordList<T>::uidAt( uint i )
+int OPimRecordList<T>::uidAt( uint i )
 {
     return m_ids[ i ];
 }
 
 
 template <class T>
-bool ORecordList<T>::remove( int uid )
+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 )
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
@@ -22,139 +22,139 @@
  -.   .:....=;==+<;          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 "orecur.h"
+#include "opimrecurrence.h"
 
 /* OPIE */
-#include <opie2/otimezone.h>
+#include <opie2/opimtimezone.h>
 #include <qpe/timeconversion.h>
 
 /* QT */
 #include <qshared.h>
 
 /* STD */
 #include <time.h>
 
 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;
         create = QDateTime::currentDateTime();
         hasEnd = FALSE;
         end = QDate::currentDate();
     }
     char days; // Q_UINT8 for 8 seven days;)
-    ORecur::RepeatType type;
+    OPimRecurrence::RepeatType type;
     int freq;
     int pos;
     bool hasEnd : 1;
     QDate end;
     QDateTime create;
     int rep;
     QString app;
     ExceptionList list;
     QDate start;
 };
 
 
-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;
     }
 }
 
 
-void ORecur::deref() {
+void OPimRecurrence::deref() {
     if ( data->deref() ) {
         delete data;
         data = 0l;
     }
 }
 
 
-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();
     deref();
     data = re.data;
 
     return *this;
 }
 
 
-bool ORecur::doesRecur()const {
+bool OPimRecurrence::doesRecur()const {
     return !( type() == NoRepeat );
 }
 
 
 /*
  * 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);
 
     QDate recur;
     if (!nextOcurrence( da, recur ) )
         return false;
 
     return (recur == 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) )
         stillLooking = p_nextOccurrence( next.addDays(1), next );
 
     return stillLooking;
 }
 
 
-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;
     int freq = frequency();
     int diff, diff2, a;
     int iday, imonth, iyear;
     int dayOfWeek = 0;
     int firstOfWeek = 0;
@@ -418,132 +418,132 @@ bool ORecur::p_nextOccurrence( const QDate& from, QDate& next ) {
                 return FALSE;
             return TRUE;
         default:
             return FALSE;
     }
 }
 
 
-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;
         d2->days = data->days;
         d2->type = data->type;
         d2->freq = data->freq;
         d2->pos  = data->pos;
         d2->hasEnd = data->hasEnd;
@@ -553,139 +553,139 @@ void ORecur::checkOrModify() {
         d2->app = data->app;
         d2->list = data->list;
         d2->start = data->start;
         data = d2;
     }
 }
 
 
-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:
             retString = "NoRepeat";
             break;
 
     }
 
     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;
 
     // save exceptions list here!!
     ExceptionList::ConstIterator it;
     ExceptionList list = data->list;
     QString exceptBuf;
     QDate date;
     for ( it = list.begin(); it != list.end(); ++it ) {
             date = (*it);
             if ( it != list.begin() ) exceptBuf += " ";
             
             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
@@ -38,34 +38,34 @@
 /* STD */
 #include <sys/types.h>
 
 namespace Opie {
 /**
  * Class to handle Recurrencies..
  */
 
-class ORecur {
+class OPimRecurrence {
 
   public:
     typedef QValueList<QDate> ExceptionList;
     enum RepeatType{ NoRepeat = -1, Daily, Weekly, MonthlyDay,
                      MonthlyDate, Yearly };
     enum Days { MON = 0x01, TUE = 0x02, WED = 0x04, THU = 0x08,
                 FRI = 0x10, SAT = 0x20, SUN = 0x40 };
     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 */
     bool doesRecur( const QDate& );
     RepeatType type()const;
     int frequency()const;
     int position()const;
     char days()const;
@@ -80,17 +80,17 @@ class ORecur {
     bool repeatOnWeekDay( int day )const;
 
     /**
      * FromWhereToStart is not included!!!
      */
     bool nextOcurrence( const QDate& FromWhereToStart, QDate &recurDate );
 
     /**
-     * The module this ORecur belongs to
+     * The module this OPimRecurrence belongs to
      */
     QString service()const;
 
     /*
      * reference to the exception list
      */
     ExceptionList &exceptions();
 
@@ -124,14 +124,14 @@ class ORecur {
 
     /* Converts rType to String */
     QString rTypeString() const;
     /* Returns a map to convert Stringname for RType to RepeatType */
     QMap<QString, RepeatType> rTypeValueConvertMap() const;
 
     class Data;
     Data* data;
-    class ORecurPrivate;
-    ORecurPrivate *d;
+    class OPimRecurrencePrivate;
+    OPimRecurrencePrivate *d;
 };
 
 }
 #endif
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
@@ -67,19 +67,19 @@ OPimRecord* OPimResolver::record( const QString& service, int uid ) {
 }
 OPimRecord* OPimResolver::record( const QString& service ) {
     return record( serviceId( service ) );
 }
 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;
     }
     /*
      * FIXME resolve externally
      */
     if (!rec ) {
         ;
@@ -206,22 +206,22 @@ bool OPimResolver::add( const QString& service,  const OPimRecord& rec) {
 }
 OPimBase* OPimResolver::backend( const QString& service ) {
     return backend( serviceId( service ) );
 }
 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;
     }
     // FIXME for 3rd party
     if (!base )
         ;
 
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
@@ -25,17 +25,17 @@
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 */
 #ifndef OPIMRESOLVER_H
 #define OPIMRESOLVER_H
 
 /* OPIE */
-#include <opie2/otemplatebase.h>
+#include <opie2/opimtemplatebase.h>
 
 /* QT */
 #include <qstring.h>
 #include <qvaluelist.h>
 
 namespace Opie {
 /**
  * OPimResolver is a MetaClass to access
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
@@ -22,17 +22,17 @@
  -.   .:....=;==+<;          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 "otimezone.h"
+#include "opimtimezone.h"
 
 /* STD */
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
 
 namespace Opie
 {
@@ -95,94 +95,94 @@ time_t to_Time_t( const QDateTime& utc, const QString& str )
 #endif
 
     return ti;
 }
 }
 
 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();
 }
 
 /*
  * 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 );
 }
 
 
 /*
  * 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() );
     return utcTime( utc, m_name );
 }
 
 
-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
@@ -39,22 +39,22 @@
 namespace Opie
 {
 /**
  * A very primitive class to convert time
  * from one timezone to another
  * 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;
 
     /**
      * converts the QDateTime to a DateTime
      * in the local timezone
      * if QDateTime is 25th Jan and takes place in Europe/Berlin at 12h
      * and the current timezone is Europe/London the returned
@@ -75,30 +75,30 @@ class OTimeZone {
     /**
      * converts the time_t to the time in the timezone
      */
     QDateTime toDateTime( time_t );
 
     /**
      * 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
      */
     time_t fromDateTime( const QDateTime& );
 
     /**
      * converts the datetime with timezone UTC
      */
     time_t fromUTCDateTime( const QDateTime& );
 
-    static OTimeZone current();
-    static OTimeZone utc();
+    static OPimTimeZone current();
+    static OPimTimeZone utc();
 
     QString timeZone() const;
     
  private:
     ZoneName m_name;
     class Private;
     Private* d;
 };
diff --git a/libopie2/opiepim/otodo.cpp b/libopie2/opiepim/core/opimtodo.cpp
index f534067..34df807 100644
--- a/libopie2/opiepim/otodo.cpp
+++ b/libopie2/opiepim/core/opimtodo.cpp
@@ -22,21 +22,21 @@
  -.   .:....=;==+<;          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 "otodo.h"
+#include "opimtodo.h"
 
 /* OPIE */
 #include <opie2/opimstate.h>
-#include <opie2/orecur.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>
@@ -44,117 +44,117 @@
 
 /* QT */
 #include <qobject.h>
 #include <qshared.h>
 
 namespace Opie
 {
 
-struct OTodo::OTodoData : public QShared
+struct OPimTodo::OPimTodoData : public QShared
 {
-    OTodoData() : QShared()
+    OPimTodoData() : QShared()
     {
         recur = 0;
         state = 0;
         maintainer = 0;
         notifiers = 0;
     };
-    ~OTodoData()
+    ~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;
-    ORecur *recur;
+    OPimRecurrence *recur;
     OPimMaintainer *maintainer;
     QDate start;
     QDate completed;
     OPimNotifyManager *notifiers;
 };
 
 
-OTodo::OTodo( const OTodo &event )
+OPimTodo::OPimTodo( const OPimTodo &event )
         : OPimRecord( event ), data( event.data )
 {
     data->ref();
     //    qWarning("ref up");
 }
 
 
-OTodo::~OTodo()
+OPimTodo::~OPimTodo()
 {
 
-    //    qWarning("~OTodo "  );
+    //    qWarning("~OPimTodo "  );
     if ( data->deref() )
     {
-        //        qWarning("OTodo::dereffing");
+        //        qWarning("OPimTodo::dereffing");
         delete data;
         data = 0l;
     }
 }
 
 
-OTodo::OTodo( bool completed, int priority,
+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("OTodoData " + summary);
+    //    qWarning("OPimTodoData " + summary);
     setCategories( category );
 
-    data = new OTodoData;
+    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 );
 }
 
 
-OTodo::OTodo( bool completed, int priority,
+OPimTodo::OPimTodo( bool completed, int priority,
               const QStringList &category,
               const QString& summary,
               const QString &description,
               ushort progress,
               bool hasDate, QDate date, int uid )
         : OPimRecord( uid )
 {
-    //    qWarning("OTodoData" + summary);
+    //    qWarning("OPimTodoData" + summary);
     setCategories( idsFromString( category.join( ";" ) ) );
 
-    data = new OTodoData;
+    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 OTodo::match( const QRegExp &regExp ) const
+bool OPimTodo::match( const QRegExp &regExp ) const
 {
     if ( QString::number( data->priority ).find( regExp ) != -1 )
     {
         setLastHitField( Priority );
         return true;
     }
     else if ( data->hasDate && data->date.toString().find( regExp ) != -1 )
     {
@@ -170,245 +170,245 @@ bool OTodo::match( const QRegExp &regExp ) const
     {
         setLastHitField( Summary );
         return true;
     }
     return false;
 }
 
 
-bool OTodo::isCompleted() const
+bool OPimTodo::isCompleted() const
 {
     return data->isCompleted;
 }
 
 
-bool OTodo::hasDueDate() const
+bool OPimTodo::hasDueDate() const
 {
     return data->hasDate;
 }
 
 
-bool OTodo::hasStartDate() const
+bool OPimTodo::hasStartDate() const
 {
     return data->start.isValid();
 }
 
 
-bool OTodo::hasCompletedDate() const
+bool OPimTodo::hasCompletedDate() const
 {
     return data->completed.isValid();
 }
 
 
-int OTodo::priority() const
+int OPimTodo::priority() const
 {
     return data->priority;
 }
 
 
-QString OTodo::summary() const
+QString OPimTodo::summary() const
 {
     return data->sum;
 }
 
 
-ushort OTodo::progress() const
+ushort OPimTodo::progress() const
 {
     return data->prog;
 }
 
 
-QDate OTodo::dueDate() const
+QDate OPimTodo::dueDate() const
 {
     return data->date;
 }
 
 
-QDate OTodo::startDate() const
+QDate OPimTodo::startDate() const
 {
     return data->start;
 }
 
 
-QDate OTodo::completedDate() const
+QDate OPimTodo::completedDate() const
 {
     return data->completed;
 }
 
 
-QString OTodo::description() const
+QString OPimTodo::description() const
 {
     return data->desc;
 }
 
 
-bool OTodo::hasState() const
+bool OPimTodo::hasState() const
 {
     if ( !data->state ) return false;
     return ( data->state->state() != OPimState::Undefined );
 }
 
 
-OPimState OTodo::state() const
+OPimState OPimTodo::state() const
 {
     if ( !data->state )
     {
         OPimState state;
         return state;
     }
 
     return ( *data->state );
 }
 
 
-bool OTodo::hasRecurrence() const
+bool OPimTodo::hasRecurrence() const
 {
     if ( !data->recur ) return false;
     return data->recur->doesRecur();
 }
 
 
-ORecur OTodo::recurrence() const
+OPimRecurrence OPimTodo::recurrence() const
 {
-    if ( !data->recur ) return ORecur();
+    if ( !data->recur ) return OPimRecurrence();
 
     return ( *data->recur );
 }
 
 
-bool OTodo::hasMaintainer() const
+bool OPimTodo::hasMaintainer() const
 {
     if ( !data->maintainer ) return false;
 
     return ( data->maintainer->mode() != OPimMaintainer::Undefined );
 }
 
 
-OPimMaintainer OTodo::maintainer() const
+OPimMaintainer OPimTodo::maintainer() const
 {
     if ( !data->maintainer ) return OPimMaintainer();
 
     return ( *data->maintainer );
 }
 
 
-void OTodo::setCompleted( bool completed )
+void OPimTodo::setCompleted( bool completed )
 {
     changeOrModify();
     data->isCompleted = completed;
 }
 
 
-void OTodo::setHasDueDate( bool hasDate )
+void OPimTodo::setHasDueDate( bool hasDate )
 {
     changeOrModify();
     data->hasDate = hasDate;
 }
 
 
-void OTodo::setDescription( const QString &desc )
+void OPimTodo::setDescription( const QString &desc )
 {
     //    qWarning( "desc " + desc );
     changeOrModify();
     data->desc = Qtopia::simplifyMultiLineSpace( desc );
 }
 
 
-void OTodo::setSummary( const QString& sum )
+void OPimTodo::setSummary( const QString& sum )
 {
     changeOrModify();
     data->sum = sum;
 }
 
 
-void OTodo::setPriority( int prio )
+void OPimTodo::setPriority( int prio )
 {
     changeOrModify();
     data->priority = prio;
 }
 
 
-void OTodo::setDueDate( const QDate& date )
+void OPimTodo::setDueDate( const QDate& date )
 {
     changeOrModify();
     data->date = date;
 }
 
 
-void OTodo::setStartDate( const QDate& date )
+void OPimTodo::setStartDate( const QDate& date )
 {
     changeOrModify();
     data->start = date;
 }
 
 
-void OTodo::setCompletedDate( const QDate& date )
+void OPimTodo::setCompletedDate( const QDate& date )
 {
     changeOrModify();
     data->completed = date;
 }
 
 
-void OTodo::setState( const OPimState& state )
+void OPimTodo::setState( const OPimState& state )
 {
     changeOrModify();
     if ( data->state )
         ( *data->state ) = state;
     else
         data->state = new OPimState( state );
 }
 
 
-void OTodo::setRecurrence( const ORecur& rec )
+void OPimTodo::setRecurrence( const OPimRecurrence& rec )
 {
     changeOrModify();
     if ( data->recur )
         ( *data->recur ) = rec;
     else
-        data->recur = new ORecur( rec );
+        data->recur = new OPimRecurrence( rec );
 }
 
 
-void OTodo::setMaintainer( const OPimMaintainer& pim )
+void OPimTodo::setMaintainer( const OPimMaintainer& pim )
 {
     changeOrModify();
 
     if ( data->maintainer )
         ( *data->maintainer ) = pim;
     else
         data->maintainer = new OPimMaintainer( pim );
 }
 
 
-bool OTodo::isOverdue( )
+bool OPimTodo::isOverdue( )
 {
     if ( data->hasDate && !data->isCompleted )
         return QDate::currentDate() > data->date;
     return false;
 }
 
 
-void OTodo::setProgress( ushort progress )
+void OPimTodo::setProgress( ushort progress )
 {
     changeOrModify();
     data->prog = progress;
 }
 
 
-QString OTodo::toShortText() const
+QString OPimTodo::toShortText() const
 {
     return summary();
 }
 
 
 /*!
   Returns a richt text string
 */
-QString OTodo::toRichText() const
+QString OPimTodo::toRichText() const
 {
     QString text;
     QStringList catlist;
 
     // summary
     text += "<b><h3><img src=\"todo/TodoList\"> ";
     if ( !summary().isEmpty() )
     {
@@ -468,41 +468,41 @@ QString OTodo::toRichText() const
     text += "<b>" + QObject::tr( "Category:" ) + "</b> ";
     text += categoryNames( "Todo List" ).join( ", " );
     text += "<br>";
 
     return text;
 }
 
 
-bool OTodo::hasNotifiers() const
+bool OPimTodo::hasNotifiers() const
 {
     if ( !data->notifiers ) return false;
     return !data->notifiers->isEmpty();
 }
 
 
-OPimNotifyManager& OTodo::notifiers()
+OPimNotifyManager& OPimTodo::notifiers()
 {
     if ( !data->notifiers )
         data->notifiers = new OPimNotifyManager;
     return ( *data->notifiers );
 }
 
 
-const OPimNotifyManager& OTodo::notifiers() const
+const OPimNotifyManager& OPimTodo::notifiers() const
 {
     if ( !data->notifiers )
         data->notifiers = new OPimNotifyManager;
 
     return ( *data->notifiers );
 }
 
 
-bool OTodo::operator<( const OTodo &toDoEvent ) const
+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();
@@ -511,17 +511,17 @@ bool OTodo::operator<( const OTodo &toDoEvent ) const
         {
             return dueDate() < toDoEvent.dueDate();
         }
     }
     return false;
 }
 
 
-bool OTodo::operator<=( const OTodo &toDoEvent ) const
+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();
@@ -530,17 +530,17 @@ bool OTodo::operator<=( const OTodo &toDoEvent ) const
         {
             return dueDate() <= toDoEvent.dueDate();
         }
     }
     return true;
 }
 
 
-bool OTodo::operator>( const OTodo &toDoEvent ) const
+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();
@@ -549,17 +549,17 @@ bool OTodo::operator>( const OTodo &toDoEvent ) const
         {
             return dueDate() > toDoEvent.dueDate();
         }
     }
     return false;
 }
 
 
-bool OTodo::operator>=( const OTodo &toDoEvent ) const
+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();
@@ -568,60 +568,60 @@ bool OTodo::operator>=( const OTodo &toDoEvent ) const
         {
             return dueDate() > toDoEvent.dueDate();
         }
     }
     return true;
 }
 
 
-bool OTodo::operator==( const OTodo &toDoEvent ) const
+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 OTodo::deref()
+void OPimTodo::deref()
 {
 
     //    qWarning("deref in ToDoEvent");
     if ( data->deref() )
     {
         //        qWarning("deleting");
         delete data;
         data = 0;
     }
 }
 
 
-OTodo &OTodo::operator=( const OTodo &item )
+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> OTodo::toMap() const
+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 );
@@ -641,72 +641,72 @@ QMap<int, QString> OTodo::toMap() const
 }
 
 
 /**
  *  change or modify looks at the ref count and either
  *  creates a new QShared Object or it can modify it
  * right in place
  */
-void OTodo::changeOrModify()
+void OPimTodo::changeOrModify()
 {
     if ( data->count != 1 )
     {
         qWarning( "changeOrModify" );
         data->deref();
-        OTodoData* d2 = new OTodoData();
+        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 OTodo::copy( OTodoData* src, OTodoData* dest )
+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 ORecur( *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 OTodo::type() const
+QString OPimTodo::type() const
 {
-    return QString::fromLatin1( "OTodo" );
+    return QString::fromLatin1( "OPimTodo" );
 }
 
 
-QString OTodo::recordField( int /*id*/ ) const
+QString OPimTodo::recordField( int /*id*/ ) const
 {
     return QString::null;
 }
 
 
-int OTodo::rtti()
+int OPimTodo::rtti()
 {
     return OPimResolver::TodoList;
 }
 
 }
diff --git a/libopie2/opiepim/otodo.h b/libopie2/opiepim/core/opimtodo.h
index 04dd269..5304180 100644
--- a/libopie2/opiepim/otodo.h
+++ b/libopie2/opiepim/core/opimtodo.h
@@ -42,23 +42,23 @@ _;:,     .>    :=|.         This program is free software; you can
 #include <qstringlist.h>
 #include <qdatetime.h>
 #include <qvaluelist.h>
 
 namespace Opie
 {
 
 class OPimState;
-class ORecur;
+class OPimRecurrence;
 class OPimMaintainer;
 class OPimNotifyManager;
-class OTodo : public OPimRecord
+class OPimTodo : public OPimRecord
 {
   public:
-    typedef QValueList<OTodo> ValueList;
+    typedef QValueList<OPimTodo> ValueList;
     enum RecordFields {
         Uid = Qtopia::UID_ID,
         Category = Qtopia::CATEGORY_ID,
         HasDate,
         Completed,
         Description,
         Summary,
         Priority,
@@ -85,41 +85,41 @@ class OTodo : public OPimRecord
        @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
     **/
-    OTodo( bool completed = false, int priority = Normal,
+    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*/ );
 
-    OTodo( bool completed, int priority,
+    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
      *
      */
-    OTodo( const OTodo & );
+    OPimTodo( const OPimTodo & );
 
     /**
      *destructor
      */
-    ~OTodo();
+    ~OPimTodo();
 
     /**
      * Is this event completed?
      */
     bool isCompleted() const;
 
     /**
      * Does this Event have a deadline
@@ -154,37 +154,37 @@ class OTodo : public OPimRecord
     QDate completedDate() const;
 
     /**
      * does it have a state?
      */
     bool hasState() const;
 
     /**
-     * What is the state of this OTodo?
+     * What is the state of this OPimTodo?
      */
     OPimState state() const;
 
     /**
      * has recurrence?
      */
     bool hasRecurrence() const;
 
     /**
      * the recurrance of this
      */
-    ORecur recurrence() const;
+    OPimRecurrence recurrence() const;
 
     /**
-     * does this OTodo have a maintainer?
+     * does this OPimTodo have a maintainer?
      */
     bool hasMaintainer() const;
 
     /**
-     * the Maintainer of this OTodo
+     * the Maintainer of this OPimTodo
      */
     OPimMaintainer maintainer() const;
 
     /**
      * The description of the todo
      */
     QString description() const;
 
@@ -261,17 +261,17 @@ class OTodo : public OPimRecord
      */
     void setStartDate( const QDate& date );
 
     /**
      * set the completed date
      */
     void setCompletedDate( const QDate& date );
 
-    void setRecurrence( const ORecur& );
+    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
      */
@@ -282,39 +282,39 @@ class OTodo : public OPimRecord
      */
     void setMaintainer( const OPimMaintainer& );
 
     bool isOverdue();
 
 
     virtual bool match( const QRegExp &r ) const;
 
-    bool operator<( const OTodo &toDoEvent ) const;
-    bool operator<=( const OTodo &toDoEvent ) const;
-    bool operator!=( const OTodo &toDoEvent ) const;
-    bool operator>( const OTodo &toDoEvent ) const;
-    bool operator>=( const OTodo &toDoEvent ) const;
-    bool operator==( const OTodo &toDoEvent ) const;
-    OTodo &operator=( const OTodo &toDoEvent );
+    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 OTodoPrivate;
-    struct OTodoData;
+    class OPimTodoPrivate;
+    struct OPimTodoData;
 
     void deref();
     inline void changeOrModify();
-    void copy( OTodoData* src, OTodoData* dest );
-    OTodoPrivate *d;
-    OTodoData *data;
+    void copy( OPimTodoData* src, OPimTodoData* dest );
+    OPimTodoPrivate *d;
+    OPimTodoData *data;
 
 };
 
 
-inline bool OTodo::operator!=( const OTodo &toDoEvent ) const
+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
@@ -30,64 +30,64 @@
 
 #include <qpe/alarmserver.h>
 
 // #include "otodoaccesssql.h"
 #include <opie2/otodoaccess.h>
 #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 );
 
     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
@@ -27,44 +27,44 @@
                              Boston, MA 02111-1307, USA.
 */
 #ifndef OPIE_TODO_ACCESS_H
 #define OPIE_TODO_ACCESS_H
 
 #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,
                      Priority,
                      Description,
                      Deadline };
     enum SortFilter{ Category =1,
                      OnlyOverDue= 2,
                      DoNotShowCompleted =4  };
     /**
      * if you use 0l
      * 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 */
     /**
      * include todos from start to end
      * includeNoDates whether or not to include
      * events with no dates
      */
@@ -76,61 +76,61 @@ public:
      * start
      * end date taken from the currentDate()
      */
     List effectiveToDos( const QDate& start,
                          bool includeNoDates = true );
 
 
     /**
-     * return overdue OTodos
+     * return overdue OPimTodos
      */
     List overDue();
 
     /**
      *
      */
     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
      */
     void removeAllCompleted();
 
     /**
      * request information about what a backend supports.
      * Supports in the sense of beeing able to store.
-     * This is related to the enum in OTodo
+     * This is related to the enum in OPimTodo
      *
      * @param backend Will be used in the future when we support multiple backend
      */
     QBitArray backendSupport( const QString& backend = QString::null )const;
 
     /**
      * see above but for a specefic attribute. This method was added for convience
      * @param attr The attribute to be queried for
      * @param backend Will be used in the future when we support multiple backends
      */
     bool backendSupports( int attr, const QString& backend = QString::null  )const;
 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;
 };
 
 }
 
 #endif
diff --git a/libopie2/opiepim/libopiepim2.control b/libopie2/opiepim/libopiepim2.control
index 1b419ad..b548b01 100644
--- a/libopie2/opiepim/libopiepim2.control
+++ b/libopie2/opiepim/libopiepim2.control
@@ -1,10 +1,10 @@
 Package: libopiepim2
 Files: lib/libopiepim2.so.*
 Priority: optional
 Section: opie/system
 Maintainer: Opie Team <opie@handhelds.org>
 Architecture: arm
-Version: 1.8.2-$SUB_VERSION.2
-Depends: libqpe1, libopiecore2 (1.8.2)
+Version: 1.8.3-$SUB_VERSION.2
+Depends: libqpe1, libopiecore2 (>=1.8.0)
 Provides: libopiepim2
 Description: Opie library 2.0 PIM
diff --git a/libopie2/opiepim/opiepim.pro b/libopie2/opiepim/opiepim.pro
index 82737f4..9a34e29 100644
--- a/libopie2/opiepim/opiepim.pro
+++ b/libopie2/opiepim/opiepim.pro
@@ -1,30 +1,27 @@
 TEMPLATE    = lib
 CONFIG      += qt warn_on debug
 DESTDIR     = $(OPIEDIR)/lib
-HEADERS     = ocontact.h ocontactfields.h opimrecord.h otodo.h opimnotify.h opimnotifymanager.h oevent.h
-              
-SOURCES     = ocontact.cpp ocontactfields.cpp opimrecord.cpp otodo.cpp opimnotify.cpp \
-	opimnotifymanager.cpp oevent.cpp
+HEADERS     = opimcontact.h opimcontactfields.h opimrecord.h opimtodo.h opimnotify.h \
+              opimnotifymanager.h opimevent.h
+
+SOURCES     = opimcontact.cpp opimcontactfields.cpp opimrecord.cpp opimtodo.cpp opimnotify.cpp \
+              opimnotifymanager.cpp opimevent.cpp
 INTERFACES  =
 TARGET      = opiepim2
-VERSION     = 1.8.2
+VERSION     = 1.8.3
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH  += $(OPIEDIR)/include
+LIBS        += -lopiecore2
 
 include ( core/core.pro )
 include ( core/backends/backends.pro )
 include ( ui/ui.pro )
 
-MOC_DIR     = moc
-OBJECTS_DIR = obj
-
-
 !contains( platform, x11 ) {
   include ( $(OPIEDIR)/include.pro )
 }
 
 contains( platform, x11 ) {
   LIBS        = -L$(OPIEDIR)/lib -Wl,-rpath,$(OPIEDIR)/lib 
 }
 
-LIBS += -lopiecore2