13 files changed, 167 insertions, 152 deletions

diff --git a/microkde/kdecore/kcatalogue.cpp b/microkde/kdecore/kcatalogue.cpp
index 97ac326..1600b08 100644
--- a/microkde/kdecore/kcatalogue.cpp
+++ b/microkde/kdecore/kcatalogue.cpp
@@ -11,24 +11,26 @@
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 
 //US #include <config.h>
 
 #include <qfile.h>
+//Added by qt3to4:
+#include <Q3CString>
 
 #include <kdebug.h>
 
 #include "kcatalogue.h"
 
 char *k_nl_find_msg(struct kde_loaded_l10nfile *domain_file,
 	       const char *msgid);
 void k_nl_unload_domain (struct loaded_domain *domain);
 
 #ifndef KDE_USE_FINAL // with --enable-final, we're getting this from libintl.cpp
 struct kde_loaded_l10nfile
 {
@@ -79,25 +81,25 @@ KCatalogue::~KCatalogue()
 QString KCatalogue::name() const
 {
   return d->name;
 }
 
 void KCatalogue::setFileName( const QString & fileName )
 {
   // nothing to do if the file name is already the same
   if ( this->fileName() == fileName ) return;
 
   doUnload();
 
-  QCString newFileName = QFile::encodeName( fileName );
+  Q3CString newFileName = QFile::encodeName( fileName );
 
   if ( !fileName.isEmpty() )
     {
       // set file name
       char *filename = new char[ newFileName.length() + 1 ];
       ::qstrcpy( filename, newFileName );
       d->domain.filename = filename;
     }
 }
 
 QString KCatalogue::fileName() const
 {
diff --git a/microkde/kdecore/kconfigbase.h b/microkde/kdecore/kconfigbase.h
index 7e56d11..1ef6a04 100644
--- a/microkde/kdecore/kconfigbase.h
+++ b/microkde/kdecore/kconfigbase.h
@@ -17,24 +17,26 @@
    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.
 */
 
 // $Id$
 
 #ifndef _KCONFIGBASE_H
 #define _KCONFIGBASE_H
 
 #include "kconfig.h"
+//Added by qt3to4:
+#include <Q3CString>
 
 /**
   * Helper class to facilitate working with @ref KConfig / @ref KSimpleConfig
   * groups.
   *
   * Careful programmers always set the group of a
   * @ref KConfig @ref KSimpleConfig object to the group they want to read from
   * and set it back to the old one of afterwards. This is usually
   * written as:
   * <pre>
   *
   * QString oldgroup config->group();
@@ -73,25 +75,25 @@ public:
    *               KConfigGroupSaver works on.
    * @param group  The new group that the config object should switch to.
    */
   KConfigGroupSaver( KConfig* config, QString group )
       /* KDE 4 : make the second parameter const QString & */
       : _config(config), _oldgroup(config->group())
         { _config->setGroup( group ); }
 
   KConfigGroupSaver( KConfig* config, const char *group )
       : _config(config), _oldgroup(config->group())
         { _config->setGroup( group ); }
 
-  KConfigGroupSaver( KConfig* config, const QCString &group )
+  KConfigGroupSaver( KConfig* config, const Q3CString &group )
       : _config(config), _oldgroup(config->group())
         { _config->setGroup( group ); }
 
   ~KConfigGroupSaver() { _config->setGroup( _oldgroup ); }
 
     KConfig* config() { return _config; };
 
 private:
   KConfig* _config;
   QString _oldgroup;
 
   KConfigGroupSaver(const KConfigGroupSaver&);
diff --git a/microkde/kdecore/klibloader.cpp b/microkde/kdecore/klibloader.cpp
index 6d0475a..0b54eb6 100644
--- a/microkde/kdecore/klibloader.cpp
+++ b/microkde/kdecore/klibloader.cpp
@@ -11,50 +11,53 @@
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 //US #include <config.h>
 #include <qclipboard.h>
 #include <qfile.h>
 #include <qtimer.h>
-#include <qobjectdict.h>
-#include <qwidgetlist.h>
+#include <q3objectdict.h>
 #include <qwidget.h>
+#include <qwidget.h>
+//Added by qt3to4:
+#include <Q3CString>
+#include <Q3PtrList>
 
 #include "kapplication.h"
 #include "klibloader.h"
 #include "kstandarddirs.h"
 #include "kdebug.h"
 #include "klocale.h"
 
 /*US
 #ifndef NDEBUG
 #include "ltdl.h"
 #endif
 */
 
 //US do everything through qlibrary
 #ifndef DESKTOP_VERSION
 #include <qpe/qpeapplication.h>
 #include <qtopia/qlibrary.h>
 #else
 #include <qlibrary.h> 
 #endif
 
 
-template class QAsciiDict<KLibrary>;
+template class Q3AsciiDict<KLibrary>;
 
 #include <stdlib.h> //getenv
 
 /*US
 #if HAVE_DLFCN_H
 #  include <dlfcn.h>
 #endif
  
 #ifdef RTLD_GLOBAL
 #  define LT_GLOBAL             RTLD_GLOBAL
 #else
 #  ifdef DL_GLOBAL
@@ -111,25 +114,25 @@ KLibrary::KLibrary( const QString& libname, const QString& filename, QLibrary* h
     m_timer = 0;
 }
 
 KLibrary::~KLibrary()
 {
 //    kdDebug(150) << "Deleting KLibrary " << this << "  " << m_libname << endl;
     if ( m_timer && m_timer->isActive() )
 	m_timer->stop();
 
     // If any object is remaining, delete
     if ( m_objs.count() > 0 )
 	{
-	    QPtrListIterator<QObject> it( m_objs );
+	    Q3PtrListIterator<QObject> it( m_objs );
 	    for ( ; it.current() ; ++it )
 		{
 		    kdDebug(150) << "Factory still has object " << it.current() << " " << it.current()->name () << " Library = " << m_libname << endl;
 		    disconnect( it.current(), SIGNAL( destroyed() ),
 				this, SLOT( slotObjectDestroyed() ) );
 		}
 	    m_objs.setAutoDelete(true);
 	    m_objs.clear();
 	}
 
     if ( m_factory ) {
 //	kdDebug(150) << " ... deleting the factory " << m_factory << endl;
@@ -143,25 +146,25 @@ QString KLibrary::name() const
 }
 
 QString KLibrary::fileName() const
 {
     return m_filename;
 }
 
 KLibFactory* KLibrary::factory()
 {
     if ( m_factory )
         return m_factory;
 
-        QCString symname;
+        Q3CString symname;
         symname.sprintf("init_%s", name().latin1() );
     
         void* sym = symbol( symname );
         if ( !sym )
         {
             qDebug("KLibrary: The library %s does not offer an %s function", name().latin1(), symname.data());
 #ifndef NDEBUG
 //US            qDebug("KLibrary: errorcode: %s", lt_dlerror());
 #endif            
             kdWarning(150) << "KLibrary: The library " << name().latin1() << " does not offer an init_" << name().latin1() << " function" << endl;
             return 0;
     }
@@ -296,26 +299,26 @@ KLibWrapPrivate::KLibWrapPrivate(KLibrary *l, QLibrary* h)
 //US use instead:
     if (h->resolve("__kde_do_not_unload") != 0) {
 //        kdDebug(150) << "Will not unload " << name << endl;
         unload_mode = DONT_UNLOAD;
     } else if (h->resolve("__kde_do_unload") != 0) {
         unload_mode = UNLOAD;
     }
 }
 
 class KLibLoaderPrivate
 {
 public:
-    QPtrList<KLibWrapPrivate> loaded_stack;
-    QPtrList<KLibWrapPrivate> pending_close;
+    Q3PtrList<KLibWrapPrivate> loaded_stack;
+    Q3PtrList<KLibWrapPrivate> pending_close;
     enum {UNKNOWN, UNLOAD, DONT_UNLOAD} unload_mode;
 
     QString errorMessage;
 };
 
 KLibLoader* KLibLoader::s_self = 0;
 
 KLibLoader* KLibLoader::self()
 {
     if ( !s_self )
         s_self = new KLibLoader;
     return s_self;
@@ -339,41 +342,41 @@ KLibLoader::KLibLoader( QObject* parent, const char* name )
     d->unload_mode = KLibLoaderPrivate::UNKNOWN;
     if (getenv("KDE_NOUNLOAD") != 0)
         d->unload_mode = KLibLoaderPrivate::DONT_UNLOAD;
     else if (getenv("KDE_DOUNLOAD") != 0)
         d->unload_mode = KLibLoaderPrivate::UNLOAD;
     d->loaded_stack.setAutoDelete( true );
 }
 
 KLibLoader::~KLibLoader()
 {
 //    kdDebug(150) << "Deleting KLibLoader " << this << "  " << name() << endl;
 
-    QAsciiDictIterator<KLibWrapPrivate> it( m_libs );
+    Q3AsciiDictIterator<KLibWrapPrivate> it( m_libs );
     for (; it.current(); ++it )
     {
       kdDebug(150) << "The KLibLoader contains the library " << it.current()->name
         << " (" << it.current()->lib << ")" << endl;
       d->pending_close.append(it.current());
     }
 
     close_pending(0);
 
     delete d;
 }
 
 //static
 QString KLibLoader::findLibrary( const char * name/*US , const KInstance * instance*/ )
 {
-    QCString libname( name );
+    Q3CString libname( name );
 
     // only append ".la" if there is no extension
     // this allows to load non-libtool libraries as well
     // (mhk, 20000228)
     int pos = libname.findRev('/');
     if (pos < 0)
       pos = 0;
 /*US      
     if (libname.find('.', pos) < 0) {
       libname += ".la";
     }
 */    
@@ -412,25 +415,25 @@ QString KLibLoader::findLibrary( const char * name/*US , const KInstance * insta
 //US        libfile = instance->dirs()->findResource( "lib", libname );
         libfile = KGlobal::dirs()->findResource( "lib", libname );
         //qDebug("libfile2 = %s ",libfile.latin1() );
 #ifndef NDEBUG
         if ( !libfile.isEmpty() && libname.left(3) == "lib" ) // don't warn for kdeinit modules
           kdDebug(150) << "library " << libname << " not found under 'module' but under 'lib'" << endl;
 #endif
       }
       if ( libfile.isEmpty() )
       {
 #ifndef NDEBUG
         kdDebug(150) << "library=" << libname << ": No file names " << libname.data() << " found in paths." << endl;
-        self()->d->errorMessage = i18n("Library files for \"%1\" not found in paths").arg(libname); 
+        self()->d->errorMessage = i18n("Library files for \"%1\" not found in paths").arg(QString(libname)); 
             
         qDebug("KLibLoader::library could not find library: %s", libname.data());
 #endif
             
       }
       else
             self()->d->errorMessage = QString::null;
     }
 
     //qDebug("return libfile = %s ",libfile.latin1() );
     return libfile;
 }
@@ -460,25 +463,25 @@ KLibrary* KLibLoader::library( const char *name )
     if (!name)
         return 0;
 
     KLibWrapPrivate* wrap = m_libs[name];
     if (wrap) {
       /* Nothing to do to load the library.  */
       wrap->ref_count++;
       return wrap->lib;
     }
 
     /* Test if this library was loaded at some time, but got
        unloaded meanwhile, whithout being dlclose()'ed.  */
-    QPtrListIterator<KLibWrapPrivate> it(d->loaded_stack);
+    Q3PtrListIterator<KLibWrapPrivate> it(d->loaded_stack);
     for (; it.current(); ++it) {
       if (it.current()->name == name)
         wrap = it.current();
     }
 
     if (wrap) {
       d->pending_close.removeRef(wrap);
       if (!wrap->lib) {
         /* This lib only was in loaded_stack, but not in m_libs.  */
         wrap->lib = new KLibrary( name, wrap->filename, wrap->handle );
       }
       wrap->ref_count++;
@@ -541,44 +544,44 @@ KLibFactory* KLibLoader::factory( const char* name )
 {
     KLibrary* lib = library( name );
     if ( !lib )
         return 0;
 
     return lib->factory();
 }
 
 void KLibLoader::slotLibraryDestroyed()
 {
   const KLibrary *lib = static_cast<const KLibrary *>( sender() );
 
-  QAsciiDictIterator<KLibWrapPrivate> it( m_libs );
+  Q3AsciiDictIterator<KLibWrapPrivate> it( m_libs );
   for (; it.current(); ++it )
     if ( it.current()->lib == lib )
     {
       KLibWrapPrivate *wrap = it.current();
       wrap->lib = 0;  /* the KLibrary object is already away */
       m_libs.remove( it.currentKey() );
       close_pending( wrap );
       return;
     }
 }
 
 void KLibLoader::close_pending(KLibWrapPrivate *wrap)
 {
   if (wrap && !d->pending_close.containsRef( wrap ))
     d->pending_close.append( wrap );
 
   /* First delete all KLibrary objects in pending_close, but _don't_ unload
      the DSO behind it.  */
-  QPtrListIterator<KLibWrapPrivate> it(d->pending_close);
+  Q3PtrListIterator<KLibWrapPrivate> it(d->pending_close);
   for (; it.current(); ++it) {
     wrap = it.current();
     if (wrap->lib) {
       disconnect( wrap->lib, SIGNAL( destroyed() ),
                   this, SLOT( slotLibraryDestroyed() ) );
       delete wrap->lib;
       wrap->lib = 0;
     }
   }
 
   if (d->unload_mode == KLibLoaderPrivate::DONT_UNLOAD) return;
 
diff --git a/microkde/kdecore/klibloader.h b/microkde/kdecore/klibloader.h
index ed57109..53d146e 100644
--- a/microkde/kdecore/klibloader.h
+++ b/microkde/kdecore/klibloader.h
@@ -12,26 +12,26 @@
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 #ifndef KLIBLOADER_H
 #define KLIBLOADER_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qstringlist.h>
-#include <qasciidict.h>
-#include <qptrlist.h>
+#include <q3asciidict.h>
+#include <q3ptrlist.h>
 #include <kglobal.h>
 
 #include <stdlib.h> // For backwards compatibility
 
 class KInstance;
 class QTimer;
 class KLibrary;
 class KLibFactory;
 class KLibFactoryPrivate;
 class KLibLoaderPrivate;
 class KLibraryPrivate;
 
@@ -43,25 +43,25 @@ class QLibrary;
 /**
  * @short Represents a dynamically loaded library.
  *
  * KLibrary allows you to look up symbols of the shared library.
  * Use @ref KLibLoader to create a new instance of KLibrary.
  *
  * @see KLibLoader
  * @author Torben Weis <weis@kde.org>
  */
 class KLibrary : public QObject
 {
     friend class KLibLoader;
-    friend class QAsciiDict<KLibrary>;
+    friend class Q3AsciiDict<KLibrary>;
 
     Q_OBJECT
 public:
     /**
      * @internal
      * Don't create KLibrary objects on your own. Instead use @ref KLibLoader.
      */
 //US    KLibrary( const QString& libname, const QString& filename, void * handle );
     KLibrary( const QString& libname, const QString& filename, QLibrary* handle );
 
     /**
      * Returns the name of the library.
@@ -118,25 +118,25 @@ private slots:
 private:
     /**
      * @internal
      * Don't destruct KLibrary objects yourself. Instead use @ref unload() instead.
      */
     ~KLibrary();
 
     QString m_libname;
     QString m_filename;
     KLibFactory* m_factory;
 //US    void * m_handle;
     QLibrary* m_handle;
-    QPtrList<QObject> m_objs;
+    Q3PtrList<QObject> m_objs;
     QTimer *m_timer;
     KLibraryPrivate *d;
 };
 
 class KLibWrapPrivate;
 
 /**
  * The KLibLoader allows you to load libraries dynamically at runtime.
  * Dependent libraries are loaded automatically.
  *
  * KLibLoader follows the singleton pattern. You can not create multiple
  * instances. Use @ref self() to get a pointer to the loader.
@@ -278,25 +278,25 @@ public:
      *             ".la" will be appended.
      * @param instance a KInstance used to get the standard paths
      */
     static QString findLibrary( const char * name/*US , const KInstance * instance = KGlobal::instance()*/ );
 
 protected:
     KLibLoader( QObject* parent = 0, const char* name = 0 );
 
 private slots:
     void slotLibraryDestroyed();
 private:
     void close_pending( KLibWrapPrivate * );
-    QAsciiDict<KLibWrapPrivate> m_libs;
+    Q3AsciiDict<KLibWrapPrivate> m_libs;
 
     static KLibLoader* s_self;
 
 protected:
     virtual void virtual_hook( int id, void* data );
 private:
     KLibLoaderPrivate *d;
 };
 
 /**
  * If you develop a library that is to be loaded dynamically at runtime, then
  * you should return a pointer to your factory. The K_EXPORT_COMPONENT_FACTORY
diff --git a/microkde/kdecore/klocale.cpp b/microkde/kdecore/klocale.cpp
index 1d8ae9f..dd310fa 100644
--- a/microkde/kdecore/klocale.cpp
+++ b/microkde/kdecore/klocale.cpp
@@ -1,27 +1,28 @@
 #include <qregexp.h>
 #include <qapplication.h>
+#include <QDesktopWidget>
 
 #include "kdebug.h"
 #include "kcalendarsystemgregorian.h"
 
 #include "klocale.h"
 
 #include <qstringlist.h>
 
 //#define COLLECT_TRANSLATION
 
 
-QDict<QString> *mLocaleDict = 0;
-void setLocaleDict( QDict<QString> * dict )
+Q3Dict<QString> *mLocaleDict = 0;
+void setLocaleDict( Q3Dict<QString> * dict )
 {
     mLocaleDict = dict;
 
 }
 
 #ifdef COLLECT_TRANSLATION 
 
 QStringList missingTrans;
 QStringList existingTrans1;
 QStringList existingTrans2;
 
 void addMissing(const char *text) 
@@ -36,53 +37,53 @@ void addExist(const char *text,QString trans )
 {
     //return;
     QString mis ( text );
     if ( !existingTrans1.contains( mis  ) ) {
         existingTrans1.append(mis);
         existingTrans2.append(trans);
 
     }
 
 }
 
 #include <qfile.h>
-#include <qtextstream.h>
+#include <q3textstream.h>
 #include <qtextcodec.h>
 #endif
 void dumpMissing()
 {
 #ifdef COLLECT_TRANSLATION 
     QString fileName = "/tmp/usernewtrans.txt";
     QFile file( fileName );
-    if (!file.open( IO_WriteOnly ) ) {
+    if (!file.open( QIODevice::WriteOnly ) ) {
         return ;
     } 
-    QTextStream ts( &file );
+    Q3TextStream ts( &file );
     ts.setCodec( QTextCodec::codecForName("utf8") );
 
     int i;
     for ( i = 0; i< missingTrans.count(); ++i ) {
 
         QString text = missingTrans[i].replace( QRegExp("\n"),"\\n" );
         ts << "{ \""<<text<< "\",\""<< text <<"\" },\n";
 
     }
     file.close();
     {
     QString fileName = "/tmp/usertrans.txt";
     QFile file( fileName );
-    if (!file.open( IO_WriteOnly ) ) {
+    if (!file.open( QIODevice::WriteOnly ) ) {
         return ;
     } 
-    QTextStream ts( &file );
+    Q3TextStream ts( &file );
     ts.setCodec( QTextCodec::codecForName("utf8") );
 
     int i;
     for ( i = 0; i< existingTrans1.count(); ++i ) {
 
         QString text = existingTrans1[i].replace( QRegExp("\n"),"\\n" );
         QString text2 = existingTrans2[i].replace( QRegExp("\n"),"\\n" );
         ts << "{ \""<<text<< "\",\""<< text2 <<"\" },\n";
 
     }
     file.close();
     }
@@ -458,25 +459,25 @@ QString KLocale::formatDate(const QDate &pDate, bool shortFormat, IntDateFormat
 
 QString KLocale::formatDateTime(const QDateTime &pDateTime,
 				bool shortFormat,
 				bool includeSeconds,
 				IntDateFormat intIntDateFormat) const
 {
   QString format("%1 %2");
 
   if ( intIntDateFormat == Default )
     format = "%1 %2";
   else if ( intIntDateFormat == Format1 )
     format = "%1 %2";
-  else  if ( intIntDateFormat == ISODate )
+  else  if ( intIntDateFormat == Qt::ISODate )
     format = "%1T%2";
 
   QString res = format.arg(formatDate( pDateTime.date(), shortFormat, intIntDateFormat ))
                .arg(formatTime( pDateTime.time(), includeSeconds , intIntDateFormat ));
 
   //qDebug("KLocale::formatDateTime transformed %s, into %s", pDateTime.toString().latin1(), res.latin1() );
 
   return res;
 }
 
 QString KLocale::formatDateTime(const QDateTime &pDateTime, IntDateFormat intIntDateFormat) const
 {
@@ -518,25 +519,25 @@ QDate KLocale::readDate(const QString &intstr, const QString &fmt, bool* ok) con
         if (c.isSpace())
           strpos++;
         else if (c != str.at(strpos++))
           goto error;
         continue;
       }
 
       // remove space at the begining
       if (str.length() > strpos && str.at(strpos).isSpace())
         strpos++;
 
       c = fmt.at(fmtpos++);
-      switch (c)
+      switch (c.unicode())
       {
 	case 'a':
 	case 'A':
 	  // this will just be ignored
 	  { // Cristian Tache: porting to Win: Block added because of "j" redefinition
   	  for (int j = 1; j < 8; j++) {
   	    QString s = weekDayName(j, c == 'a').lower();
   	    int len = s.length();
   	    if (str.mid(strpos, len) == s)
   	      strpos += len;
   	  }
   	  break;
@@ -629,25 +630,25 @@ QTime KLocale::readTime(const QString &intstr, bool seconds, bool *ok) const
 	  if (c.isSpace())
 	    strpos++;
 	  else if (c != str.at(strpos++))
 	    goto error;
 	  continue;
 	}
 
       // remove space at the begining
       if (str.length() > strpos && str.at(strpos).isSpace())
 	strpos++;
 
       c = Format.at(Formatpos++);
-      switch (c)
+      switch (c.unicode())
 	{
 	case 'p':
 	  {
 	    QString s;
 	    s = i18n("pm").lower();
 	    int len = s.length();
 	    if (str.mid(strpos, len) == s)
 	      {
 		pm = true;
 		strpos += len;
 	      }
 	    else
@@ -725,25 +726,25 @@ QDateTime KLocale::readDateTime(const QString &intstr,
       qDebug("KLocale::readDateTime, only ISODate is supported.");
       return QDateTime();
     }  
 
   int pos = intstr.find("T");
   QString date = intstr.left(pos);
   QString time = intstr.mid(pos+1);
 
   QString dformat = dateFormat(intIntDateFormat);
   QString tformat = timeFormat(intIntDateFormat);
 
   QDate m_date = readDate(date, dformat, &ok1);
-  QTime m_time = readTime(time, tformat, &ok2);
+  QTime m_time = readTime(time, !tformat.isEmpty(), &ok2);
 
   QDateTime m_dt;
 
   if (ok)
     {
       if ((ok1 == false) || (ok2 == false))
 	*ok = false;
       else
 	*ok = true;
     }
 
   //only set values if both operations returned true.
diff --git a/microkde/kdecore/klocale.h b/microkde/kdecore/klocale.h
index 58e0b39..840fc9d 100644
--- a/microkde/kdecore/klocale.h
+++ b/microkde/kdecore/klocale.h
@@ -1,26 +1,26 @@
 #ifndef MINIKDE_KLOCALE_H
 #define MINIKDE_KLOCALE_H
 
 #include <qstring.h>
 #include <qstringlist.h>
 #include <qdatetime.h>
-#include <qdict.h>
+#include <q3dict.h>
 
 #ifndef I18N_NOOP
 #define I18N_NOOP(x) (x)
 #endif
 
 class KCalendarSystem;
-void setLocaleDict( QDict<QString> * dict );
+void setLocaleDict( Q3Dict<QString> * dict );
 QString i18n(const char *text);
 QString i18n(const char *hint, const char *text);
 QString i18n(const char *text1, const char *textn, int num);
 
 // Qt3's uic generates i18n( "msg", "comment" ) calls which conflict
 // with our i18n method. we use uic -tr tr2i18n to redirect
 // to the right i18n() function
 inline QString tr2i18n(const char* message, const char* =0) {
   return i18n( message);
 }
 
 class KLocale
diff --git a/microkde/kdecore/kmdcodec.cpp b/microkde/kdecore/kmdcodec.cpp
index bc03569..db11e52 100644
--- a/microkde/kdecore/kmdcodec.cpp
+++ b/microkde/kdecore/kmdcodec.cpp
@@ -30,24 +30,26 @@
    The quoted-printable codec as described in RFC 2045, section 6.7. is by
    Rik Hemsley (C) 2001.
 */
 
 //US #include <config.h>
 
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 
 #include <kdebug.h>
 #include "kmdcodec.h"
+//Added by qt3to4:
+#include <Q3CString>
 
 #define KMD5_S11 7
 #define KMD5_S12 12
 #define KMD5_S13 17
 #define KMD5_S14 22
 #define KMD5_S21 5
 #define KMD5_S22 9
 #define KMD5_S23 14
 #define KMD5_S24 20
 #define KMD5_S31 4
 #define KMD5_S32 11
 #define KMD5_S33 16
@@ -138,32 +140,32 @@ static int rikFindChar(register const char * _s, const char c)
 
   while (true)
   {
     if ((0 == *s) || (c == *s)) break; ++s;
     if ((0 == *s) || (c == *s)) break; ++s;
     if ((0 == *s) || (c == *s)) break; ++s;
     if ((0 == *s) || (c == *s)) break; ++s;
   }
 
   return s - _s;
 }
 
-QCString KCodecs::quotedPrintableEncode(const QByteArray& in, bool useCRLF)
+Q3CString KCodecs::quotedPrintableEncode(const QByteArray& in, bool useCRLF)
 {
   QByteArray out;
   quotedPrintableEncode (in, out, useCRLF);
-  return QCString (out.data(), out.size()+1);
+  return Q3CString (out.data(), out.size()+1);
 }
 
-QCString KCodecs::quotedPrintableEncode(const QCString& str, bool useCRLF)
+Q3CString KCodecs::quotedPrintableEncode(const Q3CString& str, bool useCRLF)
 {
   if (str.isEmpty())
     return "";
 
   QByteArray in (str.length());
   memcpy (in.data(), str.data(), str.length());
   return quotedPrintableEncode(in, useCRLF);
 }
 
 void KCodecs::quotedPrintableEncode(const QByteArray& in, QByteArray& out, bool useCRLF)
 {
   out.resize (0);
@@ -271,32 +273,32 @@ void KCodecs::quotedPrintableEncode(const QByteArray& in, QByteArray& out, bool
       } else {
         *cursor++ = '=';
         *cursor++ = '\n';
       }
 
       lineLength = 0;
     }
   }
 
   out.truncate(cursor - out.data());
 }
 
