Trinity Qt initial conversion

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1157655 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 97 insertions, 97 deletions

diff --git a/kresources/kolab/kcal/resourcekolab.cpp b/kresources/kolab/kcal/resourcekolab.cpp
index 3c1c80e10..b61b12110 100644
--- a/kresources/kolab/kcal/resourcekolab.cpp
+++ b/kresources/kolab/kcal/resourcekolab.cpp
@@ -50,10 +50,10 @@
 #include <ktempfile.h>
 #include <kmdcodec.h>
 
-#include <qfile.h>
-#include <qobject.h>
-#include <qtimer.h>
-#include <qapplication.h>
+#include <tqfile.h>
+#include <tqobject.h>
+#include <tqtimer.h>
+#include <tqapplication.h>
 
 #include <assert.h>
 
@@ -71,12 +71,12 @@ static const char* incidenceInlineMimeType = "text/calendar";
 
 ResourceKolab::ResourceKolab( const KConfig *config )
   : ResourceCalendar( config ), ResourceKolabBase( "ResourceKolab-libkcal" ),
-    mCalendar( QString::fromLatin1("UTC") ), mOpen( false ),mResourceChangedTimer( 0,
+    mCalendar( TQString::fromLatin1("UTC") ), mOpen( false ),mResourceChangedTimer( 0,
         "mResourceChangedTimer" )
 {
   setType( "imap" );
-  connect( &mResourceChangedTimer, SIGNAL( timeout() ),
-           this, SLOT( slotEmitResourceChanged() ) );
+  connect( &mResourceChangedTimer, TQT_SIGNAL( timeout() ),
+           this, TQT_SLOT( slotEmitResourceChanged() ) );
 }
 
 ResourceKolab::~ResourceKolab()
@@ -89,8 +89,8 @@ ResourceKolab::~ResourceKolab()
 }
 
 void ResourceKolab::loadSubResourceConfig( KConfig& config,
-                                           const QString& name,
-                                           const QString& label,
+                                           const TQString& name,
+                                           const TQString& label,
                                            bool writable,
                                            bool alarmRelevant,
                                            ResourceMap& subResource )
@@ -105,11 +105,11 @@ bool ResourceKolab::openResource( KConfig& config, const char* contentType,
                                   ResourceMap& map )
 {
   // Read the subresource entries from KMail
-  QValueList<KMailICalIface::SubResource> subResources;
+  TQValueList<KMailICalIface::SubResource> subResources;
   if ( !kmailSubresources( subResources, contentType ) )
     return false;
   map.clear();
-  QValueList<KMailICalIface::SubResource>::ConstIterator it;
+  TQValueList<KMailICalIface::SubResource>::ConstIterator it;
   for ( it = subResources.begin(); it != subResources.end(); ++it )
     loadSubResourceConfig( config, (*it).location, (*it).label, (*it).writable,
                            (*it).alarmRelevant, map );
@@ -154,7 +154,7 @@ void ResourceKolab::doClose()
   closeResource( config, mJournalSubResources );
 }
 
