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, 76 insertions, 76 deletions

diff --git a/kresources/scalix/kcal/resourcescalix.cpp b/kresources/scalix/kcal/resourcescalix.cpp
index 9a8beeb9e..d2849e862 100644
--- a/kresources/scalix/kcal/resourcescalix.cpp
+++ b/kresources/scalix/kcal/resourcescalix.cpp
@@ -43,9 +43,9 @@
 #include <kmainwindow.h>
 #include <klocale.h>
 
-#include <qobject.h>
-#include <qtimer.h>
-#include <qapplication.h>
+#include <tqobject.h>
+#include <tqtimer.h>
+#include <tqapplication.h>
 
 #include <assert.h>
 
@@ -63,11 +63,11 @@ static const char* incidenceInlineMimeType = "text/calendar";
 
 ResourceScalix::ResourceScalix( const KConfig *config )
   : ResourceCalendar( config ), ResourceScalixBase( "ResourceScalix-libkcal" ),
-    mCalendar( QString::fromLatin1("UTC") ), mOpen( false )
+    mCalendar( TQString::fromLatin1("UTC") ), mOpen( false )
 {
   setType( "scalix" );
-  connect( &mResourceChangedTimer, SIGNAL( timeout() ),
-           this, SLOT( slotEmitResourceChanged() ) );
+  connect( &mResourceChangedTimer, TQT_SIGNAL( timeout() ),
+           this, TQT_SLOT( slotEmitResourceChanged() ) );
 }
 
 ResourceScalix::~ResourceScalix()
@@ -80,8 +80,8 @@ ResourceScalix::~ResourceScalix()
 }
 
 void ResourceScalix::loadSubResourceConfig( KConfig& config,
-                                           const QString& name,
-                                           const QString& label,
+                                           const TQString& name,
+                                           const TQString& label,
                                            bool writable,
                                            ResourceMap& subResource )
 {
@@ -94,11 +94,11 @@ bool ResourceScalix::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, map );
   return true;
@@ -142,7 +142,7 @@ void ResourceScalix::doClose()
   closeResource( config, mJournalSubResources );
 }
 
-bool ResourceScalix::loadSubResource( const QString& subResource,
+bool ResourceScalix::loadSubResource( const TQString& subResource,
                                      const char* mimetype )
 {
   int count = 0;
@@ -156,10 +156,10 @@ bool ResourceScalix::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" );
@@ -172,7 +172,7 @@ bool ResourceScalix::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 ResourceScalix::load()\n";
       if ( progressId )
@@ -182,7 +182,7 @@ bool ResourceScalix::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() );
       }
     }
@@ -238,7 +238,7 @@ bool ResourceScalix::loadAllJournals()
   return doLoadAll( mJournalSubResources, incidenceInlineMimeType );
 }
 