-QCString KCodecs::quotedPrintableDecode(const QByteArray & in)
+Q3CString KCodecs::quotedPrintableDecode(const QByteArray & in)
 {
   QByteArray out;
   quotedPrintableDecode (in, out);
-  return QCString (out.data(), out.size()+1);
+  return Q3CString (out.data(), out.size()+1);
 }
 
-QCString KCodecs::quotedPrintableDecode(const QCString & str)
+Q3CString KCodecs::quotedPrintableDecode(const Q3CString & str)
 {
   if (str.isEmpty())
     return "";
 
   QByteArray in (str.length());
   memcpy (in.data(), str.data(), str.length());
   return quotedPrintableDecode (in);
 }
 
 void KCodecs::quotedPrintableDecode(const QByteArray& in, QByteArray& out)
 {
   // clear out the output buffer
@@ -346,39 +348,39 @@ void KCodecs::quotedPrintableDecode(const QByteArray& in, QByteArray& out)
         }
       }
     }
     else
     {
       *cursor++ = c;
     }
   }
 
   out.truncate(cursor - out.data());
 }
 
-QCString KCodecs::base64Encode( const QCString& str, bool insertLFs )
+Q3CString KCodecs::base64Encode( const Q3CString& str, bool insertLFs )
 {
     if ( str.isEmpty() )
         return "";
 
     QByteArray in (str.length());
     memcpy( in.data(), str.data(), str.length() );
     return base64Encode( in, insertLFs );
 }
 