-bool ResourceKolab::loadSubResource( const QString& subResource,
+bool ResourceKolab::loadSubResource( const TQString& subResource,
                                      const char* mimetype )
 {
   int count = 0;
@@ -168,10 +168,10 @@ bool ResourceKolab::loadSubResource( const QString& subResource,
 
   const int nbMessages = 200; // read 200 mails at a time (see kabc resource)
 
-  const QString labelTxt = !strcmp(mimetype, "application/x-vnd.kolab.task") ? i18n( "Loading tasks..." )
+  const TQString labelTxt = !strcmp(mimetype, "application/x-vnd.kolab.task") ? i18n( "Loading tasks..." )
                            : !strcmp(mimetype, "application/x-vnd.kolab.journal") ? i18n( "Loading journals..." )
                            : i18n( "Loading events..." );
-  const bool useProgress = qApp && qApp->type() != QApplication::Tty && count > mProgressDialogIncidenceLimit;
+  const bool useProgress = qApp && qApp->type() != TQApplication::Tty && count > mProgressDialogIncidenceLimit;
   if ( useProgress )
     (void)::Observer::self(); // ensure kio_uiserver is running
   UIServer_stub uiserver( "kio_uiserver", "UIServer" );
@@ -184,7 +184,7 @@ bool ResourceKolab::loadSubResource( const QString& subResource,
   }
 
   for ( int startIndex = 0; startIndex < count; startIndex += nbMessages ) {
-    QMap<Q_UINT32, QString> lst;
+    TQMap<Q_UINT32, TQString> lst;
     if ( !kmailIncidences( lst, mimetype, subResource, startIndex, nbMessages ) ) {
       kdError(5650) << "Communication problem in ResourceKolab::load()\n";
       if ( progressId )
@@ -194,7 +194,7 @@ bool ResourceKolab::loadSubResource( const QString& subResource,
 
     { // for RAII scoping below
       TemporarySilencer t( this );
-      for( QMap<Q_UINT32, QString>::ConstIterator it = lst.begin(); it != lst.end(); ++it ) {
+      for( TQMap<Q_UINT32, TQString>::ConstIterator it = lst.begin(); it != lst.end(); ++it ) {
         addIncidence( mimetype, it.data(), subResource, it.key() );
       }
     }
@@ -266,7 +266,7 @@ bool ResourceKolab::loadAllJournals()
   return kolabStyle && icalStyle;
 }
 
-void ResourceKolab::removeIncidences( const QCString& incidenceType )
+void ResourceKolab::removeIncidences( const TQCString& incidenceType )
 {
   Kolab::UidMap::Iterator mapIt = mUidMap.begin();
   while ( mapIt != mUidMap.end() )
@@ -278,7 +278,7 @@ void ResourceKolab::removeIncidences( const QCString& incidenceType )
 
     // A  faster but hackish way would probably be to check the type of the resource,
     // like mEventSubResources.find( it.data().resource() ) != mEventSubResources.end() ?
-    const QString& uid = it.key();
+    const TQString& uid = it.key();
     if ( incidenceType == "Event" && mCalendar.event( uid ) )
       mUidMap.remove( it );
     else if ( incidenceType == "Todo" && mCalendar.todo( uid ) )
@@ -299,7 +299,7 @@ bool ResourceKolab::doSave()
 }
 void ResourceKolab::incidenceUpdatedSilent( KCal::IncidenceBase* incidencebase)
 {
- const QString uid = incidencebase->uid();
+ const TQString uid = incidencebase->uid();
   //kdDebug() << k_funcinfo << uid << endl;
 
   if ( mUidsPendingUpdate.contains( uid ) || mUidsPendingAdding.contains( uid ) ) {
@@ -310,7 +310,7 @@ void ResourceKolab::incidenceUpdatedSilent( KCal::IncidenceBase* incidencebase)
     return;
   }
 
-  QString subResource;
+  TQString subResource;
   Q_UINT32 sernum = 0;
   if ( mUidMap.contains( uid ) ) {
     subResource = mUidMap[ uid ].resource();
@@ -324,7 +324,7 @@ void ResourceKolab::incidenceUpdated( KCal::IncidenceBase* incidencebase )
 {
   if ( incidencebase->isReadOnly() ) return;
   incidencebase->setSyncStatusSilent( KCal::Event::SYNCMOD );
-  incidencebase->setLastModified( QDateTime::currentDateTime() );
+  incidencebase->setLastModified( TQDateTime::currentDateTime() );
   // we should probably update the revision number here,
   // or internally in the Event itself when certain things change.
   // need to verify with ical documentation.
@@ -332,7 +332,7 @@ void ResourceKolab::incidenceUpdated( KCal::IncidenceBase* incidencebase )
 
 }
 
-void ResourceKolab::resolveConflict( KCal::Incidence* inc, const QString& subresource, Q_UINT32 sernum )
+void ResourceKolab::resolveConflict( KCal::Incidence* inc, const TQString& subresource, Q_UINT32 sernum )
 {
     if ( ! inc )
         return;
@@ -341,7 +341,7 @@ void ResourceKolab::resolveConflict( KCal::Incidence* inc, const QString& subres
         delete inc;
         return;
     }
-    const QString origUid = inc->uid();
+    const TQString origUid = inc->uid();
     Incidence* local = mCalendar.incidence( origUid );
     Incidence* localIncidence = 0;
     Incidence* addedIncidence = 0;
@@ -354,7 +354,7 @@ void ResourceKolab::resolveConflict( KCal::Incidence* inc, const QString& subres
         KIncidenceChooser* ch = new KIncidenceChooser();
         ch->setIncidence( local ,inc );
         if ( KIncidenceChooser::chooseMode == KIncidenceChooser::ask ) {
-          connect ( this, SIGNAL( useGlobalMode() ), ch, SLOT (  useGlobalMode() ) );
+          connect ( this, TQT_SIGNAL( useGlobalMode() ), ch, TQT_SLOT (  useGlobalMode() ) );
           if ( ch->exec() )
             if ( KIncidenceChooser::chooseMode != KIncidenceChooser::ask )
               emit useGlobalMode() ;
@@ -390,8 +390,8 @@ void ResourceKolab::resolveConflict( KCal::Incidence* inc, const QString& subres
     }
     mSilent = silent;
 }
-void ResourceKolab::addIncidence( const char* mimetype, const QString& data,
-                                  const QString& subResource, Q_UINT32 sernum )
+void ResourceKolab::addIncidence( const char* mimetype, const TQString& data,
+                                  const TQString& subResource, Q_UINT32 sernum )
 {
   // This uses pointer comparison, so it only works if we use the static
   // objects defined in the top of the file
@@ -408,12 +408,12 @@ void ResourceKolab::addIncidence( const char* mimetype, const QString& data,
 }
 
 
-bool ResourceKolab::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const QString& subresource,
+bool ResourceKolab::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const TQString& subresource,
                                      Q_UINT32 sernum )
 {
-  const QString& type = incidencebase->type();
+  const TQString& type = incidencebase->type();
   const char* mimetype = 0;
-  QString data;
+  TQString data;
   bool isXMLStorageFormat = kmailStorageFormat( subresource ) == KMailICalIface::StorageXML;
   if ( type == "Event" ) {
     if( isXMLStorageFormat ) {
@@ -454,11 +454,11 @@ bool ResourceKolab::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const Q
   KCal::Incidence* incidence = static_cast<KCal::Incidence *>( incidencebase );
 
   KCal::Attachment::List atts = incidence->attachments();
-  QStringList attURLs, attMimeTypes, attNames;
-  QValueList<KTempFile*> tmpFiles;
+  TQStringList attURLs, attMimeTypes, attNames;
+  TQValueList<KTempFile*> tmpFiles;
   for ( KCal::Attachment::List::ConstIterator it = atts.constBegin(); it != atts.constEnd(); ++it ) {
     KTempFile* tempFile = new KTempFile;
-    QCString decoded = KCodecs::base64Decode( QCString( (*it)->data() ) );
+    TQCString decoded = KCodecs::base64Decode( TQCString( (*it)->data() ) );
     tempFile->file()->writeBlock( decoded.data(), decoded.length() );
     tempFile->close();
     KURL url;
@@ -467,9 +467,9 @@ bool ResourceKolab::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const Q
     attMimeTypes.append( (*it)->mimeType() );
     attNames.append( (*it)->label() );
   }
-  QStringList deletedAtts;
+  TQStringList deletedAtts;
   if ( kmailListAttachments( deletedAtts, subresource, sernum ) ) {
-    for ( QStringList::ConstIterator it = attNames.constBegin(); it != attNames.constEnd(); ++it ) {
+    for ( TQStringList::ConstIterator it = attNames.constBegin(); it != attNames.constEnd(); ++it ) {
       deletedAtts.remove( *it );
     }
   }
@@ -477,7 +477,7 @@ bool ResourceKolab::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const Q
   if ( incidence->schedulingID() != incidence->uid() )
     customHeaders.insert( "X-Kolab-SchedulingID", incidence->schedulingID() );
 
-  QString subject = incidencebase->uid();
+  TQString subject = incidencebase->uid();
   if ( !isXMLStorageFormat ) subject.prepend( "iCal " ); // conform to the old style
 
   // behold, sernum is an in-parameter
@@ -487,7 +487,7 @@ bool ResourceKolab::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const Q
     mUidMap[ incidencebase->uid() ].setSerialNumber( sernum );
   }
 
-  for( QValueList<KTempFile *>::Iterator it = tmpFiles.begin(); it != tmpFiles.end(); ++it ) {
+  for( TQValueList<KTempFile *>::Iterator it = tmpFiles.begin(); it != tmpFiles.end(); ++it ) {
     (*it)->setAutoDelete( true );
     delete (*it);
   }
@@ -495,17 +495,17 @@ bool ResourceKolab::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const Q
   return rc;
 }
 
-bool ResourceKolab::addIncidence( KCal::Incidence* incidence, const QString& _subresource,
+bool ResourceKolab::addIncidence( KCal::Incidence* incidence, const TQString& _subresource,
                                   Q_UINT32 sernum )
 {
   Q_ASSERT( incidence );
   if ( !incidence ) return false;
-  QString uid = incidence->uid();
-  QString subResource = _subresource;
+  TQString uid = incidence->uid();
+  TQString subResource = _subresource;
 
   Kolab::ResourceMap *map = &mEventSubResources; // don't use a ref here!
 
-  const QString& type = incidence->type();
+  const TQString& type = incidence->type();
   if ( type == "Event" )
     map = &mEventSubResources;
   else if ( type == "Todo" )
@@ -520,7 +520,7 @@ bool ResourceKolab::addIncidence( KCal::Incidence* incidence, const QString& _su
     bool newIncidence = _subresource.isEmpty();
     if ( newIncidence ) {
       // Add a description of the incidence
-      QString text = "<b><font size=\"+1\">";
+      TQString text = "<b><font size=\"+1\">";
       if ( incidence->type() == "Event" )
         text += i18n( "Choose the folder where you want to store this event" );
       else if ( incidence->type() == "Todo" )
@@ -642,10 +642,10 @@ bool ResourceKolab::addEvent( KCal::Event* event )
   if ( mUidMap.contains( event->uid() ) )
     return true; //noop
   else
-    return addIncidence( event, QString::null, 0 );
+    return addIncidence( event, TQString::null, 0 );
 }
 
-void ResourceKolab::addEvent( const QString& xml, const QString& subresource,
+void ResourceKolab::addEvent( const TQString& xml, const TQString& subresource,
                               Q_UINT32 sernum )
 {
   KCal::Event* event = Kolab::Event::xmlToEvent( xml, mCalendar.timeZoneId(), this, subresource, sernum );
@@ -659,7 +659,7 @@ bool ResourceKolab::deleteIncidence( KCal::Incidence* incidence )
 {
   if ( incidence->isReadOnly() ) return false;
 
-  const QString uid = incidence->uid();
+  const TQString uid = incidence->uid();
   if( !mUidMap.contains( uid ) ) return false; // Odd
   /* The user told us to delete, tell KMail */
   if ( !mSilent ) {
@@ -680,7 +680,7 @@ bool ResourceKolab::deleteEvent( KCal::Event* event )
   return deleteIncidence( event );
 }
 
-KCal::Event* ResourceKolab::event( const QString& uid )
+KCal::Event* ResourceKolab::event( const TQString& uid )
 {
   return mCalendar.event(uid);
 }
@@ -690,20 +690,20 @@ KCal::Event::List ResourceKolab::rawEvents( EventSortField sortField, SortDirect
   return mCalendar.rawEvents( sortField, sortDirection );
 }
 
-KCal::Event::List ResourceKolab::rawEventsForDate( const QDate& date,
+KCal::Event::List ResourceKolab::rawEventsForDate( const TQDate& date,
                                                    EventSortField sortField,
                                                    SortDirection sortDirection )
 {
   return mCalendar.rawEventsForDate( date, sortField, sortDirection );
 }
 
-KCal::Event::List ResourceKolab::rawEventsForDate( const QDateTime& qdt )
+KCal::Event::List ResourceKolab::rawEventsForDate( const TQDateTime& qdt )
 {
   return mCalendar.rawEventsForDate( qdt );
 }
 
-KCal::Event::List ResourceKolab::rawEvents( const QDate& start,
-                                            const QDate& end,
+KCal::Event::List ResourceKolab::rawEvents( const TQDate& start,
+                                            const TQDate& end,
                                             bool inclusive )
 {
   return mCalendar.rawEvents( start, end, inclusive );
@@ -714,10 +714,10 @@ bool ResourceKolab::addTodo( KCal::Todo* todo )
   if ( mUidMap.contains( todo->uid() ) )
     return true; //noop
   else
-    return addIncidence( todo, QString::null, 0 );
+    return addIncidence( todo, TQString::null, 0 );
 }
 
-void ResourceKolab::addTodo( const QString& xml, const QString& subresource,
+void ResourceKolab::addTodo( const TQString& xml, const TQString& subresource,
                              Q_UINT32 sernum )
 {
   KCal::Todo* todo = Kolab::Task::xmlToTask( xml, mCalendar.timeZoneId(), this, subresource, sernum );
@@ -731,7 +731,7 @@ bool ResourceKolab::deleteTodo( KCal::Todo* todo )
   return deleteIncidence( todo );
 }
 
-KCal::Todo* ResourceKolab::todo( const QString& uid )
+KCal::Todo* ResourceKolab::todo( const TQString& uid )
 {
   return mCalendar.todo( uid );
 }
@@ -741,7 +741,7 @@ KCal::Todo::List ResourceKolab::rawTodos( TodoSortField sortField, SortDirection
   return mCalendar.rawTodos( sortField, sortDirection );
 }
 
-KCal::Todo::List ResourceKolab::rawTodosForDate( const QDate& date )
+KCal::Todo::List ResourceKolab::rawTodosForDate( const TQDate& date )
 {
   return mCalendar.rawTodosForDate( date );
 }
@@ -751,10 +751,10 @@ bool ResourceKolab::addJournal( KCal::Journal* journal )
   if ( mUidMap.contains( journal->uid() ) )
     return true; //noop
   else
-    return addIncidence( journal, QString::null, 0 );
+    return addIncidence( journal, TQString::null, 0 );
 }
 
-void ResourceKolab::addJournal( const QString& xml, const QString& subresource,
+void ResourceKolab::addJournal( const TQString& xml, const TQString& subresource,
                                 Q_UINT32 sernum )
 {
   KCal::Journal* journal =
@@ -770,7 +770,7 @@ bool ResourceKolab::deleteJournal( KCal::Journal* journal )
   return deleteIncidence( journal );
 }
 
-KCal::Journal* ResourceKolab::journal( const QString& uid )
+KCal::Journal* ResourceKolab::journal( const TQString& uid )
 {
   return mCalendar.journal(uid);
 }
@@ -780,7 +780,7 @@ KCal::Journal::List ResourceKolab::rawJournals( JournalSortField sortField, Sort
   return mCalendar.rawJournals( sortField, sortDirection );
 }
 
-KCal::Journal::List ResourceKolab::rawJournalsForDate( const QDate &date )
+KCal::Journal::List ResourceKolab::rawJournalsForDate( const TQDate &date )
 {
   return mCalendar.rawJournalsForDate( date );
 }
@@ -792,9 +792,9 @@ KCal::Alarm::List ResourceKolab::relevantAlarms( const KCal::Alarm::List &alarms
   while ( it != alarms.end() ) {
     KCal::Alarm *a = (*it);
     ++it;
-    const QString &uid = a->parent()->uid();
+    const TQString &uid = a->parent()->uid();
      if ( mUidMap.contains( uid ) ) {
-       const QString &sr = mUidMap[ uid ].resource();
+       const TQString &sr = mUidMap[ uid ].resource();
        Kolab::SubResource *subResource = 0;
        if ( mEventSubResources.contains( sr ) )
           subResource = &( mEventSubResources[ sr ] );
@@ -813,28 +813,28 @@ KCal::Alarm::List ResourceKolab::relevantAlarms( const KCal::Alarm::List &alarms
 
 
 
-KCal::Alarm::List ResourceKolab::alarms( const QDateTime& from,
-                                         const QDateTime& to )
+KCal::Alarm::List ResourceKolab::alarms( const TQDateTime& from,
+                                         const TQDateTime& to )
 {
   return relevantAlarms( mCalendar.alarms( from, to ) );
 }
 
-KCal::Alarm::List ResourceKolab::alarmsTo( const QDateTime& to )
+KCal::Alarm::List ResourceKolab::alarmsTo( const TQDateTime& to )
 {
   return relevantAlarms( mCalendar.alarmsTo(to) );
 }
 
-void ResourceKolab::setTimeZoneId( const QString& tzid )
+void ResourceKolab::setTimeZoneId( const TQString& tzid )
 {
   mCalendar.setTimeZoneId( tzid );
   mFormat.setTimeZone( mCalendar.timeZoneId(), !mCalendar.isLocalTime() );
 }
 
-bool ResourceKolab::fromKMailAddIncidence( const QString& type,
-                                           const QString& subResource,
+bool ResourceKolab::fromKMailAddIncidence( const TQString& type,
+                                           const TQString& subResource,
                                            Q_UINT32 sernum,
                                            int format,
-                                           const QString& data )
+                                           const TQString& data )
 {
   bool rc = true;
   TemporarySilencer t( this ); // RAII
@@ -864,9 +864,9 @@ bool ResourceKolab::fromKMailAddIncidence( const QString& type,
   return rc;
 }
 
-void ResourceKolab::fromKMailDelIncidence( const QString& type,
-                                           const QString& subResource,
-                                           const QString& uid )
+void ResourceKolab::fromKMailDelIncidence( const TQString& type,
+                                           const TQString& subResource,
+                                           const TQString& uid )
 {
   if ( type != kmailCalendarContentsType && type != kmailTodoContentsType
        && type != kmailJournalContentsType )
@@ -892,8 +892,8 @@ void ResourceKolab::fromKMailDelIncidence( const QString& type,
   }
 }
 
-void ResourceKolab::fromKMailRefresh( const QString& type,
-                                      const QString& /*subResource*/ )
+void ResourceKolab::fromKMailRefresh( const TQString& type,
+                                      const TQString& /*subResource*/ )
 {
   // TODO: Only load the specified subResource
   if ( type == "Calendar" )
@@ -907,9 +907,9 @@ void ResourceKolab::fromKMailRefresh( const QString& type,
   mResourceChangedTimer.changeInterval( 100 );
 }
 
-void ResourceKolab::fromKMailAddSubresource( const QString& type,
-                                             const QString& subResource,
-                                             const QString& label,
+void ResourceKolab::fromKMailAddSubresource( const TQString& type,
+                                             const TQString& subResource,
+                                             const TQString& label,
                                              bool writable, bool alarmRelevant )
 {
   ResourceMap* map = 0;
@@ -941,8 +941,8 @@ void ResourceKolab::fromKMailAddSubresource( const QString& type,
   emit signalSubresourceAdded( this, type, subResource, label );
 }
 
-void ResourceKolab::fromKMailDelSubresource( const QString& type,
-                                             const QString& subResource )
+void ResourceKolab::fromKMailDelSubresource( const TQString& type,
+                                             const TQString& subResource )
 {
   ResourceMap* map = subResourceMap( type );
   if ( !map ) // not ours
@@ -963,7 +963,7 @@ void ResourceKolab::fromKMailDelSubresource( const QString& type,
   emit signalSubresourceRemoved( this, type, subResource );
 }
 
-QStringList ResourceKolab::subresources() const
+TQStringList ResourceKolab::subresources() const
 {
   // Workaround: The ResourceView in KOrganizer wants to know this
   // before it opens the resource :-( Make sure we are open
@@ -974,7 +974,7 @@ QStringList ResourceKolab::subresources() const
 }
 
 const QString
-ResourceKolab::labelForSubresource( const QString& subresource ) const
+ResourceKolab::labelForSubresource( const TQString& subresource ) const
 {
   if ( mEventSubResources.contains( subresource ) )
     return mEventSubResources[ subresource ].label();
@@ -985,16 +985,16 @@ ResourceKolab::labelForSubresource( const QString& subresource ) const
   return subresource;
 }
 
-void ResourceKolab::fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                              const QString& type,
-                                              const QString& folder )
+void ResourceKolab::fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                              const TQString& type,
+                                              const TQString& folder )
 {
   TemporarySilencer t( this );
-  for( QMap<Q_UINT32, QString>::ConstIterator it = map.begin(); it != map.end(); ++it )
+  for( TQMap<Q_UINT32, TQString>::ConstIterator it = map.begin(); it != map.end(); ++it )
     addIncidence( type.latin1(), it.data(), folder, it.key() );
 }
 
-bool ResourceKolab::subresourceActive( const QString& subresource ) const
+bool ResourceKolab::subresourceActive( const TQString& subresource ) const
 {
   // Workaround: The ResourceView in KOrganizer wants to know this
   // before it opens the resource :-( Make sure we are open
@@ -1013,7 +1013,7 @@ bool ResourceKolab::subresourceActive( const QString& subresource ) const
   return true;
 }
 
-void ResourceKolab::setSubresourceActive( const QString &subresource, bool v )
+void ResourceKolab::setSubresourceActive( const TQString &subresource, bool v )
 {
   ResourceMap *map = 0;
   const char* mimeType = 0;
@@ -1054,7 +1054,7 @@ KABC::Lock* ResourceKolab::lock()
 }
 
 
-Kolab::ResourceMap* ResourceKolab::subResourceMap( const QString& contentsType )
+Kolab::ResourceMap* ResourceKolab::subResourceMap( const TQString& contentsType )
 {
   if ( contentsType == kmailCalendarContentsType ) {
     return &mEventSubResources;
@@ -1069,10 +1069,10 @@ Kolab::ResourceMap* ResourceKolab::subResourceMap( const QString& contentsType )
 
 
 /*virtual*/
-bool ResourceKolab::addSubresource( const QString& resource, const QString& parent )
+bool ResourceKolab::addSubresource( const TQString& resource, const TQString& parent )
 {
    kdDebug(5650) << "KCal Kolab resource - adding subresource: " << resource << endl;
-   QString contentsType = kmailCalendarContentsType;
+   TQString contentsType = kmailCalendarContentsType;
    if ( !parent.isEmpty() ) {
      if ( mEventSubResources.contains( parent ) )
        contentsType = kmailCalendarContentsType;
@@ -1081,10 +1081,10 @@ bool ResourceKolab::addSubresource( const QString& resource, const QString& pare
      else if ( mJournalSubResources.contains( parent ) )
        contentsType = kmailJournalContentsType;
    } else {
-     QStringList contentTypeChoices;
+     TQStringList contentTypeChoices;
      contentTypeChoices << i18n("Calendar") << i18n("Tasks") << i18n("Journals");
-     const QString caption = i18n("Which kind of subresource should this be?");
-     const QString choice = KInputDialog::getItem( caption, QString::null, contentTypeChoices );
+     const TQString caption = i18n("Which kind of subresource should this be?");
+     const TQString choice = KInputDialog::getItem( caption, TQString::null, contentTypeChoices );
      if ( choice == contentTypeChoices[0] )
        contentsType = kmailCalendarContentsType;
      else if ( choice == contentTypeChoices[1] )
@@ -1097,27 +1097,27 @@ bool ResourceKolab::addSubresource( const QString& resource, const QString& pare
 }
 
 /*virtual*/
-bool ResourceKolab::removeSubresource( const QString& resource )
+bool ResourceKolab::removeSubresource( const TQString& resource )
 {
    kdDebug(5650) << "KCal Kolab resource - removing subresource: " << resource << endl;
    return kmailRemoveSubresource( resource );
 }
 
 /*virtual*/
-QString ResourceKolab::subresourceIdentifier( Incidence *incidence )
+TQString ResourceKolab::subresourceIdentifier( Incidence *incidence )
 {
-  QString uid = incidence->uid();
+  TQString uid = incidence->uid();
   if ( mUidMap.contains( uid ) )
     return mUidMap[ uid ].resource();
   else
     if ( mNewIncidencesMap.contains( uid ) )
       return mNewIncidencesMap[ uid ];
     else
-      return QString();
+      return TQString();
 }
 
 
-bool ResourceKolab::unloadSubResource( const QString& subResource )
+bool ResourceKolab::unloadSubResource( const TQString& subResource )
 {
     const bool silent = mSilent;
     mSilent = true;
@@ -1139,7 +1139,7 @@ bool ResourceKolab::unloadSubResource( const QString& subResource )
     return true;
 }
 
-QString ResourceKolab::subresourceType( const QString &resource )
+TQString ResourceKolab::subresourceType( const TQString &resource )
 {
   if ( mEventSubResources.contains( resource ) )
     return "event";
@@ -1147,7 +1147,7 @@ QString ResourceKolab::subresourceType( const QString &resource )
     return "todo";
   if ( mJournalSubResources.contains( resource ) )
     return "journal";
-  return QString();
+  return TQString();
 }
 
 #include "resourcekolab.moc"