-void ResourceScalix::removeIncidences( const QCString& incidenceType )
+void ResourceScalix::removeIncidences( const TQCString& incidenceType )
 {
   Scalix::UidMap::Iterator mapIt = mUidMap.begin();
   while ( mapIt != mUidMap.end() )
@@ -250,7 +250,7 @@ void ResourceScalix::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 ) )
@@ -269,12 +269,12 @@ void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* incidencebase )
 {
   if ( incidencebase->isReadOnly() ) return; // Should not happen (TM)
   incidencebase->setSyncStatus( 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.
 
-  const QString uid = incidencebase->uid();
+  const TQString uid = incidencebase->uid();
 
   if ( mUidsPendingUpdate.contains( uid ) || mUidsPendingAdding.contains( uid ) ) {
     /* We are currently processing this event ( removing and readding or
@@ -284,7 +284,7 @@ void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* incidencebase )
     return;
   }
 
-  QString subResource;
+  TQString subResource;
   Q_UINT32 sernum = 0;
   if ( mUidMap.contains( uid ) ) {
     subResource = mUidMap[ uid ].resource();
@@ -294,7 +294,7 @@ void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* incidencebase )
   sendKMailUpdate( incidencebase, subResource, sernum );
 }
 
-void ResourceScalix::resolveConflict( KCal::Incidence* inc, const QString& subresource, Q_UINT32 sernum )
+void ResourceScalix::resolveConflict( KCal::Incidence* inc, const TQString& subresource, Q_UINT32 sernum )
 {
     if ( ! inc )
         return;
@@ -310,7 +310,7 @@ void ResourceScalix::resolveConflict( KCal::Incidence* inc, const QString& subre
         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() ;
@@ -343,8 +343,8 @@ void ResourceScalix::resolveConflict( KCal::Incidence* inc, const QString& subre
       mSilent = silent;
   }
 }
-void ResourceScalix::addIncidence( const char* mimetype, const QString& data,
-                                  const QString& subResource, Q_UINT32 sernum )
+void ResourceScalix::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
@@ -353,12 +353,12 @@ void ResourceScalix::addIncidence( const char* mimetype, const QString& data,
 }
 
 
-bool ResourceScalix::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const QString& subresource,
+bool ResourceScalix::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;
   if ( type == "Event" ) {
     mimetype = incidenceInlineMimeType;
     data = mFormat.createScheduleMessage( static_cast<KCal::Event *>(incidencebase),
@@ -385,7 +385,7 @@ bool ResourceScalix::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const
   else if ( type == "Todo" )
     customHeaders.insert( "X-Scalix-Class", "IPM.Task" );
 
-  QString subject = incidence->summary();
+  TQString subject = incidence->summary();
 
   // behold, sernum is an in-parameter
   const bool rc = kmailUpdate( subresource, sernum, data, mimetype, subject, customHeaders );
@@ -396,17 +396,17 @@ bool ResourceScalix::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const
   return rc;
 }
 
-bool ResourceScalix::addIncidence( KCal::Incidence* incidence, const QString& _subresource,
+bool ResourceScalix::addIncidence( KCal::Incidence* incidence, const TQString& _subresource,
                                   Q_UINT32 sernum )
 {
   Q_ASSERT( incidence );
   if ( !incidence ) return false;
-  const QString &uid = incidence->uid();
-  QString subResource = _subresource;
+  const TQString &uid = incidence->uid();
+  TQString subResource = _subresource;
 
   Scalix::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" )
@@ -507,14 +507,14 @@ bool ResourceScalix::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 );
 }
 
 bool ResourceScalix::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 ) {
@@ -535,7 +535,7 @@ bool ResourceScalix::deleteEvent( KCal::Event* event )
   return deleteIncidence( event );
 }
 
-KCal::Event* ResourceScalix::event( const QString& uid )
+KCal::Event* ResourceScalix::event( const TQString& uid )
 {
   return mCalendar.event(uid);
 }
@@ -545,20 +545,20 @@ KCal::Event::List ResourceScalix::rawEvents( EventSortField sortField, SortDirec
   return mCalendar.rawEvents( sortField, sortDirection );
 }
 
-KCal::Event::List ResourceScalix::rawEventsForDate( const QDate& date,
+KCal::Event::List ResourceScalix::rawEventsForDate( const TQDate& date,
                                                    EventSortField sortField,
                                                    SortDirection sortDirection )
 {
   return mCalendar.rawEventsForDate( date, sortField, sortDirection );
 }
 
-KCal::Event::List ResourceScalix::rawEventsForDate( const QDateTime& qdt )
+KCal::Event::List ResourceScalix::rawEventsForDate( const TQDateTime& qdt )
 {
   return mCalendar.rawEventsForDate( qdt );
 }
 
-KCal::Event::List ResourceScalix::rawEvents( const QDate& start,
-                                            const QDate& end,
+KCal::Event::List ResourceScalix::rawEvents( const TQDate& start,
+                                            const TQDate& end,
                                             bool inclusive )
 {
   return mCalendar.rawEvents( start, end, inclusive );
@@ -569,7 +569,7 @@ bool ResourceScalix::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 );
 }
 
 bool ResourceScalix::deleteTodo( KCal::Todo* todo )
@@ -577,7 +577,7 @@ bool ResourceScalix::deleteTodo( KCal::Todo* todo )
   return deleteIncidence( todo );
 }
 
-KCal::Todo* ResourceScalix::todo( const QString& uid )
+KCal::Todo* ResourceScalix::todo( const TQString& uid )
 {
   return mCalendar.todo( uid );
 }
@@ -587,7 +587,7 @@ KCal::Todo::List ResourceScalix::rawTodos( TodoSortField sortField, SortDirectio
   return mCalendar.rawTodos( sortField, sortDirection );
 }
 
-KCal::Todo::List ResourceScalix::rawTodosForDate( const QDate& date )
+KCal::Todo::List ResourceScalix::rawTodosForDate( const TQDate& date )
 {
   return mCalendar.rawTodosForDate( date );
 }
@@ -597,7 +597,7 @@ bool ResourceScalix::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 );
 }
 
 bool ResourceScalix::deleteJournal( KCal::Journal* journal )
@@ -605,7 +605,7 @@ bool ResourceScalix::deleteJournal( KCal::Journal* journal )
   return deleteIncidence( journal );
 }
 
-KCal::Journal* ResourceScalix::journal( const QString& uid )
+KCal::Journal* ResourceScalix::journal( const TQString& uid )
 {
   return mCalendar.journal(uid);
 }
@@ -615,33 +615,33 @@ KCal::Journal::List ResourceScalix::rawJournals( JournalSortField sortField, Sor
   return mCalendar.rawJournals( sortField, sortDirection );
 }
 
-KCal::Journal::List ResourceScalix::rawJournalsForDate( const QDate &date )
+KCal::Journal::List ResourceScalix::rawJournalsForDate( const TQDate &date )
 {
   return mCalendar.rawJournalsForDate( date );
 }
 
-KCal::Alarm::List ResourceScalix::alarms( const QDateTime& from,
-                                         const QDateTime& to )
+KCal::Alarm::List ResourceScalix::alarms( const TQDateTime& from,
+                                         const TQDateTime& to )
 {
   return mCalendar.alarms( from, to );
 }
 
-KCal::Alarm::List ResourceScalix::alarmsTo( const QDateTime& to )
+KCal::Alarm::List ResourceScalix::alarmsTo( const TQDateTime& to )
 {
   return mCalendar.alarmsTo(to);
 }
 
-void ResourceScalix::setTimeZoneId( const QString& tzid )
+void ResourceScalix::setTimeZoneId( const TQString& tzid )
 {
   mCalendar.setTimeZoneId( tzid );
   mFormat.setTimeZone( mCalendar.timeZoneId(), !mCalendar.isLocalTime() );
 }
 
-bool ResourceScalix::fromKMailAddIncidence( const QString& type,
-                                           const QString& subResource,
+bool ResourceScalix::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
@@ -660,9 +660,9 @@ bool ResourceScalix::fromKMailAddIncidence( const QString& type,
   return rc;
 }
 
-void ResourceScalix::fromKMailDelIncidence( const QString& type,
-                                           const QString& subResource,
-                                           const QString& uid )
+void ResourceScalix::fromKMailDelIncidence( const TQString& type,
+                                           const TQString& subResource,
+                                           const TQString& uid )
 {
   if ( type != kmailCalendarContentsType && type != kmailTodoContentsType
        && type != kmailJournalContentsType )
@@ -688,8 +688,8 @@ void ResourceScalix::fromKMailDelIncidence( const QString& type,
   }
 }
 
-void ResourceScalix::fromKMailRefresh( const QString& type,
-                                      const QString& /*subResource*/ )
+void ResourceScalix::fromKMailRefresh( const TQString& type,
+                                      const TQString& /*subResource*/ )
 {
   // TODO: Only load the specified subResource
   if ( type == "Calendar" )
@@ -703,9 +703,9 @@ void ResourceScalix::fromKMailRefresh( const QString& type,
   mResourceChangedTimer.changeInterval( 100 );
 }
 
-void ResourceScalix::fromKMailAddSubresource( const QString& type,
-                                             const QString& subResource,
-                                             const QString& label,
+void ResourceScalix::fromKMailAddSubresource( const TQString& type,
+                                             const TQString& subResource,
+                                             const TQString& label,
                                              bool writable )
 {
   ResourceMap* map = 0;
@@ -736,8 +736,8 @@ void ResourceScalix::fromKMailAddSubresource( const QString& type,
   emit signalSubresourceAdded( this, type, subResource, label );
 }
 
-void ResourceScalix::fromKMailDelSubresource( const QString& type,
-                                             const QString& subResource )
+void ResourceScalix::fromKMailDelSubresource( const TQString& type,
+                                             const TQString& subResource )
 {
   ResourceMap* map = subResourceMap( type );
   if ( !map ) // not ours
@@ -755,7 +755,7 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
 
   // Make a list of all uids to remove
   Scalix::UidMap::ConstIterator mapIt;
-  QStringList uids;
+  TQStringList uids;
   for ( mapIt = mUidMap.begin(); mapIt != mUidMap.end(); ++mapIt )
     if ( mapIt.data().resource() == subResource )
       // We have a match
@@ -764,7 +764,7 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
   // Finally delete all the incidences
   if ( !uids.isEmpty() ) {
     TemporarySilencer t( this );
-    QStringList::ConstIterator it;
+    TQStringList::ConstIterator it;
     for ( it = uids.begin(); it != uids.end(); ++it ) {
       KCal::Incidence* incidence = mCalendar.incidence( *it );
       if( incidence )
@@ -776,7 +776,7 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
   emit signalSubresourceRemoved( this, type, subResource );
 }
 
-QStringList ResourceScalix::subresources() const
+TQStringList ResourceScalix::subresources() const
 {
   // Workaround: The ResourceView in KOrganizer wants to know this
   // before it opens the resource :-( Make sure we are open
@@ -787,7 +787,7 @@ QStringList ResourceScalix::subresources() const
 }
 
 const QString
-ResourceScalix::labelForSubresource( const QString& subresource ) const
+ResourceScalix::labelForSubresource( const TQString& subresource ) const
 {
   if ( mEventSubResources.contains( subresource ) )
     return mEventSubResources[ subresource ].label();
@@ -798,28 +798,28 @@ ResourceScalix::labelForSubresource( const QString& subresource ) const
   return subresource;
 }
 
-QString ResourceScalix::subresourceIdentifier( Incidence *incidence )
+TQString ResourceScalix::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();
 }
 
-void ResourceScalix::fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                              const QString& type,
-                                              const QString& folder )
+void ResourceScalix::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 ResourceScalix::subresourceActive( const QString& subresource ) const
+bool ResourceScalix::subresourceActive( const TQString& subresource ) const
 {
   // Workaround: The ResourceView in KOrganizer wants to know this
   // before it opens the resource :-( Make sure we are open
@@ -838,7 +838,7 @@ bool ResourceScalix::subresourceActive( const QString& subresource ) const
   return true;
 }
 
-void ResourceScalix::setSubresourceActive( const QString &subresource, bool v )
+void ResourceScalix::setSubresourceActive( const TQString &subresource, bool v )
 {
   ResourceMap *map = 0;
 
@@ -869,7 +869,7 @@ KABC::Lock* ResourceScalix::lock()
 }
 
 
-Scalix::ResourceMap* ResourceScalix::subResourceMap( const QString& contentsType )
+Scalix::ResourceMap* ResourceScalix::subResourceMap( const TQString& contentsType )
 {
   if ( contentsType == kmailCalendarContentsType ) {
     return &mEventSubResources;