-QCString KCodecs::base64Encode( const QByteArray& in, bool insertLFs )
+Q3CString KCodecs::base64Encode( const QByteArray& in, bool insertLFs )
 {
     QByteArray out;
     base64Encode( in, out, insertLFs );
-    return QCString( out.data(), out.size()+1 );
+    return Q3CString( out.data(), out.size()+1 );
 }
 
 void KCodecs::base64Encode( const QByteArray& in, QByteArray& out,
                             bool insertLFs )
 {
     // clear out the output buffer
     out.resize (0);
     if ( in.isEmpty() )
         return;
 
     unsigned int sidx = 0;
     unsigned int didx = 0;
@@ -396,78 +398,75 @@ void KCodecs::base64Encode( const QByteArray& in, QByteArray& out,
 
     int count = 0;
     out.resize( out_len );
 
     // 3-byte to 4-byte conversion + 0-63 to ascii printable conversion
     if ( len > 1 )
     {
         while (sidx < len-2)
         {
             if ( insertLFs )
             {
                 if ( count && (count%76) == 0 )
-                    out.at(didx++) = '\n';
+                    out[didx++] = '\n';
                 count += 4;
             }
-            out.at(didx++) = Base64EncMap[(data[sidx] >> 2) & 077];
-            out.at(didx++) = Base64EncMap[(data[sidx+1] >> 4) & 017 |
+            out[didx++] = Base64EncMap[(data[sidx] >> 2) & 077];
+            out[didx++] = Base64EncMap[(data[sidx+1] >> 4) & 017 |
                                        (data[sidx] << 4) & 077];
-            out.at(didx++) = Base64EncMap[(data[sidx+2] >> 6) & 003 |
+            out[didx++] = Base64EncMap[(data[sidx+2] >> 6) & 003 |
                                        (data[sidx+1] << 2) & 077];
-            out.at(didx++) = Base64EncMap[data[sidx+2] & 077];
+            out[didx++] = Base64EncMap[data[sidx+2] & 077];
             sidx += 3;
         }
     }
 
     if (sidx < len)
     {
         if ( insertLFs && (count > 0) && (count%76) == 0 )
-           out.at(didx++) = '\n';
+           out[didx++] = '\n';
 
-        out.at(didx++) = Base64EncMap[(data[sidx] >> 2) & 077];
+        out[didx++] = Base64EncMap[(data[sidx] >> 2) & 077];
         if (sidx < len-1)
         {
-            out.at(didx++) = Base64EncMap[(data[sidx+1] >> 4) & 017 |
+            out[didx++] = Base64EncMap[(data[sidx+1] >> 4) & 017 |
                                        (data[sidx] << 4) & 077];
-            out.at(didx++) = Base64EncMap[(data[sidx+1] << 2) & 077];
+            out[didx++] = Base64EncMap[(data[sidx+1] << 2) & 077];
         }
         else
         {
-            out.at(didx++) = Base64EncMap[(data[sidx] << 4) & 077];
+            out[didx++] = Base64EncMap[(data[sidx] << 4) & 077];
         }
     }
 
     // Add padding
     while (didx < out.size())
-    {
-        out.at(didx) = '=';
-        didx++;
-    }
+        out[didx++] = '=';
 }
 
-QCString KCodecs::base64Decode( const QCString& str )
+Q3CString KCodecs::base64Decode( const Q3CString& str )
 {
     if ( str.isEmpty() )
         return "";
 
     QByteArray in( str.length() );
     memcpy( in.data(), str.data(), str.length() );
     return base64Decode( in );
 }
 
-QCString KCodecs::base64Decode( const QByteArray& in )
+Q3CString KCodecs::base64Decode( const QByteArray& in )
 {
     QByteArray out;
     base64Decode( in, out );
-    return QCString( out.data(), out.size()+1 );
+    return Q3CString( out.data(), out.size()+1 );
 }
 
 void KCodecs::base64Decode( const QByteArray& in, QByteArray& out )
 {
     out.resize(0);
     if ( in.isEmpty() )
         return;
 
     unsigned int count = 0;
     unsigned int len = in.size(), tail = len;
     const char* data = in.data();
 
@@ -496,174 +495,174 @@ void KCodecs::base64Decode( const QByteArray& in, QByteArray& out )
         if ( data[--tail] != '=' ) len = tail;
 
     unsigned int outIdx = 0;
     out.resize( (count=len) );
     for (unsigned int idx = 0; idx < count; idx++)
     {
         // Adhere to RFC 2045 and ignore characters
         // that are not part of the encoding table.
         unsigned char ch = data[idx];
         if ((ch > 47 && ch < 58) || (ch > 64 && ch < 91) ||
             (ch > 96 && ch < 123) || ch == '+' || ch == '/' || ch == '=')
         {
-            out.at(outIdx++) = Base64DecMap[ch];
+            out[outIdx++] = Base64DecMap[ch];
         }
         else
         {
             len--;
             tail--;
         }
     }
 
     // kdDebug() << "Tail size = " << tail << ", Length size = " << len << endl;
 
     // 4-byte to 3-byte conversion
     len = (tail>(len/4)) ? tail-(len/4) : 0;
     unsigned int sidx = 0, didx = 0;
     if ( len > 1 )
     {
       while (didx < len-2)
       {
-          out.at(didx) = (((out.at(sidx) << 2) & 255) | ((out.at(sidx+1) >> 4) & 003));
-          out.at(didx+1) = (((out.at(sidx+1) << 4) & 255) | ((out.at(sidx+2) >> 2) & 017));
-          out.at(didx+2) = (((out.at(sidx+2) << 6) & 255) | (out.at(sidx+3) & 077));
+          out[didx] = (((out[sidx] << 2) & 255) | ((out[sidx+1] >> 4) & 003));
+          out[didx+1] = (((out[sidx+1] << 4) & 255) | ((out[sidx+2] >> 2) & 017));
+          out[didx+2] = (((out[sidx+2] << 6) & 255) | (out[sidx+3] & 077));
           sidx += 4;
           didx += 3;
       }
     }
 
     if (didx < len)
-        out.at(didx) = (((out.at(sidx) << 2) & 255) | ((out.at(sidx+1) >> 4) & 003));
+        out[didx] = (((out[sidx] << 2) & 255) | ((out[sidx+1] >> 4) & 003));
 
     if (++didx < len )
-        out.at(didx) = (((out.at(sidx+1) << 4) & 255) | ((out.at(sidx+2) >> 2) & 017));
+        out[didx] = (((out[sidx+1] << 4) & 255) | ((out[sidx+2] >> 2) & 017));
 
     // Resize the output buffer
     if ( len == 0 || len < out.size() )
       out.resize(len);
 }
 
-QCString KCodecs::uuencode( const QCString& str )
+Q3CString KCodecs::uuencode( const Q3CString& str )
 {
     if ( str.isEmpty() )
         return "";
 
     QByteArray in;
     in.resize( str.length() );
     memcpy( in.data(), str.data(), str.length() );
     return uuencode( in );
 }
 
-QCString KCodecs::uuencode( const QByteArray& in )
+Q3CString KCodecs::uuencode( const QByteArray& in )
 {
     QByteArray out;
     uuencode( in, out );
-    return QCString( out.data(), out.size()+1 );
+    return Q3CString( out.data(), out.size()+1 );
 }
 
 void KCodecs::uuencode( const QByteArray& in, QByteArray& out )
 {
     out.resize( 0 );
     if( in.isEmpty() )
         return;
 
     unsigned int sidx = 0;
     unsigned int didx = 0;
     unsigned int line_len = 45;
 
     const char nl[] = "\n";
     const char* data = in.data();
     const unsigned int nl_len = strlen(nl);
     const unsigned int len = in.size();
 
     out.resize( (len+2)/3*4 + ((len+line_len-1)/line_len)*(nl_len+1) );
     // split into lines, adding line-length and line terminator
     while (sidx+line_len < len)
     {
         // line length
-        out.at(didx++) = UUEncMap[line_len];
+        out[didx++] = UUEncMap[line_len];
 
         // 3-byte to 4-byte conversion + 0-63 to ascii printable conversion
         for (unsigned int end = sidx+line_len; sidx < end; sidx += 3)
         {
-            out.at(didx++) = UUEncMap[(data[sidx] >> 2) & 077];
-            out.at(didx++) = UUEncMap[(data[sidx+1] >> 4) & 017 |
+            out[didx++] = UUEncMap[(data[sidx] >> 2) & 077];
+            out[didx++] = UUEncMap[(data[sidx+1] >> 4) & 017 |
                                    (data[sidx] << 4) & 077];
-            out.at(didx++) = UUEncMap[(data[sidx+2] >> 6) & 003 |
+            out[didx++] = UUEncMap[(data[sidx+2] >> 6) & 003 |
                                 (data[sidx+1] << 2) & 077];
-            out.at(didx++) = UUEncMap[data[sidx+2] & 077];
+            out[didx++] = UUEncMap[data[sidx+2] & 077];
         }
 
         // line terminator
         //for (unsigned int idx=0; idx < nl_len; idx++)
-        //out.at(didx++) = nl[idx];
+        //out[didx++] = nl[idx];
         memcpy(out.data()+didx, nl, nl_len);
         didx += nl_len;
     }
 
     // line length
-    out.at(didx++) = UUEncMap[len-sidx];
+    out[didx++] = UUEncMap[len-sidx];
     // 3-byte to 4-byte conversion + 0-63 to ascii printable conversion
     while (sidx+2 < len)
     {
-        out.at(didx++) = UUEncMap[(data[sidx] >> 2) & 077];
-        out.at(didx++) = UUEncMap[(data[sidx+1] >> 4) & 017 |
+        out[didx++] = UUEncMap[(data[sidx] >> 2) & 077];
+        out[didx++] = UUEncMap[(data[sidx+1] >> 4) & 017 |
                                (data[sidx] << 4) & 077];
-        out.at(didx++) = UUEncMap[(data[sidx+2] >> 6) & 003 |
+        out[didx++] = UUEncMap[(data[sidx+2] >> 6) & 003 |
                                (data[sidx+1] << 2) & 077];
-        out.at(didx++) = UUEncMap[data[sidx+2] & 077];
+        out[didx++] = UUEncMap[data[sidx+2] & 077];
         sidx += 3;
     }
 
     if (sidx < len-1)
     {
-        out.at(didx++) = UUEncMap[(data[sidx] >> 2) & 077];
-        out.at(didx++) = UUEncMap[(data[sidx+1] >> 4) & 017 |
+        out[didx++] = UUEncMap[(data[sidx] >> 2) & 077];
+        out[didx++] = UUEncMap[(data[sidx+1] >> 4) & 017 |
                                (data[sidx] << 4) & 077];
-        out.at(didx++) = UUEncMap[(data[sidx+1] << 2) & 077];
-        out.at(didx++) = UUEncMap[0];
+        out[didx++] = UUEncMap[(data[sidx+1] << 2) & 077];
+        out[didx++] = UUEncMap[0];
     }
     else if (sidx < len)
     {
-        out.at(didx++) = UUEncMap[(data[sidx] >> 2) & 077];
-        out.at(didx++) = UUEncMap[(data[sidx] << 4) & 077];
-        out.at(didx++) = UUEncMap[0];
-        out.at(didx++) = UUEncMap[0];
+        out[didx++] = UUEncMap[(data[sidx] >> 2) & 077];
+        out[didx++] = UUEncMap[(data[sidx] << 4) & 077];
+        out[didx++] = UUEncMap[0];
+        out[didx++] = UUEncMap[0];
     }
 
     // line terminator
     memcpy(out.data()+didx, nl, nl_len);
     didx += nl_len;
 
     // sanity check
     if ( didx != out.size() )
         out.resize( 0 );
 }
 
-QCString KCodecs::uudecode( const QCString& str )
+Q3CString KCodecs::uudecode( const Q3CString& str )
 {
     if ( str.isEmpty() )
         return "";
 
     QByteArray in;
     in.resize( str.length() );
     memcpy( in.data(), str.data(), str.length() );
     return uudecode( in );
 }
 
-QCString KCodecs::uudecode( const QByteArray& in )
+Q3CString KCodecs::uudecode( const QByteArray& in )
 {
     QByteArray out;
     uudecode( in, out );
-    return QCString( out.data(), out.size()+1 );
+    return Q3CString( out.data(), out.size()+1 );
 }
 
 void KCodecs::uudecode( const QByteArray& in, QByteArray& out )
 {
     out.resize( 0 );
     if( in.isEmpty() )
         return;
 
     unsigned int sidx = 0;
     unsigned int didx = 0;
     unsigned int len = in.size();
     unsigned int line_len, end;
@@ -696,43 +695,43 @@ void KCodecs::uudecode( const QByteArray& in, QByteArray& out )
         // get line length (in number of encoded octets)
         line_len = UUDecMap[ (unsigned char) data[sidx++]];
         // ascii printable to 0-63 and 4-byte to 3-byte conversion
         end = didx+line_len;
         char A, B, C, D;
         if (end > 2) {
           while (didx < end-2)
           {
              A = UUDecMap[(unsigned char) data[sidx]];
              B = UUDecMap[(unsigned char) data[sidx+1]];
              C = UUDecMap[(unsigned char) data[sidx+2]];
              D = UUDecMap[(unsigned char) data[sidx+3]];
-             out.at(didx++) = ( ((A << 2) & 255) | ((B >> 4) & 003) );
-             out.at(didx++) = ( ((B << 4) & 255) | ((C >> 2) & 017) );
-             out.at(didx++) = ( ((C << 6) & 255) | (D & 077) );
+             out[didx++] = ( ((A << 2) & 255) | ((B >> 4) & 003) );
+             out[didx++] = ( ((B << 4) & 255) | ((C >> 2) & 017) );
+             out[didx++] = ( ((C << 6) & 255) | (D & 077) );
              sidx += 4;
           }
         }
 
         if (didx < end)
         {
             A = UUDecMap[(unsigned char) data[sidx]];
             B = UUDecMap[(unsigned char) data[sidx+1]];
-            out.at(didx++) = ( ((A << 2) & 255) | ((B >> 4) & 003) );
+            out[didx++] = ( ((A << 2) & 255) | ((B >> 4) & 003) );
         }
 
         if (didx < end)
         {
             B = UUDecMap[(unsigned char) data[sidx+1]];
             C = UUDecMap[(unsigned char) data[sidx+2]];
-            out.at(didx++) = ( ((B << 4) & 255) | ((C >> 2) & 017) );
+            out[didx++] = ( ((B << 4) & 255) | ((C >> 2) & 017) );
         }
 
         // skip padding
         while (sidx < len  && data[sidx] != '\n' && data[sidx] != '\r')
             sidx++;
 
         // skip end of line
         while (sidx < len  && (data[sidx] == '\n' || data[sidx] == '\r'))
             sidx++;
 
         // skip the "END" separator when present.
         if ( hasLF && QString( data+sidx).left(3).lower() == "end" )
@@ -752,36 +751,36 @@ KMD5::KMD5()
 KMD5::KMD5(const char *in, int len)
 {
     init();
     update(in, len);
 }
 
 KMD5::KMD5(const QByteArray& in)
 {
     init();
     update( in );
 }
 
-KMD5::KMD5(const QCString& in)
+KMD5::KMD5(const Q3CString& in)
 {
     init();
     update( in );
 }
 
 void KMD5::update(const QByteArray& in)
 {
     update(in.data(), int(in.size()));
 }
 
-void KMD5::update(const QCString& in)
+void KMD5::update(const Q3CString& in)
 {
     update(in.data(), int(in.length()));
 }
 
 void KMD5::update(const unsigned char* in, int len)
 {
     if (len < 0)
         len = qstrlen(reinterpret_cast<const char*>(in));
 
     if (!len)
         return;
 
@@ -864,67 +863,67 @@ void KMD5::finalize ()
     memset ( (void *)m_buffer, 0, sizeof(*m_buffer));
 
     m_finalized = true;
 }
 
 
 bool KMD5::verify( const KMD5::Digest& digest)
 {
     finalize();
     return (0 == memcmp(rawDigest(), digest, sizeof(KMD5::Digest)));
 }
 
-bool KMD5::verify( const QCString& hexdigest)
+bool KMD5::verify( const Q3CString& hexdigest)
 {
     finalize();
     return (0 == strcmp(hexDigest().data(), hexdigest));
 }
 
 const KMD5::Digest& KMD5::rawDigest()
 {
     finalize();
     return m_digest;
 }
 
 void KMD5::rawDigest( KMD5::Digest& bin )
 {
     finalize();
     memcpy( bin, m_digest, 16 );
 }
 
 
-QCString KMD5::hexDigest()
+Q3CString KMD5::hexDigest()
 {
-    QCString s(33);
+    Q3CString s(33);
 
     finalize();
     sprintf(s.data(), "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
             m_digest[0], m_digest[1], m_digest[2], m_digest[3], m_digest[4], m_digest[5],
             m_digest[6], m_digest[7], m_digest[8], m_digest[9], m_digest[10], m_digest[11],
             m_digest[12], m_digest[13], m_digest[14], m_digest[15]);
 
     return s;
 }
 
-void KMD5::hexDigest(QCString& s)
+void KMD5::hexDigest(Q3CString& s)
 {
     finalize();
     s.resize(33);
     sprintf(s.data(), "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
             m_digest[0], m_digest[1], m_digest[2], m_digest[3], m_digest[4], m_digest[5],
             m_digest[6], m_digest[7], m_digest[8], m_digest[9], m_digest[10], m_digest[11],
             m_digest[12], m_digest[13], m_digest[14], m_digest[15]);
 }
 
-QCString KMD5::base64Digest()
+Q3CString KMD5::base64Digest()
 {
     QByteArray ba(16);
 
     finalize();
     memcpy(ba.data(), m_digest, 16);
     return KCodecs::base64Encode(ba);
 }
 
 
 void KMD5::init()
 {
     d = 0;
@@ -947,25 +946,25 @@ void KMD5::reset()
     memset ( m_digest, 0, sizeof(*m_digest));
 }
 
 void KMD5::transform( const unsigned char block[64] )
 {
 
     Q_UINT32 a = m_state[0], b = m_state[1], c = m_state[2], d = m_state[3], x[16];
 
     decode (x, block, 64);
     //memcpy( x, block, 64 );
 
 //US    Q_ASSERT(!m_finalized);  // not just a user error, since the method is private
-    ASSERT(!m_finalized);  // not just a user error, since the method is private
+    Q_ASSERT(!m_finalized);  // not just a user error, since the method is private
 
     /* Round 1 */
     FF (a, b, c, d, x[ 0], KMD5_S11, 0xd76aa478); /* 1 */
     FF (d, a, b, c, x[ 1], KMD5_S12, 0xe8c7b756); /* 2 */
     FF (c, d, a, b, x[ 2], KMD5_S13, 0x242070db); /* 3 */
     FF (b, c, d, a, x[ 3], KMD5_S14, 0xc1bdceee); /* 4 */
     FF (a, b, c, d, x[ 4], KMD5_S11, 0xf57c0faf); /* 5 */
     FF (d, a, b, c, x[ 5], KMD5_S12, 0x4787c62a); /* 6 */
     FF (c, d, a, b, x[ 6], KMD5_S13, 0xa8304613); /* 7 */
     FF (b, c, d, a, x[ 7], KMD5_S14, 0xfd469501); /* 8 */
     FF (a, b, c, d, x[ 8], KMD5_S11, 0x698098d8); /* 9 */
     FF (d, a, b, c, x[ 9], KMD5_S12, 0x8b44f7af); /* 10 */
diff --git a/microkde/kdecore/kmdcodec.h b/microkde/kdecore/kmdcodec.h
index 2c4d611..616b683 100644
--- a/microkde/kdecore/kmdcodec.h
+++ b/microkde/kdecore/kmdcodec.h
@@ -30,24 +30,26 @@
    The quoted-printable codec as described in RFC 2045, section 6.7. is by
    Rik Hemsley (C) 2001.
 */
 
 #ifndef _KMDBASE_H
 #define _KMDBASE_H
 
 #define KBase64 KCodecs
 
 #include <qglobal.h>
 #include <qstring.h>
 #include <qiodevice.h>
+//Added by qt3to4:
+#include <Q3CString>
 
 /**
  * A wrapper class for the most commonly used encoding and
  * decoding algorithms.  Currently there is support for encoding
  * and decoding input using base64, uu and the quoted-printable
  * specifications.
  *
  * @sect Usage:
  *
  * <PRE>
  * QCString input = "Aladdin:open sesame";
  * QCString result = KCodecs::base64Encode(input);
@@ -72,40 +74,40 @@ class KCodecs
 {
 public:
 
   /**
    * Encodes the given data using the quoted-printable algorithm.
    *
    * @param in      data to be encoded.
    * @param useCRLF if true the input data is expected to have
    *                CRLF line breaks and the output will have CRLF line
    *                breaks, too.
    * @return        quoted-printable encoded data.
    */
-  static QCString quotedPrintableEncode(const QByteArray & in,
+  static Q3CString quotedPrintableEncode(const QByteArray & in,
                                         bool useCRLF = true);
 
   /**
    * @overload
    *
    * Same as above except it accepts a null terminated
    * string instead an array.
    *
    * @param str     data to be encoded.
    * @param useCRLF if true the input data is expected to have
    *                CRLF line breaks and the output will have CRLF line
    *                breaks, too.
    * @return        quoted-printable encoded data.
    */
-  static QCString quotedPrintableEncode(const QCString & str,
+  static Q3CString quotedPrintableEncode(const Q3CString & str,
                                         bool useCRLF = true);
 
   /**
    * Encodes the given data using the quoted-printable algorithm.
    *
    * Use this function if you want the result of the encoding
    * to be placed in another array which cuts down the number
    * of copy operation that have to be performed in the process.
    * This is also the preferred method for encoding binary data.
    *
    * NOTE: the output array is first reset and then resized
    * appropriately before use, hence, all data stored in the
@@ -120,36 +122,36 @@ public:
    */
   static void quotedPrintableEncode(const QByteArray & in, QByteArray& out,
                                     bool useCRLF);
 
   /**
    * Decodes a quoted-printable encoded string.
    *
    * Accepts data with CRLF or standard unix line breaks.
    *
    * @param in  the data to be decoded.
    * @return    decoded data.
    */
-  static QCString quotedPrintableDecode(const QByteArray & in);
+  static Q3CString quotedPrintableDecode(const QByteArray & in);
 
   /**
    * @overload
    *
    * Same as above except it accepts a null terminated
    * string instead an array.
    *
    * @param str  the data to be decoded.
    * @return     decoded data.
    */
-  static QCString quotedPrintableDecode(const QCString & str);
+  static Q3CString quotedPrintableDecode(const Q3CString & str);
 
   /**
    * Decodes a quoted-printable encoded data.
    *
    * Accepts data with CRLF or standard unix line breaks.
    * Use this function if you want the result of the decoding
    * to be placed in another array which cuts down the number
    * of copy operation that have to be performed in the process.
    * This is also the preferred method for decoding an encoded
    * binary data.
    *
    * NOTE: the output array is first reset and then resized
@@ -166,36 +168,36 @@ public:
 
   /**
    * Encodes the given data using the uuencode algorithm.
    *
    * The output is split into lines starting with the number of
    * encoded octets in the line and ending with a newline.  No
    * line is longer than 45 octets (60 characters), excluding the
    * line terminator.
    *
    * @param in   the data to be uuencoded
    * @return     a uuencoded data.
    */
-  static QCString uuencode( const QByteArray& in );
+  static Q3CString uuencode( const QByteArray& in );
 
   /**
    * @overload
    *
    * Same as the above functions except it accepts
    * a null terminated string instead an array.
    *
    * @param str   the string to be uuencoded.
    * @return      the encoded string.
    */
-  static QCString uuencode( const QCString& str );
+  static Q3CString uuencode( const Q3CString& str );
 
   /**
    * Encodes the given data using the uuencode algorithm.
    *
    * Use this function if you want the result of the encoding
    * to be placed in another array and cut down the number of
    * copy operation that have to be performed in the process.
    * This is the preffered method for encoding binary data.
    *
    * NOTE: the output array is first reset and then resized
    * appropriately before use, hence, all data stored in the
    * output array will be lost.
@@ -206,36 +208,36 @@ public:
   static void uuencode( const QByteArray& in, QByteArray& out );
 
   /**
    * Decodes the given data using the uuencode algorithm.
    *
    * Any 'begin' and 'end' lines like those generated by
    * the utilities in unix and unix-like OS will be
    * automatically ignored.
    *
    * @param in   the data uuencoded data to be decoded.
    * @return     a decoded string.
    */
-  static QCString uudecode( const QByteArray& in );
+  static Q3CString uudecode( const QByteArray& in );
 
   /**
    * @overload
    *
    * Same as the above functions except it accepts
    * a null terminated string instead an array.
    *
    * @param str   the string to be decoded.
    * @return      a uudecoded string.
    */
-  static QCString uudecode( const QCString& str );
+  static Q3CString uudecode( const Q3CString& str );
 
   /**
    * Decodes the given data using the uudecode algorithm.
    *
    * Use this function if you want the result of the decoding
    * to be placed in another array which cuts down the number
    * of copy operation that have to be performed in the process.
    * This is the preferred method for decoding binary data.
    *
    * Any 'begin' and 'end' lines like those generated by
    * the utilities in unix and unix-like OS will be
    * automatically ignored.
@@ -254,37 +256,37 @@ public:
    * Encodes the given data using the base64 algorithm.
    *
    * The boolean argument determines if the encoded data is
    * going to be restricted to 76 characters or less per line
    * as specified by RFC 2045.  If @p insertLFs is true, then
    * there will be 76 characters or less per line.
    *
    * @param in         the data to be encoded.
    * @param insertLFs  limit the number of characters per line.
    *
    * @return           a base64 encoded string.
    */
-  static QCString base64Encode( const QByteArray& in, bool insertLFs = false);
+  static Q3CString base64Encode( const QByteArray& in, bool insertLFs = false);
 
   /**
    * @overload
    *
    * Same as the above functions except it accepts
    * a null terminated string instead an array.
    *
    * @param str       the string to be encoded.
    * @param insertLFs limit the number of characters per line.
    * @return          the decoded string.
    */
-  static QCString base64Encode( const QCString& str, bool insertLFs = false );
+  static Q3CString base64Encode( const Q3CString& str, bool insertLFs = false );
 
   /**
    * Encodes the given data using the base64 algorithm.
    *
    * Use this function if you want the result of the encoding
    * to be placed in another array which cuts down the number
    * of copy operation that have to be performed in the process.
    * This is also the preferred method for encoding binary data.
    *
    * The boolean argument determines if the encoded data is going
    * to be restricted to 76 characters or less per line as specified
    * by RFC 2045.  If @p insertLFs is true, then there will be 76
@@ -299,36 +301,36 @@ public:
    * @param insertLFs limit the number of characters per line.
    */
   static void base64Encode( const QByteArray& in, QByteArray& out,
                             bool insertLFs = false );
 
   /**
    * Decodes the given data that was encoded using the
    * base64 algorithm.
    *
    * @param in   the base64-encoded data to be decoded.
    * @return     the decoded data.
    */
-  static QCString base64Decode( const QByteArray& in );
+  static Q3CString base64Decode( const QByteArray& in );
 
   /**
    * @overload
    *
    * Same as the above functions except it accepts
    * a null terminated string instead an array.
    *
    * @param str  the base64-encoded string.
    * @return     the decoded string.
    */
-  static QCString base64Decode( const QCString& str );
+  static Q3CString base64Decode( const Q3CString& str );
 
   /**
    * Decodes the given data that was encoded with the base64
    * algorithm.
    *
    * Use this function if you want the result of the decoding
    * to be placed in another array which cuts down the number
    * of copy operation that have to be performed in the process.
    * This is also the preferred method for decoding an encoded
    * binary data.
    *
    * NOTE: the output array is first reset and then resized
@@ -422,25 +424,25 @@ public:
   /**
    * @overload
    *
    * Same as above except it accepts a QByteArray as its argument.
    */
   KMD5(const QByteArray& a );
 
   /**
    * @overload
    *
    * Same as above except it accepts a QByteArray as its argument.
    */
-  KMD5(const QCString& a );
+  KMD5(const Q3CString& a );
 
   /**
    * Updates the message to be digested. Be sure to add all data
    * before you read the digest. After reading the digest, you
    * can <b>not</b> add more data!
    *
    * @param in     message to be added to digest
    * @param len    the length of the given message.
    */
   void update(const char* in, int len = -1) { update(reinterpret_cast<const unsigned char*>(in), len); }
 
   /**
@@ -451,25 +453,25 @@ public:
   /**
    * @overload
    *
    * @param in     message to be added to the digest (QByteArray).
    */
   void update(const QByteArray& in );
 
   /**
    * @overload
    *
    * @param in     message to be added to the digest (QByteArray).
    */
-  void update(const QCString& in );
+  void update(const Q3CString& in );
 
   /**
    * @overload
    *
    * reads the data from an I/O device, i.e. from a file (QFile).
    *
    * NOTE that the file must be open for reading.
    *
    * @param file       a pointer to FILE as returned by calls like f{d,re}open
    *
    * @returns false if an error occured during reading.
    */
@@ -493,47 +495,47 @@ public:
    *
    * Use this method if you do not want to worry about making
    * copy of the digest once you obtain it.
    *
    * @param bin an array of 16 characters ( char[16] )
    */
   void rawDigest( KMD5::Digest& bin );
 
   /**
    * Returns the value of the calculated message digest in
    * a hexadecimal representation.
    */
-  QCString hexDigest ();
+  Q3CString hexDigest ();
 
   /**
    * @overload
    */
-  void hexDigest(QCString&);
+  void hexDigest(Q3CString&);
 
   /**
    * Returns the value of the calculated message digest in
    * a base64-encoded representation.
    */
-  QCString base64Digest ();
+  Q3CString base64Digest ();
 
   /**
    * returns true if the calculated digest for the given
    * message matches the given one.
    */
   bool verify( const KMD5::Digest& digest);
 
   /**
    * @overload
    */
-  bool verify(const QCString&);
+  bool verify(const Q3CString&);
 
 protected:
   /**
    *  Performs the real update work.  Note
    *  that length is implied to be 64.
    */
   void transform( const unsigned char buffer[64] );
 
   /**
    * finalizes the digest
    */
   void finalize();
diff --git a/microkde/kdecore/kprefs.cpp b/microkde/kdecore/kprefs.cpp
index 0220a34..d4010fa 100644
--- a/microkde/kdecore/kprefs.cpp
+++ b/microkde/kdecore/kprefs.cpp
@@ -12,24 +12,26 @@
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 // $Id$
 
 #include <qcolor.h>
+//Added by qt3to4:
+#include <Q3ValueList>
 
 #include <kconfig.h>
 #include <kstandarddirs.h>
 #include <kglobal.h>
 #include <kdebug.h>
 
 #include "kprefs.h"
 
 class KPrefsItemBool : public KPrefsItem {
   public:
     KPrefsItemBool(const QString &group,const QString &name,bool *,bool defaultValue=true);
     virtual ~KPrefsItemBool() {}
@@ -131,35 +133,35 @@ class KPrefsItemStringList : public KPrefsItem {
     void setDefault();
     void readConfig(KConfig *);
     void writeConfig(KConfig *);    
 
   private:
     QStringList *mReference;
     QStringList mDefault;
 };
 
 
 class KPrefsItemIntList : public KPrefsItem {
   public:
-    KPrefsItemIntList(const QString &group,const QString &name,QValueList<int> *,
-                      const QValueList<int> &defaultValue=QValueList<int>());
+    KPrefsItemIntList(const QString &group,const QString &name,Q3ValueList<int> *,
+                      const Q3ValueList<int> &defaultValue=Q3ValueList<int>());
     virtual ~KPrefsItemIntList() {}
     
     void setDefault();
     void readConfig(KConfig *);
     void writeConfig(KConfig *);    
 
   private:
-    QValueList<int> *mReference;
-    QValueList<int> mDefault;
+    Q3ValueList<int> *mReference;
+    Q3ValueList<int> mDefault;
 };
 
 
 KPrefsItemBool::KPrefsItemBool(const QString &group,const QString &name,
                                bool *reference,bool defaultValue) :
   KPrefsItem(group,name)
 {
   mReference = reference;
   mDefault = defaultValue;
 }
 
 void KPrefsItemBool::setDefault()
@@ -355,25 +357,25 @@ void KPrefsItemStringList::writeConfig(KConfig *config)
   config->setGroup(mGroup);
   config->writeEntry(mName,*mReference);
 }
 
 void KPrefsItemStringList::readConfig(KConfig *config)
 {
   config->setGroup(mGroup);
   *mReference = config->readListEntry(mName);
 }
 
 
 KPrefsItemIntList::KPrefsItemIntList(const QString &group,const QString &name,
-                                     QValueList<int> *reference,const QValueList<int> &defaultValue) :
+                                     Q3ValueList<int> *reference,const Q3ValueList<int> &defaultValue) :
   KPrefsItem(group,name)
 {
   mReference = reference;
   mDefault = defaultValue;
 }
 
 void KPrefsItemIntList::setDefault()
 {
   *mReference = mDefault;
 }
 
 void KPrefsItemIntList::writeConfig(KConfig *config)
@@ -496,17 +498,17 @@ void KPrefs::addItemString(const QString &key,QString *reference,const QString &
 
 void KPrefs::addItemPassword(const QString &key,QString *reference,const QString &defaultValue)
 {
   addItem(new KPrefsItemString(*mCurrentGroup,key,reference,defaultValue,true));
 }
 
 void KPrefs::addItemStringList(const QString &key,QStringList *reference,
                                const QStringList &defaultValue)
 {
   addItem(new KPrefsItemStringList(*mCurrentGroup,key,reference,defaultValue));
 }
 
-void KPrefs::addItemIntList(const QString &key,QValueList<int> *reference,
-                            const QValueList<int> &defaultValue)
+void KPrefs::addItemIntList(const QString &key,Q3ValueList<int> *reference,
+                            const Q3ValueList<int> &defaultValue)
 {
   addItem(new KPrefsItemIntList(*mCurrentGroup,key,reference,defaultValue));
 }
diff --git a/microkde/kdecore/kprefs.h b/microkde/kdecore/kprefs.h
index 95d2724..d9d1572 100644
--- a/microkde/kdecore/kprefs.h
+++ b/microkde/kdecore/kprefs.h
@@ -12,29 +12,31 @@
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 #ifndef _KPREFS_H
 #define _KPREFS_H
 // $Id$
 
-#include <qptrlist.h>
+#include <q3ptrlist.h>
 #include <qcolor.h>
 #include <qfont.h>
 #include <qsize.h>
 #include <qstringlist.h>
+//Added by qt3to4:
+#include <Q3ValueList>
 
 class KConfig;
 
 /**
   @short Class for storing a preferences setting
   @author Cornelius Schumacher
   @see KPref
   
   This class represents one preferences setting as used by @ref KPrefs.
   Subclasses of KPrefsItem implement storage functions for a certain type of
   setting. Normally you don't have to use this class directly. Use the special
   addItem() functions of KPrefs instead. If you subclass this class you will
@@ -274,26 +276,26 @@ class KPrefs {
                            const QStringList &defaultValue=QStringList());
 
     /**
       Register an item of type QValueList<int>.
       
       @param key Key used in config file.
       @param reference Pointer to the variable, which is set by readConfig()
                        and setDefaults() calls and read by writeConfig() calls.
       @param defaultValue Default value, which is used by setDefaults() and
                           when the config file does not yet contain the key of
                           this item.
     */
-    void addItemIntList(const QString &key,QValueList<int> *reference,
-                        const QValueList<int> &defaultValue=QValueList<int>());
+    void addItemIntList(const QString &key,Q3ValueList<int> *reference,
+                        const Q3ValueList<int> &defaultValue=Q3ValueList<int>());
 
   protected:
     /**
       Implemented by subclasses that use special defaults.
     */
     virtual void usrSetDefaults() {};
     /**
       Implemented by subclasses that read special config values.
     */
     virtual void usrReadConfig() {};
     /**
       Implemented by subclasses that write special config values.
@@ -301,16 +303,16 @@ class KPrefs {
     virtual void usrWriteConfig() {};
 
     /**
       Return the @ref KConfig object used for reading and writing the settings.
     */
     KConfig *config() const;
 
   private:
     static QString *mCurrentGroup;
 
     KConfig *mConfig;  // pointer to KConfig object
 
-    QPtrList<KPrefsItem> mItems;
+    Q3PtrList<KPrefsItem> mItems;
 };
 
 #endif
diff --git a/microkde/kdecore/kshortcut.h b/microkde/kdecore/kshortcut.h
index 4813734..244d590 100644
--- a/microkde/kdecore/kshortcut.h
+++ b/microkde/kdecore/kshortcut.h
@@ -554,25 +554,25 @@ class KShortcut
 	 * @see null()
 	 * @see isNull()
 	 * @see clear()
 	 */
 	KShortcut() {}
 
 	/**
 	 * Creates a new shortcut with the given Qt key code
 	 * as the only key sequence.
 	 * @param keyQt the qt keycode
 	 * @see Qt::Key
 	 */
-	KShortcut( int keyQt ) {}
+	KShortcut( int /*keyQt */) {}
 
 	/**
 	 * Creates a new shortcut that contains only the given qt key
 	 * sequence.
 	 * @param keySeq the qt key sequence to add
 	 */
 //US	KShortcut( const QKeySequence& keySeq ) {}
 
 	/**
 	 * Creates a new shortcut that contains only the given key
 	 * in its only sequence.
 	 * @param key the key to add
@@ -590,34 +590,34 @@ class KShortcut
 	 * Copies the given shortcut.
 	 * @param shortcut the shortcut to add
 	 */
 //US	KShortcut( const KShortcut& shortcut );
 
 	/**
 	 * Creates a new key sequence that contains the given key sequence.
 	 * The description consists of semicolon-separated keys as
 	 * used in @ref KKeySequence::KKeySequence(const QString&).
 	 * @param shortcut the description of the key
 	 * @see KKeySequence::KKeySequence(const QString&)
 	 */
-	KShortcut( const char* shortcut ) {}
+	KShortcut( const char* /*shortcut */) {}
 
 	/**
 	 * Creates a new key sequence that contains the given key sequence.
 	 * The description consists of semicolon-separated keys as
 	 * used in @ref KKeySequence::KKeySequence(const QString&).
 	 * @param shortcut the description of the key
 	 * @see KKeySequence::KKeySequence(const QString&)
 	 */
-	KShortcut( const QString& shortcut ) {}
+	KShortcut( const QString& /*shortcut */) {}
 	~KShortcut() {}
 
 	/**
 	 * Clears the shortcut. The shortcut is null after calling this 
 	 * function.
 	 * @see isNull()
 	 */
 //US	void clear();
 
 	/**
 	 * Initializes the shortcut with the given Qt key code
 	 * as the only key sequence.
@@ -807,25 +807,25 @@ class KShortcut
 	/**
 	 * Returns a description of the shortcut as semicolon-separated
 	 * ket sequences, as returned by @ref KKeySequence::toString().
 	 * @return the string represenation of this shortcut
 	 * @see KKey::toString()
 	 * @see KKeySequence::toString()
 	 */
 //US	QString toString() const;
 
 	/**
 	 * @internal
 	 */
-  QString toStringInternal( const KShortcut* pcutDefault = 0 ) const
+  QString toStringInternal( const KShortcut* /*pcutDefault*/ = 0 ) const
   {
     return "EMPTY IMPL.";
   }
 
 	/**
 	 * Returns a null shortcut.
 	 * @return the null shortcut
 	 * @see isNull()
 	 * @see clear()
 	 */
 //US	static KShortcut& null();
 
diff --git a/microkde/kdecore/kstandarddirs.cpp b/microkde/kdecore/kstandarddirs.cpp
index d5bfefd..f10934b 100644
--- a/microkde/kdecore/kstandarddirs.cpp
+++ b/microkde/kdecore/kstandarddirs.cpp
@@ -28,73 +28,75 @@
 
 #include <stdlib.h>
 #include <assert.h>
 //US#include <errno.h>
 //US #ifdef HAVE_SYS_STAT_H
 //US #include <sys/stat.h>
 //US #endif
 //US#include <sys/types.h>
 //US#include <dirent.h>
 //US#include <pwd.h>
 
 #include <qregexp.h>
-#include <qasciidict.h>
-#include <qdict.h>
+#include <q3asciidict.h>
+#include <q3dict.h>
 #include <qdir.h>
 #include <qfileinfo.h>
 #include <qstring.h>
 #include <qmessagebox.h>
 #include <qapplication.h>
 
 #include <qstringlist.h>
+//Added by qt3to4:
+#include <Q3CString>
 
 #include "kstandarddirs.h"
 #include "kconfig.h"
 #include "kdebug.h"
 //US #include "kinstance.h"
 #include "kshell.h"
 //US#include <sys/param.h>
 //US#include <unistd.h>
 
 //US
 QString KStandardDirs::mAppDir = QString::null;
 
 
-template class QDict<QStringList>;
+template class Q3Dict<QStringList>;
 
 #if 0
-#include <qtextedit.h>
+#include <q3textedit.h>
 void ddd( QString op )
 {
-  static QTextEdit * dot = 0;
+  static Q3TextEdit * dot = 0;
   if ( ! dot )
-  dot = new QTextEdit();
+  dot = new Q3TextEdit();
 
   dot->show();
 
   dot->append( op );
 
 }
 #endif
 class KStandardDirs::KStandardDirsPrivate
 {
 public:
    KStandardDirsPrivate()
     : restrictionsActive(false),
       dataRestrictionActive(false)
    { }
 
    bool restrictionsActive;
    bool dataRestrictionActive;
-   QAsciiDict<bool> restrictions;
+   Q3AsciiDict<bool> restrictions;
    QStringList xdgdata_prefixes;
    QStringList xdgconf_prefixes;
 };
 
 static const char* const types[] = {"html", "icon", "apps", "sound",
 			      "data", "locale", "services", "mime",
 			      "servicetypes", "config", "exe", "tmp",
 			      "wallpaper", "lib", "pixmap", "templates",
 			      "module", "qtplugins",
 			      "xdgdata-apps", "xdgdata-dirs", "xdgconf-menu", 0 };
 
 static int tokenize( QStringList& token, const QString& str,
@@ -436,25 +438,25 @@ static void lookupDirectory(const QString& path, const QString &relPart,
       it++;
       if ( fn.isNull() )
           break;
 
       if (fn == _dot || fn == _dotdot || fn.at(fn.length() - 1).latin1() == '~'   )
 	continue;
 
 /*US
       if (!recursive && !regexp.exactMatch(fn))
         continue; // No match
 */
 //US this should do the same:
-      int pos = regexp.match(fn);
+      int pos = regexp.exactMatch(fn);
       if (!recursive && !pos == 0)
         continue; // No match
 
       QString pathfn = path + fn;
 /*US
       if ( stat( QFile::encodeName(pathfn), &buff ) != 0 ) {
         kdDebug() << "Error stat'ing " << pathfn << " : " << perror << endl;
         continue; // Couldn't stat (e.g. no read permissions)
       }
 
       if ( recursive )
       {
@@ -473,25 +475,25 @@ static void lookupDirectory(const QString& path, const QString &relPart,
       if ( recursive )
       {
         if ( pathfnInfo.isDir()) {
           lookupDirectory(pathfn + '/', relPart + fn + '/', regexp, list, relList, recursive, uniq);
       }
 
 
 /*US
         if (!regexp.exactMatch(fn))
           continue; // No match
 */
 //US this should do the same:
-        pos = regexp.match(fn);
+        pos = regexp.exactMatch(fn);
         if (!pos == 0)
           continue; // No match
       }
 
 //US      if ( S_ISREG( buff.st_mode))
       if ( pathfnInfo.isFile())
       {
         if (!uniq || !relList.contains(relPart + fn))
         {
           list.append( pathfn );
           relList.append( relPart + fn );
         }
@@ -1099,25 +1101,25 @@ bool KStandardDirs::makeDir(const QString& dir2, int mode)
     // append trailing slash if missing
     if (dir.at(len - 1) != '/')
         target += '/';
 
     QString base("");
     uint i = 1;
 
     while( i < len )
     {
 //US        struct stat st;
         int pos = target.find('/', i);
         base += target.mid(i - 1, pos - i + 1);
-        QCString baseEncoded = QFile::encodeName(base);
+        Q3CString baseEncoded = QFile::encodeName(base);
         // bail out if we encountered a problem
 //US        if (stat(baseEncoded, &st) != 0)
         QFileInfo baseEncodedInfo(baseEncoded);
         if (!baseEncodedInfo.exists())
         {
           // Directory does not exist....
           // Or maybe a dangling symlink ?
 //US          if (lstat(baseEncoded, &st) == 0)
           if (baseEncodedInfo.isSymLink()) {
 //US              (void)unlink(baseEncoded); // try removing
               QFile(baseEncoded).remove();
           }
@@ -1199,25 +1201,25 @@ bool KStandardDirs::makeDir(const QString& dir2, int mode)
 
         i = pos + 1;
     }
     return true;
 
 }
 
 QString readEnvPath(const char *env)
 {
   //#ifdef _WIN32_
   //    return "";
   //#else
-  QCString c_path;
+  Q3CString c_path;
   if ( getenv(env) != NULL )
     c_path = QString ( getenv(env) );
   if (c_path.isEmpty())
     return QString::null;
   return QFile::decodeName(c_path);
    //#endif
 
 }
 
 void KStandardDirs::addKDEDefaults()
 {
  
diff --git a/microkde/kdecore/kstandarddirs.h b/microkde/kdecore/kstandarddirs.h
index 901384e..f0e28fc 100644
--- a/microkde/kdecore/kstandarddirs.h
+++ b/microkde/kdecore/kstandarddirs.h
@@ -15,25 +15,25 @@
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.
 */
 
 #ifndef SSK_KSTDDIRS_H
 #define SSK_KSTDDIRS_H
 
 #include <qstring.h>
-#include <qdict.h>
+#include <q3dict.h>
 #include <qstringlist.h>
 #include <kglobal.h>
 
 class KConfig;
 class KStandardDirsPrivate;
 
 
 /**
  * @short Site-independent access to standard KDE directories.
  * @author Stephan Kulow <coolo@kde.org> and Sirtaj Singh Kang <taj@kde.org>
  * @version $Id$
  *
@@ -565,29 +565,29 @@ public:
 	 * @since 3.1
          */
         static QString realPath(const QString &dirname);
         
     static void setAppDir( const QString & );
     static QString appDir();
          
  private:
 
 	QStringList prefixes;
 
 	// Directory dictionaries
-	QDict<QStringList> absolutes;
-	QDict<QStringList> relatives;
+	Q3Dict<QStringList> absolutes;
+	Q3Dict<QStringList> relatives;
 
-	mutable QDict<QStringList> dircache;
-	mutable QDict<QString> savelocations;
+	mutable Q3Dict<QStringList> dircache;
+	mutable Q3Dict<QString> savelocations;
 
 	// Disallow assignment and copy-construction
 	KStandardDirs( const KStandardDirs& );
 	KStandardDirs& operator= ( const KStandardDirs& );
 
 	bool addedCustoms;
 
         class KStandardDirsPrivate;
 	KStandardDirsPrivate *d;
 //US    
     static QString mAppDir;