TQt4 port tellico

This enables compilation under both Qt3 and Qt4


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

10 files changed, 507 insertions, 502 deletions

diff --git a/src/core/dcopinterface.cpp b/src/core/dcopinterface.cpp
index f375b6b..bd7014c 100644
--- a/src/core/dcopinterface.cpp
+++ b/src/core/dcopinterface.cpp
@@ -22,8 +22,8 @@
 using Tellico::ApplicationInterface;
 using Tellico::CollectionInterface;
 
-Tellico::Import::Action ApplicationInterface::actionType(const QString& actionName) {
-  QString name = actionName.lower();
+Tellico::Import::Action ApplicationInterface::actionType(const TQString& actionName) {
+  TQString name = actionName.lower();
   if(name == Latin1Literal("append")) {
     return Import::Append;
   } else if(name == Latin1Literal("merge")) {
@@ -32,8 +32,8 @@ Tellico::Import::Action ApplicationInterface::actionType(const QString& actionNa
   return Import::Replace;
 }
 
-QValueList<long> ApplicationInterface::selectedEntries() const {
-  QValueList<long> ids;
+TQValueList<long> ApplicationInterface::selectedEntries() const {
+  TQValueList<long> ids;
   Data::EntryVec entries = Controller::self()->selectedEntries();
   for(Data::EntryVecIt entry = entries.begin(); entry != entries.end(); ++entry) {
     ids << entry->id();
@@ -41,8 +41,8 @@ QValueList<long> ApplicationInterface::selectedEntries() const {
   return ids;
 }
 
-QValueList<long> ApplicationInterface::filteredEntries() const {
-  QValueList<long> ids;
+TQValueList<long> ApplicationInterface::filteredEntries() const {
+  TQValueList<long> ids;
   Data::EntryVec entries = Controller::self()->visibleEntries();
   for(Data::EntryVecIt entry = entries.begin(); entry != entries.end(); ++entry) {
     ids << entry->id();
@@ -73,8 +73,8 @@ bool CollectionInterface::removeEntry(long id_) {
   return coll->entryById(id_) == 0;
 }
 
-QStringList CollectionInterface::values(const QString& fieldName_) const {
-  QStringList results;
+TQStringList CollectionInterface::values(const TQString& fieldName_) const {
+  TQStringList results;
   Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll) {
     return results;
@@ -93,8 +93,8 @@ QStringList CollectionInterface::values(const QString& fieldName_) const {
   return results;
 }
 
-QStringList CollectionInterface::values(long id_, const QString& fieldName_) const {
-  QStringList results;
+TQStringList CollectionInterface::values(long id_, const TQString& fieldName_) const {
+  TQStringList results;
   Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll) {
     return results;
@@ -113,27 +113,27 @@ QStringList CollectionInterface::values(long id_, const QString& fieldName_) con
   return results;
 }
 
-QStringList CollectionInterface::bibtexKeys() const {
+TQStringList CollectionInterface::bibtexKeys() const {
   Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll || coll->type() != Data::Collection::Bibtex) {
-    return QStringList();
+    return TQStringList();
   }
   return BibtexHandler::bibtexKeys(Controller::self()->selectedEntries());
 }
 
-QString CollectionInterface::bibtexKey(long id_) const {
+TQString CollectionInterface::bibtexKey(long id_) const {
   Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll || coll->type() != Data::Collection::Bibtex) {
-    return QString();
+    return TQString();
   }
   Data::EntryPtr entry = coll->entryById(id_);
   if(!entry) {
-    return QString();
+    return TQString();
   }
   return BibtexHandler::bibtexKeys(entry).first();
 }
 
-bool CollectionInterface::setFieldValue(long id_, const QString& fieldName_, const QString& value_) {
+bool CollectionInterface::setFieldValue(long id_, const TQString& fieldName_, const TQString& value_) {
   Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll) {
     return false;
@@ -150,7 +150,7 @@ bool CollectionInterface::setFieldValue(long id_, const QString& fieldName_, con
   return true;
 }
 
-bool CollectionInterface::addFieldValue(long id_, const QString& fieldName_, const QString& value_) {
+bool CollectionInterface::addFieldValue(long id_, const TQString& fieldName_, const TQString& value_) {
   Data::CollPtr coll = Data::Document::self()->collection();
   if(!coll) {
     return false;
@@ -160,10 +160,10 @@ bool CollectionInterface::addFieldValue(long id_, const QString& fieldName_, con
     return false;
   }
   Data::EntryPtr oldEntry = new Data::Entry(*entry);
-  QStringList values = entry->fields(fieldName_, false);
-  QStringList newValues = values;
+  TQStringList values = entry->fields(fieldName_, false);
+  TQStringList newValues = values;
   newValues << value_;
-  if(!entry->setField(fieldName_, newValues.join(QString::fromLatin1("; ")))) {
+  if(!entry->setField(fieldName_, newValues.join(TQString::tqfromLatin1("; ")))) {
     return false;
   }
   Kernel::self()->modifyEntries(oldEntry, entry);
diff --git a/src/core/dcopinterface.h b/src/core/dcopinterface.h
index 018de80..e0c6c73 100644
--- a/src/core/dcopinterface.h
+++ b/src/core/dcopinterface.h
@@ -19,40 +19,40 @@
 #include <dcopobject.h>
 #include <kurl.h>
 
-#include <qstringlist.h> // used in generated dcopinterface_skel.cpp
+#include <tqstringlist.h> // used in generated dcopinterface_skel.cpp
 
 namespace Tellico {
 
 class ApplicationInterface : public DCOPObject {
 K_DCOP
 k_dcop:
-  bool importTellico(const QString& file, const QString& action)
+  bool importTellico(const TQString& file, const TQString& action)
     { return importFile(Import::TellicoXML, KURL::fromPathOrURL(file), actionType(action)); }
-  bool importBibtex(const QString& file, const QString& action)
+  bool importBibtex(const TQString& file, const TQString& action)
     { return importFile(Import::Bibtex, KURL::fromPathOrURL(file), actionType(action)); }
-  bool importMODS(const QString& file, const QString& action)
+  bool importMODS(const TQString& file, const TQString& action)
     { return importFile(Import::MODS, KURL::fromPathOrURL(file), actionType(action)); }
-  bool importRIS(const QString& file, const QString& action)
+  bool importRIS(const TQString& file, const TQString& action)
     { return importFile(Import::RIS, KURL::fromPathOrURL(file), actionType(action)); }
 
-  bool exportXML(const QString& file)
+  bool exportXML(const TQString& file)
     { return exportCollection(Export::TellicoXML, KURL::fromPathOrURL(file)); }
-  bool exportZip(const QString& file)
+  bool exportZip(const TQString& file)
     { return exportCollection(Export::TellicoZip, KURL::fromPathOrURL(file)); }
-  bool exportBibtex(const QString& file)
+  bool exportBibtex(const TQString& file)
     { return exportCollection(Export::Bibtex, KURL::fromPathOrURL(file)); }
-  bool exportHTML(const QString& file)
+  bool exportHTML(const TQString& file)
     { return exportCollection(Export::HTML, KURL::fromPathOrURL(file)); }
-  bool exportCSV(const QString& file)
+  bool exportCSV(const TQString& file)
     { return exportCollection(Export::CSV, KURL::fromPathOrURL(file)); }
-  bool exportPilotDB(const QString& file)
+  bool exportPilotDB(const TQString& file)
     { return exportCollection(Export::PilotDB, KURL::fromPathOrURL(file)); }
 
-  QValueList<long> selectedEntries() const;
-  QValueList<long> filteredEntries() const;
+  TQValueList<long> selectedEntries() const;
+  TQValueList<long> filteredEntries() const;
 
-  virtual void openFile(const QString& file) = 0;
-  virtual void setFilter(const QString& text) = 0;
+  virtual void openFile(const TQString& file) = 0;
+  virtual void setFilter(const TQString& text) = 0;
   virtual bool showEntry(long id) = 0;
 
 protected:
@@ -61,24 +61,27 @@ protected:
   virtual bool exportCollection(Export::Format format, const KURL& url) = 0;
 
 private:
-  Import::Action actionType(const QString& actionName);
+  Import::Action actionType(const TQString& actionName);
 };
 
 class CollectionInterface : public DCOPObject {
 K_DCOP
 k_dcop:
-  CollectionInterface() : DCOPObject("collection") {}
-
   long addEntry();
   bool removeEntry(long entryID);
 
-  QStringList values(const QString& fieldName) const;
-  QStringList values(long entryID, const QString& fieldName) const;
-  QStringList bibtexKeys() const;
-  QString bibtexKey(long entryID) const;
+  TQStringList values(const TQString& fieldName) const;
+  TQStringList values(long entryID, const TQString& fieldName) const;
+  TQStringList bibtexKeys() const;
+  TQString bibtexKey(long entryID) const;
+
+  bool setFieldValue(long entryID, const TQString& fieldName, const TQString& value);
+  bool addFieldValue(long entryID, const TQString& fieldName, const TQString& value);
 
-  bool setFieldValue(long entryID, const QString& fieldName, const QString& value);
-  bool addFieldValue(long entryID, const QString& fieldName, const QString& value);
+  friend class MainWindow;
+
+protected:
+  CollectionInterface() : DCOPObject("collection") {}
 };
 
 } // end namespace
diff --git a/src/core/dcopinterface_skel.cpp b/src/core/dcopinterface_skel.cpp
index 9edf4ad..49bdce0 100644
--- a/src/core/dcopinterface_skel.cpp
+++ b/src/core/dcopinterface_skel.cpp
@@ -9,26 +9,26 @@
 #include "./dcopinterface.h"
 
 #include <kdatastream.h>
-#include <qasciidict.h>
+#include <tqasciidict.h>
 
 namespace Tellico {
 
 static const int ApplicationInterface_fhash = 17;
 static const char* const ApplicationInterface_ftable[16][3] = {
-    { "bool", "importTellico(QString,QString)", "importTellico(QString file,QString action)" },
-    { "bool", "importBibtex(QString,QString)", "importBibtex(QString file,QString action)" },
-    { "bool", "importMODS(QString,QString)", "importMODS(QString file,QString action)" },
-    { "bool", "importRIS(QString,QString)", "importRIS(QString file,QString action)" },
-    { "bool", "exportXML(QString)", "exportXML(QString file)" },
-    { "bool", "exportZip(QString)", "exportZip(QString file)" },
-    { "bool", "exportBibtex(QString)", "exportBibtex(QString file)" },
-    { "bool", "exportHTML(QString)", "exportHTML(QString file)" },
-    { "bool", "exportCSV(QString)", "exportCSV(QString file)" },
-    { "bool", "exportPilotDB(QString)", "exportPilotDB(QString file)" },
-    { "QValueList<long int>", "selectedEntries()", "selectedEntries()" },
-    { "QValueList<long int>", "filteredEntries()", "filteredEntries()" },
-    { "void", "openFile(QString)", "openFile(QString file)" },
-    { "void", "setFilter(QString)", "setFilter(QString text)" },
+    { "bool", "importTellico(TQString,TQString)", "importTellico(TQString file,TQString action)" },
+    { "bool", "importBibtex(TQString,TQString)", "importBibtex(TQString file,TQString action)" },
+    { "bool", "importMODS(TQString,TQString)", "importMODS(TQString file,TQString action)" },
+    { "bool", "importRIS(TQString,TQString)", "importRIS(TQString file,TQString action)" },
+    { "bool", "exportXML(TQString)", "exportXML(TQString file)" },
+    { "bool", "exportZip(TQString)", "exportZip(TQString file)" },
+    { "bool", "exportBibtex(TQString)", "exportBibtex(TQString file)" },
+    { "bool", "exportHTML(TQString)", "exportHTML(TQString file)" },
+    { "bool", "exportCSV(TQString)", "exportCSV(TQString file)" },
+    { "bool", "exportPilotDB(TQString)", "exportPilotDB(TQString file)" },
+    { "TQValueList<long int>", "selectedEntries()", "selectedEntries()" },
+    { "TQValueList<long int>", "filteredEntries()", "filteredEntries()" },
+    { "void", "openFile(TQString)", "openFile(TQString file)" },
+    { "void", "setFilter(TQString)", "setFilter(TQString text)" },
     { "bool", "showEntry(long int)", "showEntry(long int id)" },
     { 0, 0, 0 }
 };
@@ -50,139 +50,139 @@ static const int ApplicationInterface_ftable_hiddens[15] = {
     0,
 };
 
-bool ApplicationInterface::process(const QCString &fun, const QByteArray &data, QCString& replyType, QByteArray &replyData)
+bool ApplicationInterface::process(const TQCString &fun, const TQByteArray &data, TQCString& replyType, TQByteArray &replyData)
 {
-    static QAsciiDict<int>* fdict = 0;
+    static TQAsciiDict<int>* fdict = 0;
     if ( !fdict ) {
-	fdict = new QAsciiDict<int>( ApplicationInterface_fhash, true, false );
+	fdict = new TQAsciiDict<int>( ApplicationInterface_fhash, true, false );
 	for ( int i = 0; ApplicationInterface_ftable[i][1]; i++ )
 	    fdict->insert( ApplicationInterface_ftable[i][1],  new int( i ) );
     }
-    int* fp = fdict->find( fun );
+    int* fp = fdict->tqfind( fun );
     switch ( fp?*fp:-1) {
-    case 0: { // bool importTellico(QString,QString)
-	QString arg0;
-	QString arg1;
-	QDataStream arg( data, IO_ReadOnly );
+    case 0: { // bool importTellico(TQString,TQString)
+	TQString arg0;
+	TQString arg1;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	if (arg.atEnd()) return false;
 	arg >> arg1;
 	replyType = ApplicationInterface_ftable[0][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << importTellico(arg0, arg1 );
     } break;
-    case 1: { // bool importBibtex(QString,QString)
-	QString arg0;
-	QString arg1;
-	QDataStream arg( data, IO_ReadOnly );
+    case 1: { // bool importBibtex(TQString,TQString)
+	TQString arg0;
+	TQString arg1;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	if (arg.atEnd()) return false;
 	arg >> arg1;
 	replyType = ApplicationInterface_ftable[1][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << importBibtex(arg0, arg1 );
     } break;
-    case 2: { // bool importMODS(QString,QString)
-	QString arg0;
-	QString arg1;
-	QDataStream arg( data, IO_ReadOnly );
+    case 2: { // bool importMODS(TQString,TQString)
+	TQString arg0;
+	TQString arg1;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	if (arg.atEnd()) return false;
 	arg >> arg1;
 	replyType = ApplicationInterface_ftable[2][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << importMODS(arg0, arg1 );
     } break;
-    case 3: { // bool importRIS(QString,QString)
-	QString arg0;
-	QString arg1;
-	QDataStream arg( data, IO_ReadOnly );
+    case 3: { // bool importRIS(TQString,TQString)
+	TQString arg0;
+	TQString arg1;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	if (arg.atEnd()) return false;
 	arg >> arg1;
 	replyType = ApplicationInterface_ftable[3][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << importRIS(arg0, arg1 );
     } break;
-    case 4: { // bool exportXML(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 4: { // bool exportXML(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[4][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << exportXML(arg0 );
     } break;
-    case 5: { // bool exportZip(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 5: { // bool exportZip(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[5][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << exportZip(arg0 );
     } break;
-    case 6: { // bool exportBibtex(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 6: { // bool exportBibtex(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[6][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << exportBibtex(arg0 );
     } break;
-    case 7: { // bool exportHTML(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 7: { // bool exportHTML(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[7][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << exportHTML(arg0 );
     } break;
-    case 8: { // bool exportCSV(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 8: { // bool exportCSV(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[8][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << exportCSV(arg0 );
     } break;
-    case 9: { // bool exportPilotDB(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 9: { // bool exportPilotDB(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[9][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << exportPilotDB(arg0 );
     } break;
-    case 10: { // QValueList<long int> selectedEntries()
+    case 10: { // TQValueList<long int> selectedEntries()
 	replyType = ApplicationInterface_ftable[10][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << selectedEntries( );
     } break;
-    case 11: { // QValueList<long int> filteredEntries()
+    case 11: { // TQValueList<long int> filteredEntries()
 	replyType = ApplicationInterface_ftable[11][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << filteredEntries( );
     } break;
-    case 12: { // void openFile(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 12: { // void openFile(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[12][0]; 
 	openFile(arg0 );
     } break;
-    case 13: { // void setFilter(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 13: { // void setFilter(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[13][0]; 
@@ -190,11 +190,11 @@ bool ApplicationInterface::process(const QCString &fun, const QByteArray &data,
     } break;
     case 14: { // bool showEntry(long int)
 	long int arg0;
-	QDataStream arg( data, IO_ReadOnly );
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = ApplicationInterface_ftable[14][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << showEntry(arg0 );
     } break;
     default: 
@@ -216,7 +216,7 @@ QCStringList ApplicationInterface::functions()
     for ( int i = 0; ApplicationInterface_ftable[i][2]; i++ ) {
 	if (ApplicationInterface_ftable_hiddens[i])
 	    continue;
-	QCString func = ApplicationInterface_ftable[i][0];
+	TQCString func = ApplicationInterface_ftable[i][0];
 	func += ' ';
 	func += ApplicationInterface_ftable[i][2];
 	funcs << func;
@@ -227,7 +227,7 @@ QCStringList ApplicationInterface::functions()
 } // namespace
 
 #include <kdatastream.h>
-#include <qasciidict.h>
+#include <tqasciidict.h>
 
 namespace Tellico {
 
@@ -235,12 +235,12 @@ static const int CollectionInterface_fhash = 11;
 static const char* const CollectionInterface_ftable[9][3] = {
     { "long int", "addEntry()", "addEntry()" },
     { "bool", "removeEntry(long int)", "removeEntry(long int entryID)" },
-    { "QStringList", "values(QString)", "values(QString fieldName)" },
-    { "QStringList", "values(long int,QString)", "values(long int entryID,QString fieldName)" },
-    { "QStringList", "bibtexKeys()", "bibtexKeys()" },
-    { "QString", "bibtexKey(long int)", "bibtexKey(long int entryID)" },
-    { "bool", "setFieldValue(long int,QString,QString)", "setFieldValue(long int entryID,QString fieldName,QString value)" },
-    { "bool", "addFieldValue(long int,QString,QString)", "addFieldValue(long int entryID,QString fieldName,QString value)" },
+    { TQSTRINGLIST_OBJECT_NAME_STRING, "values(TQString)", "values(TQString fieldName)" },
+    { TQSTRINGLIST_OBJECT_NAME_STRING, "values(long int,TQString)", "values(long int entryID,TQString fieldName)" },
+    { TQSTRINGLIST_OBJECT_NAME_STRING, "bibtexKeys()", "bibtexKeys()" },
+    { TQSTRING_OBJECT_NAME_STRING, "bibtexKey(long int)", "bibtexKey(long int entryID)" },
+    { "bool", "setFieldValue(long int,TQString,TQString)", "setFieldValue(long int entryID,TQString fieldName,TQString value)" },
+    { "bool", "addFieldValue(long int,TQString,TQString)", "addFieldValue(long int entryID,TQString fieldName,TQString value)" },
     { 0, 0, 0 }
 };
 static const int CollectionInterface_ftable_hiddens[8] = {
@@ -254,70 +254,70 @@ static const int CollectionInterface_ftable_hiddens[8] = {
     0,
 };
 
-bool CollectionInterface::process(const QCString &fun, const QByteArray &data, QCString& replyType, QByteArray &replyData)
+bool CollectionInterface::process(const TQCString &fun, const TQByteArray &data, TQCString& replyType, TQByteArray &replyData)
 {
-    static QAsciiDict<int>* fdict = 0;
+    static TQAsciiDict<int>* fdict = 0;
     if ( !fdict ) {
-	fdict = new QAsciiDict<int>( CollectionInterface_fhash, true, false );
+	fdict = new TQAsciiDict<int>( CollectionInterface_fhash, true, false );
 	for ( int i = 0; CollectionInterface_ftable[i][1]; i++ )
 	    fdict->insert( CollectionInterface_ftable[i][1],  new int( i ) );
     }
-    int* fp = fdict->find( fun );
+    int* fp = fdict->tqfind( fun );
     switch ( fp?*fp:-1) {
     case 0: { // long int addEntry()
 	replyType = CollectionInterface_ftable[0][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << addEntry( );
     } break;
     case 1: { // bool removeEntry(long int)
 	long int arg0;
-	QDataStream arg( data, IO_ReadOnly );
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = CollectionInterface_ftable[1][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << removeEntry(arg0 );
     } break;
-    case 2: { // QStringList values(QString)
-	QString arg0;
-	QDataStream arg( data, IO_ReadOnly );
+    case 2: { // TQStringList values(TQString)
+	TQString arg0;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = CollectionInterface_ftable[2][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << values(arg0 );
     } break;
-    case 3: { // QStringList values(long int,QString)
+    case 3: { // TQStringList values(long int,TQString)
 	long int arg0;
-	QString arg1;
-	QDataStream arg( data, IO_ReadOnly );
+	TQString arg1;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	if (arg.atEnd()) return false;
 	arg >> arg1;
 	replyType = CollectionInterface_ftable[3][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << values(arg0, arg1 );
     } break;
-    case 4: { // QStringList bibtexKeys()
+    case 4: { // TQStringList bibtexKeys()
 	replyType = CollectionInterface_ftable[4][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << bibtexKeys( );
     } break;
-    case 5: { // QString bibtexKey(long int)
+    case 5: { // TQString bibtexKey(long int)
 	long int arg0;
-	QDataStream arg( data, IO_ReadOnly );
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	replyType = CollectionInterface_ftable[5][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << bibtexKey(arg0 );
     } break;
-    case 6: { // bool setFieldValue(long int,QString,QString)
+    case 6: { // bool setFieldValue(long int,TQString,TQString)
 	long int arg0;
-	QString arg1;
-	QString arg2;
-	QDataStream arg( data, IO_ReadOnly );
+	TQString arg1;
+	TQString arg2;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	if (arg.atEnd()) return false;
@@ -325,14 +325,14 @@ bool CollectionInterface::process(const QCString &fun, const QByteArray &data, Q
 	if (arg.atEnd()) return false;
 	arg >> arg2;
 	replyType = CollectionInterface_ftable[6][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << setFieldValue(arg0, arg1, arg2 );
     } break;
-    case 7: { // bool addFieldValue(long int,QString,QString)
+    case 7: { // bool addFieldValue(long int,TQString,TQString)
 	long int arg0;
-	QString arg1;
-	QString arg2;
-	QDataStream arg( data, IO_ReadOnly );
+	TQString arg1;
+	TQString arg2;
+	TQDataStream arg( data, IO_ReadOnly );
 	if (arg.atEnd()) return false;
 	arg >> arg0;
 	if (arg.atEnd()) return false;
@@ -340,7 +340,7 @@ bool CollectionInterface::process(const QCString &fun, const QByteArray &data, Q
 	if (arg.atEnd()) return false;
 	arg >> arg2;
 	replyType = CollectionInterface_ftable[7][0]; 
-	QDataStream _replyStream( replyData, IO_WriteOnly );
+	TQDataStream _replyStream( replyData, IO_WriteOnly );
 	_replyStream << addFieldValue(arg0, arg1, arg2 );
     } break;
     default: 
@@ -362,7 +362,7 @@ QCStringList CollectionInterface::functions()
     for ( int i = 0; CollectionInterface_ftable[i][2]; i++ ) {
 	if (CollectionInterface_ftable_hiddens[i])
 	    continue;
-	QCString func = CollectionInterface_ftable[i][0];
+	TQCString func = CollectionInterface_ftable[i][0];
 	func += ' ';
 	func += CollectionInterface_ftable[i][2];
 	funcs << func;
diff --git a/src/core/drophandler.cpp b/src/core/drophandler.cpp
index e27df9d..6deb2e1 100644
--- a/src/core/drophandler.cpp
+++ b/src/core/drophandler.cpp
@@ -21,7 +21,7 @@
 
 using Tellico::DropHandler;
 
-DropHandler::DropHandler(QObject* parent_) : QObject(parent_) {
+DropHandler::DropHandler(TQObject* tqparent_) : TQObject(tqparent_) {
 }
 
 DropHandler::~DropHandler() {
@@ -29,30 +29,30 @@ DropHandler::~DropHandler() {
 
 // assume the object is always the main window, that's the
 // only object with this event filter
-bool DropHandler::eventFilter(QObject* obj_, QEvent* ev_) {
+bool DropHandler::eventFilter(TQObject* obj_, TQEvent* ev_) {
   Q_UNUSED(obj_);
-  if(ev_->type() == QEvent::DragEnter) {
-    return dragEnter(static_cast<QDragEnterEvent*>(ev_));
-  } else if(ev_->type() == QEvent::Drop) {
-    return drop(static_cast<QDropEvent*>(ev_));
+  if(ev_->type() == TQEvent::DragEnter) {
+    return dragEnter(static_cast<TQDragEnterEvent*>(ev_));
+  } else if(ev_->type() == TQEvent::Drop) {
+    return drop(static_cast<TQDropEvent*>(ev_));
   }
   return false;
 }
 
-bool DropHandler::dragEnter(QDragEnterEvent* event_) {
-  bool accept = KURLDrag::canDecode(event_) || QTextDrag::canDecode(event_);
+bool DropHandler::dragEnter(TQDragEnterEvent* event_) {
+  bool accept = KURLDrag::canDecode(event_) || TQTextDrag::canDecode(event_);
   if(accept) {
     event_->accept(accept);
   }
   return accept;
 }
 
-bool DropHandler::drop(QDropEvent* event_) {
+bool DropHandler::drop(TQDropEvent* event_) {
   KURL::List urls;
-  QString text;
+  TQString text;
 
   if(KURLDrag::decode(event_, urls)) {
-  } else if(QTextDrag::decode(event_, text) && !text.isEmpty()) {
+  } else if(TQTextDrag::decode(event_, text) && !text.isEmpty()) {
     urls << KURL(text);
   }
   return !urls.isEmpty() && handleURL(urls);
@@ -63,21 +63,21 @@ bool DropHandler::handleURL(const KURL::List& urls_) {
   KURL::List tc, pdf, bib, ris;
   for(KURL::List::ConstIterator it = urls_.begin(); it != urls_.end(); ++it) {
     KMimeType::Ptr ptr = KMimeType::findByURL(*it);
-    if(ptr->is(QString::fromLatin1("application/x-tellico"))) {
+    if(ptr->is(TQString::tqfromLatin1("application/x-tellico"))) {
       tc << *it;
-    } else if(ptr->is(QString::fromLatin1("application/pdf"))) {
+    } else if(ptr->is(TQString::tqfromLatin1("application/pdf"))) {
       pdf << *it;
-    } else if(ptr->is(QString::fromLatin1("text/x-bibtex")) ||
-              ptr->is(QString::fromLatin1("application/x-bibtex"))) {
+    } else if(ptr->is(TQString::tqfromLatin1("text/x-bibtex")) ||
+              ptr->is(TQString::tqfromLatin1("application/x-bibtex"))) {
       bib << *it;
-    } else if(ptr->is(QString::fromLatin1("application/x-research-info-systems"))) {
+    } else if(ptr->is(TQString::tqfromLatin1("application/x-research-info-systems"))) {
       ris << *it;
     } else {
       myDebug() << "DropHandler::handleURL() - unrecognized type: " << ptr->name() << " (" << *it << ")" << endl;
       hasUnknown = true;
     }
   }
-  MainWindow* mainWindow = ::qt_cast<MainWindow*>(Kernel::self()->widget());
+  MainWindow* mainWindow = ::tqqt_cast<MainWindow*>(Kernel::self()->widget());
   if(!mainWindow) {
     myDebug() << "DropHandler::handleURL() - no main window!" << endl;
     return !hasUnknown;
diff --git a/src/core/drophandler.h b/src/core/drophandler.h
index ac4d146..0c64659 100644
--- a/src/core/drophandler.h
+++ b/src/core/drophandler.h
@@ -14,24 +14,25 @@
 #ifndef TELLICO_DROPHANDLER_H
 #define TELLICO_DROPHANDLER_H
 
-#include <qobject.h>
+#include <tqobject.h>
 #include <kurl.h>
 
 namespace Tellico {
 
-class DropHandler : public QObject {
+class DropHandler : public TQObject {
 Q_OBJECT
+  TQ_OBJECT
 
 public:
-  DropHandler(QObject* parent);
+  DropHandler(TQObject* tqparent);
   ~DropHandler();
 
 protected:
-  bool eventFilter(QObject* object, QEvent* event);
+  bool eventFilter(TQObject* object, TQEvent* event);
 
 private:
-  bool dragEnter(QDragEnterEvent* event);
-  bool drop(QDropEvent* event);
+  bool dragEnter(TQDragEnterEvent* event);
+  bool drop(TQDropEvent* event);
   bool handleURL(const KURL::List& urls);
 };
 
diff --git a/src/core/netaccess.cpp b/src/core/netaccess.cpp
index 77b6554..ef756cc 100644
--- a/src/core/netaccess.cpp
+++ b/src/core/netaccess.cpp
@@ -22,16 +22,16 @@
 #include <kio/previewjob.h>
 #include <ktempfile.h>
 
-#include <qapplication.h>
-#include <qfile.h>
+#include <tqapplication.h>
+#include <tqfile.h>
 
 #include <unistd.h> // for unlink()
 
 using Tellico::NetAccess;
 
-QStringList* NetAccess::s_tmpFiles = 0;
+TQStringList* NetAccess::s_tmpFiles = 0;
 
-bool NetAccess::download(const KURL& url_, QString& target_, QWidget* window_) {
+bool NetAccess::download(const KURL& url_, TQString& target_, TQWidget* window_) {
   if(url_.isLocalFile()) {
     return KIO::NetAccess::download(url_, target_, window_);
   }
@@ -45,7 +45,7 @@ bool NetAccess::download(const KURL& url_, QString& target_, QWidget* window_) {
     KTempFile tmpFile;
     target_ = tmpFile.name();
     if(!s_tmpFiles) {
-      s_tmpFiles = new QStringList;
+      s_tmpFiles = new TQStringList;
     }
     s_tmpFiles->append(target_);
   }
@@ -57,43 +57,43 @@ bool NetAccess::download(const KURL& url_, QString& target_, QWidget* window_) {
   return KIO::NetAccess::synchronousRun(job, window_);
 }
 
-void NetAccess::removeTempFile(const QString& name_) {
+void NetAccess::removeTempFile(const TQString& name_) {
   if(!s_tmpFiles) {
     return;
   }
-  if(s_tmpFiles->contains(name_)) {
-    ::unlink(QFile::encodeName(name_));
+  if(s_tmpFiles->tqcontains(name_)) {
+    ::unlink(TQFile::encodeName(name_));
     s_tmpFiles->remove(name_);
   }
 }
 
-QPixmap NetAccess::filePreview(const KURL& url, int size) {
+TQPixmap NetAccess::filePreview(const KURL& url, int size) {
   NetAccess netaccess;
 
   KURL::List list;
   list.append(url);
   KIO::Job* previewJob = KIO::filePreview(list, size, size);
-  connect(previewJob, SIGNAL(gotPreview(const KFileItem*, const QPixmap&)),
-          &netaccess, SLOT(slotPreview(const KFileItem*, const QPixmap&)));
+  connect(previewJob, TQT_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)),
+          &netaccess, TQT_SLOT(slotPreview(const KFileItem*, const TQPixmap&)));
 
   KIO::NetAccess::synchronousRun(previewJob, Kernel::self()->widget());
   return netaccess.m_preview;
 }
 
-QPixmap NetAccess::filePreview(KFileItem* item, int size) {
+TQPixmap NetAccess::filePreview(KFileItem* item, int size) {
   NetAccess netaccess;
 
   KFileItemList list;
   list.append(item);
   KIO::Job* previewJob = KIO::filePreview(list, size, size);
-  connect(previewJob, SIGNAL(gotPreview(const KFileItem*, const QPixmap&)),
-          &netaccess, SLOT(slotPreview(const KFileItem*, const QPixmap&)));
+  connect(previewJob, TQT_SIGNAL(gotPreview(const KFileItem*, const TQPixmap&)),
+          &netaccess, TQT_SLOT(slotPreview(const KFileItem*, const TQPixmap&)));
 
   KIO::NetAccess::synchronousRun(previewJob, Kernel::self()->widget());
   return netaccess.m_preview;
 }
 
-void NetAccess::slotPreview(const KFileItem*, const QPixmap& pix_) {
+void NetAccess::slotPreview(const KFileItem*, const TQPixmap& pix_) {
   m_preview = pix_;
 }
 
diff --git a/src/core/netaccess.h b/src/core/netaccess.h
index df11e0d..f793674 100644
--- a/src/core/netaccess.h
+++ b/src/core/netaccess.h
@@ -14,8 +14,8 @@
 #ifndef TELLICO_NETACCESS_H
 #define TELLICO_NETACCESS_H
 
-#include <qobject.h>
-#include <qpixmap.h>
+#include <tqobject.h>
+#include <tqpixmap.h>
 
 class KURL;
 class KFileItem;
@@ -25,22 +25,23 @@ namespace KIO {
 
 namespace Tellico {
 
-class NetAccess : public QObject {
+class NetAccess : public TQObject {
 Q_OBJECT
+  TQ_OBJECT
 
 public:
-  static bool download(const KURL& u, QString& target, QWidget* window);
-  static void removeTempFile(const QString& name);
-  static QPixmap filePreview(const KURL& fileName, int size=196);
-  static QPixmap filePreview(KFileItem* item, int size=196);
+  static bool download(const KURL& u, TQString& target, TQWidget* window);
+  static void removeTempFile(const TQString& name);
+  static TQPixmap filePreview(const KURL& fileName, int size=196);
+  static TQPixmap filePreview(KFileItem* item, int size=196);
 
 private slots:
-  void slotPreview(const KFileItem* item, const QPixmap& pix);
+  void slotPreview(const KFileItem* item, const TQPixmap& pix);
 
 private:
-  static QStringList* s_tmpFiles;
+  static TQStringList* s_tmpFiles;
 
-  QPixmap m_preview;
+  TQPixmap m_preview;
 };
 
 }
diff --git a/src/core/tellico_config.cpp b/src/core/tellico_config.cpp
index f2050f0..4984cdb 100644
--- a/src/core/tellico_config.cpp
+++ b/src/core/tellico_config.cpp
@@ -21,430 +21,430 @@ Config *Config::self()
 }
 
 Config::Config(  )
-  : KConfigSkeleton( QString::fromLatin1( "tellicorc" ) )
+  : KConfigSkeleton( TQString::tqfromLatin1( "tellicorc" ) )
 {
   mSelf = this;
-  setCurrentGroup( QString::fromLatin1( "TipOfDay" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "TipOfDay" ) );
 
   KConfigSkeleton::ItemBool  *itemShowTipOfDay;
-  itemShowTipOfDay = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "RunOnStart" ), mShowTipOfDay, true );
-  addItem( itemShowTipOfDay, QString::fromLatin1( "showTipOfDay" ) );
+  itemShowTipOfDay = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "RunOnStart" ), mShowTipOfDay, true );
+  addItem( itemShowTipOfDay, TQString::tqfromLatin1( "showTipOfDay" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Main Window Options" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Main Window Options" ) );
 
-  QValueList<int> defaultMainSplitterSizes;
+  TQValueList<int> defaultMainSplitterSizes;
 
   KConfigSkeleton::ItemIntList  *itemMainSplitterSizes;
-  itemMainSplitterSizes = new KConfigSkeleton::ItemIntList( currentGroup(), QString::fromLatin1( "Main Splitter Sizes" ), mMainSplitterSizes, defaultMainSplitterSizes );
-  addItem( itemMainSplitterSizes, QString::fromLatin1( "MainSplitterSizes" ) );
-  QValueList<int> defaultSecondarySplitterSizes;
+  itemMainSplitterSizes = new KConfigSkeleton::ItemIntList( currentGroup(), TQString::tqfromLatin1( "Main Splitter Sizes" ), mMainSplitterSizes, defaultMainSplitterSizes );
+  addItem( itemMainSplitterSizes, TQString::tqfromLatin1( "MainSplitterSizes" ) );
+  TQValueList<int> defaultSecondarySplitterSizes;
 
   KConfigSkeleton::ItemIntList  *itemSecondarySplitterSizes;
-  itemSecondarySplitterSizes = new KConfigSkeleton::ItemIntList( currentGroup(), QString::fromLatin1( "Secondary Splitter Sizes" ), mSecondarySplitterSizes, defaultSecondarySplitterSizes );
-  addItem( itemSecondarySplitterSizes, QString::fromLatin1( "SecondarySplitterSizes" ) );
+  itemSecondarySplitterSizes = new KConfigSkeleton::ItemIntList( currentGroup(), TQString::tqfromLatin1( "Secondary Splitter Sizes" ), mSecondarySplitterSizes, defaultSecondarySplitterSizes );
+  addItem( itemSecondarySplitterSizes, TQString::tqfromLatin1( "SecondarySplitterSizes" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Detailed View Options" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Detailed View Options" ) );
 
   KConfigSkeleton::ItemInt  *itemMaxPixmapWidth;
-  itemMaxPixmapWidth = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "MaxPixmapWidth" ), mMaxPixmapWidth, 50 );
-  addItem( itemMaxPixmapWidth, QString::fromLatin1( "MaxPixmapWidth" ) );
+  itemMaxPixmapWidth = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "MaxPixmapWidth" ), mMaxPixmapWidth, 50 );
+  addItem( itemMaxPixmapWidth, TQString::tqfromLatin1( "MaxPixmapWidth" ) );
   KConfigSkeleton::ItemInt  *itemMaxPixmapHeight;
-  itemMaxPixmapHeight = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "MaxPixmapHeight" ), mMaxPixmapHeight, 50 );
-  addItem( itemMaxPixmapHeight, QString::fromLatin1( "MaxPixmapHeight" ) );
+  itemMaxPixmapHeight = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "MaxPixmapHeight" ), mMaxPixmapHeight, 50 );
+  addItem( itemMaxPixmapHeight, TQString::tqfromLatin1( "MaxPixmapHeight" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Group View Options" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Group View Options" ) );
 
   KConfigSkeleton::ItemInt  *itemGroupViewSortColumn;
-  itemGroupViewSortColumn = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "SortColumn" ), mGroupViewSortColumn, 0 );
-  addItem( itemGroupViewSortColumn, QString::fromLatin1( "groupViewSortColumn" ) );
+  itemGroupViewSortColumn = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "SortColumn" ), mGroupViewSortColumn, 0 );
+  addItem( itemGroupViewSortColumn, TQString::tqfromLatin1( "groupViewSortColumn" ) );
   KConfigSkeleton::ItemBool  *itemGroupViewSortAscending;
-  itemGroupViewSortAscending = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "SortAscending" ), mGroupViewSortAscending, true );
-  addItem( itemGroupViewSortAscending, QString::fromLatin1( "groupViewSortAscending" ) );
+  itemGroupViewSortAscending = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "SortAscending" ), mGroupViewSortAscending, true );
+  addItem( itemGroupViewSortAscending, TQString::tqfromLatin1( "groupViewSortAscending" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Filter View Options" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Filter View Options" ) );
 
   KConfigSkeleton::ItemInt  *itemFilterViewSortColumn;
-  itemFilterViewSortColumn = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "SortColumn" ), mFilterViewSortColumn, 0 );
-  addItem( itemFilterViewSortColumn, QString::fromLatin1( "filterViewSortColumn" ) );
+  itemFilterViewSortColumn = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "SortColumn" ), mFilterViewSortColumn, 0 );
+  addItem( itemFilterViewSortColumn, TQString::tqfromLatin1( "filterViewSortColumn" ) );
   KConfigSkeleton::ItemBool  *itemFilterViewSortAscending;
-  itemFilterViewSortAscending = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "SortAscending" ), mFilterViewSortAscending, true );
-  addItem( itemFilterViewSortAscending, QString::fromLatin1( "filterViewSortAscending" ) );
+  itemFilterViewSortAscending = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "SortAscending" ), mFilterViewSortAscending, true );
+  addItem( itemFilterViewSortAscending, TQString::tqfromLatin1( "filterViewSortAscending" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Loan View Options" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Loan View Options" ) );
 
   KConfigSkeleton::ItemInt  *itemLoanViewSortColumn;
-  itemLoanViewSortColumn = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "SortColumn" ), mLoanViewSortColumn, 0 );
-  addItem( itemLoanViewSortColumn, QString::fromLatin1( "loanViewSortColumn" ) );
+  itemLoanViewSortColumn = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "SortColumn" ), mLoanViewSortColumn, 0 );
+  addItem( itemLoanViewSortColumn, TQString::tqfromLatin1( "loanViewSortColumn" ) );
   KConfigSkeleton::ItemBool  *itemLoanViewSortAscending;
-  itemLoanViewSortAscending = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "SortAscending" ), mLoanViewSortAscending, true );
-  addItem( itemLoanViewSortAscending, QString::fromLatin1( "loanViewSortAscending" ) );
+  itemLoanViewSortAscending = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "SortAscending" ), mLoanViewSortAscending, true );
+  addItem( itemLoanViewSortAscending, TQString::tqfromLatin1( "loanViewSortAscending" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Export Options - Bibtex" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Export Options - Bibtex" ) );
 
   KConfigSkeleton::ItemBool  *itemUseBraces;
-  itemUseBraces = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Use Braces" ), mUseBraces, true );
-  addItem( itemUseBraces, QString::fromLatin1( "UseBraces" ) );
+  itemUseBraces = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Use Braces" ), mUseBraces, true );
+  addItem( itemUseBraces, TQString::tqfromLatin1( "UseBraces" ) );
 
-  setCurrentGroup( QString::fromLatin1( "General Options" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "General Options" ) );
 
   KConfigSkeleton::ItemBool  *itemShowGroupWidget;
-  itemShowGroupWidget = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Show Group Widget" ), mShowGroupWidget, true );
-  addItem( itemShowGroupWidget, QString::fromLatin1( "ShowGroupWidget" ) );
+  itemShowGroupWidget = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Show Group Widget" ), mShowGroupWidget, true );
+  addItem( itemShowGroupWidget, TQString::tqfromLatin1( "ShowGroupWidget" ) );
   KConfigSkeleton::ItemBool  *itemShowEditWidget;
-  itemShowEditWidget = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Show Edit Widget" ), mShowEditWidget, false );
-  addItem( itemShowEditWidget, QString::fromLatin1( "ShowEditWidget" ) );
+  itemShowEditWidget = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Show Edit Widget" ), mShowEditWidget, false );
+  addItem( itemShowEditWidget, TQString::tqfromLatin1( "ShowEditWidget" ) );
   KConfigSkeleton::ItemBool  *itemShowEntryView;
-  itemShowEntryView = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Show Entry View" ), mShowEntryView, true );
-  addItem( itemShowEntryView, QString::fromLatin1( "ShowEntryView" ) );
-  QValueList<KConfigSkeleton::ItemEnum::Choice> valuesImageLocation;
+  itemShowEntryView = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Show Entry View" ), mShowEntryView, true );
+  addItem( itemShowEntryView, TQString::tqfromLatin1( "ShowEntryView" ) );
+  TQValueList<KConfigSkeleton::ItemEnum::Choice> valuesImageLocation;
   {
     KConfigSkeleton::ItemEnum::Choice choice;
-    choice.name = QString::fromLatin1( "ImagesInFile" );
+    choice.name = TQString::tqfromLatin1( "ImagesInFile" );
     valuesImageLocation.append( choice );
   }
   {
     KConfigSkeleton::ItemEnum::Choice choice;
-    choice.name = QString::fromLatin1( "ImagesInAppDir" );
+    choice.name = TQString::tqfromLatin1( "ImagesInAppDir" );
     valuesImageLocation.append( choice );
   }
   {
     KConfigSkeleton::ItemEnum::Choice choice;
-    choice.name = QString::fromLatin1( "ImagesInLocalDir" );
+    choice.name = TQString::tqfromLatin1( "ImagesInLocalDir" );
     valuesImageLocation.append( choice );
   }
   KConfigSkeleton::ItemEnum  *itemImageLocation;
-  itemImageLocation = new KConfigSkeleton::ItemEnum( currentGroup(), QString::fromLatin1( "Image Location" ), mImageLocation, valuesImageLocation, ImagesInFile );
-  addItem( itemImageLocation, QString::fromLatin1( "ImageLocation" ) );
+  itemImageLocation = new KConfigSkeleton::ItemEnum( currentGroup(), TQString::tqfromLatin1( "Image Location" ), mImageLocation, valuesImageLocation, ImagesInFile );
+  addItem( itemImageLocation, TQString::tqfromLatin1( "ImageLocation" ) );
   KConfigSkeleton::ItemBool  *itemAskWriteImagesInFile;
-  itemAskWriteImagesInFile = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Ask Write Images In File" ), mAskWriteImagesInFile, true );
-  addItem( itemAskWriteImagesInFile, QString::fromLatin1( "AskWriteImagesInFile" ) );
+  itemAskWriteImagesInFile = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Ask Write Images In File" ), mAskWriteImagesInFile, true );
+  addItem( itemAskWriteImagesInFile, TQString::tqfromLatin1( "AskWriteImagesInFile" ) );
   KConfigSkeleton::ItemBool  *itemReopenLastFile;
-  itemReopenLastFile = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Reopen Last File" ), mReopenLastFile, true );
-  addItem( itemReopenLastFile, QString::fromLatin1( "ReopenLastFile" ) );
+  itemReopenLastFile = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Reopen Last File" ), mReopenLastFile, true );
+  addItem( itemReopenLastFile, TQString::tqfromLatin1( "ReopenLastFile" ) );
   KConfigSkeleton::ItemBool  *itemAutoCapitalization;
-  itemAutoCapitalization = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Auto Capitalization" ), mAutoCapitalization, true );
-  addItem( itemAutoCapitalization, QString::fromLatin1( "AutoCapitalization" ) );
+  itemAutoCapitalization = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Auto Capitalization" ), mAutoCapitalization, true );
+  addItem( itemAutoCapitalization, TQString::tqfromLatin1( "AutoCapitalization" ) );
   KConfigSkeleton::ItemBool  *itemAutoFormat;
-  itemAutoFormat = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Auto Format" ), mAutoFormat, true );
-  addItem( itemAutoFormat, QString::fromLatin1( "AutoFormat" ) );
+  itemAutoFormat = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Auto Format" ), mAutoFormat, true );
+  addItem( itemAutoFormat, TQString::tqfromLatin1( "AutoFormat" ) );
   KConfigSkeleton::ItemString  *itemLastOpenFile;
-  itemLastOpenFile = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Last Open File" ), mLastOpenFile );
-  addItem( itemLastOpenFile, QString::fromLatin1( "LastOpenFile" ) );
+  itemLastOpenFile = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Last Open File" ), mLastOpenFile );
+  addItem( itemLastOpenFile, TQString::tqfromLatin1( "LastOpenFile" ) );
   KConfigSkeleton::ItemString  *itemNoCapitalizationString;
-  itemNoCapitalizationString = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "No Capitalization" ), mNoCapitalizationString, i18n("a,an,and,as,at,but,by,for,from,in,into,nor,of,off,on,onto,or,out,over,the,to,up,with") );
-  addItem( itemNoCapitalizationString, QString::fromLatin1( "noCapitalizationString" ) );
+  itemNoCapitalizationString = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "No Capitalization" ), mNoCapitalizationString, i18n("a,an,and,as,at,but,by,for,from,in,into,nor,of,off,on,onto,or,out,over,the,to,up,with") );
+  addItem( itemNoCapitalizationString, TQString::tqfromLatin1( "noCapitalizationString" ) );
   KConfigSkeleton::ItemString  *itemArticlesString;
-  itemArticlesString = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Articles" ), mArticlesString, i18n("the") );
-  addItem( itemArticlesString, QString::fromLatin1( "articlesString" ) );
+  itemArticlesString = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Articles" ), mArticlesString, i18n("the") );
+  addItem( itemArticlesString, TQString::tqfromLatin1( "articlesString" ) );
   KConfigSkeleton::ItemString  *itemNameSuffixesString;
-  itemNameSuffixesString = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Name Suffixes" ), mNameSuffixesString, i18n("jr.,jr,iii,iv") );
-  addItem( itemNameSuffixesString, QString::fromLatin1( "nameSuffixesString" ) );
+  itemNameSuffixesString = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Name Suffixes" ), mNameSuffixesString, i18n("jr.,jr,iii,iv") );
+  addItem( itemNameSuffixesString, TQString::tqfromLatin1( "nameSuffixesString" ) );
   KConfigSkeleton::ItemString  *itemSurnamePrefixesString;
-  itemSurnamePrefixesString = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Surname Prefixes" ), mSurnamePrefixesString, i18n("de,van,der,van der,von") );
-  addItem( itemSurnamePrefixesString, QString::fromLatin1( "surnamePrefixesString" ) );
+  itemSurnamePrefixesString = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Surname Prefixes" ), mSurnamePrefixesString, i18n("de,van,der,van der,von") );
+  addItem( itemSurnamePrefixesString, TQString::tqfromLatin1( "surnamePrefixesString" ) );
   KConfigSkeleton::ItemInt  *itemMaxIconSize;
-  itemMaxIconSize = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "Max Icon Size" ), mMaxIconSize, 96 );
-  addItem( itemMaxIconSize, QString::fromLatin1( "MaxIconSize" ) );
+  itemMaxIconSize = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "Max Icon Size" ), mMaxIconSize, 96 );
+  addItem( itemMaxIconSize, TQString::tqfromLatin1( "MaxIconSize" ) );
   KConfigSkeleton::ItemInt  *itemImageCacheSize;
-  itemImageCacheSize = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "Image Cache Size" ), mImageCacheSize, (10 * 1024 * 1024) );
-  addItem( itemImageCacheSize, QString::fromLatin1( "ImageCacheSize" ) );
+  itemImageCacheSize = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "Image Cache Size" ), mImageCacheSize, (10 * 1024 * 1024) );
+  addItem( itemImageCacheSize, TQString::tqfromLatin1( "ImageCacheSize" ) );
   KConfigSkeleton::ItemUInt  *itemMaxCustomURLSettings;
-  itemMaxCustomURLSettings = new KConfigSkeleton::ItemUInt( currentGroup(), QString::fromLatin1( "Max Custom URL Settings" ), mMaxCustomURLSettings, 9 );
-  addItem( itemMaxCustomURLSettings, QString::fromLatin1( "MaxCustomURLSettings" ) );
+  itemMaxCustomURLSettings = new KConfigSkeleton::ItemUInt( currentGroup(), TQString::tqfromLatin1( "Max Custom URL Settings" ), mMaxCustomURLSettings, 9 );
+  addItem( itemMaxCustomURLSettings, TQString::tqfromLatin1( "MaxCustomURLSettings" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Printing" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Printing" ) );
 
   KConfigSkeleton::ItemBool  *itemPrintFieldHeaders;
-  itemPrintFieldHeaders = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Print Field Headers" ), mPrintFieldHeaders, true );
-  addItem( itemPrintFieldHeaders, QString::fromLatin1( "PrintFieldHeaders" ) );
+  itemPrintFieldHeaders = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Print Field Headers" ), mPrintFieldHeaders, true );
+  addItem( itemPrintFieldHeaders, TQString::tqfromLatin1( "PrintFieldHeaders" ) );
   KConfigSkeleton::ItemBool  *itemPrintFormatted;
-  itemPrintFormatted = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Print Formatted" ), mPrintFormatted, true );
-  addItem( itemPrintFormatted, QString::fromLatin1( "PrintFormatted" ) );
+  itemPrintFormatted = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Print Formatted" ), mPrintFormatted, true );
+  addItem( itemPrintFormatted, TQString::tqfromLatin1( "PrintFormatted" ) );
   KConfigSkeleton::ItemBool  *itemPrintGrouped;
-  itemPrintGrouped = new KConfigSkeleton::ItemBool( currentGroup(), QString::fromLatin1( "Print Grouped" ), mPrintGrouped, true );
-  addItem( itemPrintGrouped, QString::fromLatin1( "PrintGrouped" ) );
+  itemPrintGrouped = new KConfigSkeleton::ItemBool( currentGroup(), TQString::tqfromLatin1( "Print Grouped" ), mPrintGrouped, true );
+  addItem( itemPrintGrouped, TQString::tqfromLatin1( "PrintGrouped" ) );
   KConfigSkeleton::ItemInt  *itemMaxImageWidth;
-  itemMaxImageWidth = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "Max Image Width" ), mMaxImageWidth, 50 );
-  addItem( itemMaxImageWidth, QString::fromLatin1( "MaxImageWidth" ) );
+  itemMaxImageWidth = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "Max Image Width" ), mMaxImageWidth, 50 );
+  addItem( itemMaxImageWidth, TQString::tqfromLatin1( "MaxImageWidth" ) );
   KConfigSkeleton::ItemInt  *itemMaxImageHeight;
-  itemMaxImageHeight = new KConfigSkeleton::ItemInt( currentGroup(), QString::fromLatin1( "Max Image Height" ), mMaxImageHeight, 50 );
-  addItem( itemMaxImageHeight, QString::fromLatin1( "MaxImageHeight" ) );
+  itemMaxImageHeight = new KConfigSkeleton::ItemInt( currentGroup(), TQString::tqfromLatin1( "Max Image Height" ), mMaxImageHeight, 50 );
+  addItem( itemMaxImageHeight, TQString::tqfromLatin1( "MaxImageHeight" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - book" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - book" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateBook;
-  itemTemplateBook = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateBook, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateBook, QString::fromLatin1( "templateBook" ) );
+  itemTemplateBook = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateBook, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateBook, TQString::tqfromLatin1( "templateBook" ) );
   KConfigSkeleton::ItemFont  *itemFontBook;
-  itemFontBook = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontBook, KGlobalSettings::generalFont() );
-  addItem( itemFontBook, QString::fromLatin1( "fontBook" ) );
+  itemFontBook = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontBook, KGlobalSettings::generalFont() );
+  addItem( itemFontBook, TQString::tqfromLatin1( "fontBook" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorBook;
-  itemBaseColorBook = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorBook, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorBook, QString::fromLatin1( "baseColorBook" ) );
+  itemBaseColorBook = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorBook, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorBook, TQString::tqfromLatin1( "baseColorBook" ) );
   KConfigSkeleton::ItemColor  *itemTextColorBook;
-  itemTextColorBook = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorBook, KGlobalSettings::textColor() );
-  addItem( itemTextColorBook, QString::fromLatin1( "textColorBook" ) );
+  itemTextColorBook = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorBook, KGlobalSettings::textColor() );
+  addItem( itemTextColorBook, TQString::tqfromLatin1( "textColorBook" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorBook;
-  itemHighlightedBaseColorBook = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorBook, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorBook, QString::fromLatin1( "highlightedBaseColorBook" ) );
+  itemHighlightedBaseColorBook = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorBook, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorBook, TQString::tqfromLatin1( "highlightedBaseColorBook" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorBook;
-  itemHighlightedTextColorBook = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorBook, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorBook, QString::fromLatin1( "highlightedTextColorBook" ) );
+  itemHighlightedTextColorBook = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorBook, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorBook, TQString::tqfromLatin1( "highlightedTextColorBook" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - video" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - video" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateVideo;
-  itemTemplateVideo = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateVideo, QString::fromLatin1( "Video" ) );
-  addItem( itemTemplateVideo, QString::fromLatin1( "templateVideo" ) );
+  itemTemplateVideo = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateVideo, TQString::tqfromLatin1( "Video" ) );
+  addItem( itemTemplateVideo, TQString::tqfromLatin1( "templateVideo" ) );
   KConfigSkeleton::ItemFont  *itemFontVideo;
-  itemFontVideo = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontVideo, KGlobalSettings::generalFont() );
-  addItem( itemFontVideo, QString::fromLatin1( "fontVideo" ) );
+  itemFontVideo = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontVideo, KGlobalSettings::generalFont() );
+  addItem( itemFontVideo, TQString::tqfromLatin1( "fontVideo" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorVideo;
-  itemBaseColorVideo = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorVideo, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorVideo, QString::fromLatin1( "baseColorVideo" ) );
+  itemBaseColorVideo = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorVideo, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorVideo, TQString::tqfromLatin1( "baseColorVideo" ) );
   KConfigSkeleton::ItemColor  *itemTextColorVideo;
-  itemTextColorVideo = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorVideo, KGlobalSettings::textColor() );
-  addItem( itemTextColorVideo, QString::fromLatin1( "textColorVideo" ) );
+  itemTextColorVideo = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorVideo, KGlobalSettings::textColor() );
+  addItem( itemTextColorVideo, TQString::tqfromLatin1( "textColorVideo" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorVideo;
-  itemHighlightedBaseColorVideo = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorVideo, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorVideo, QString::fromLatin1( "highlightedBaseColorVideo" ) );
+  itemHighlightedBaseColorVideo = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorVideo, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorVideo, TQString::tqfromLatin1( "highlightedBaseColorVideo" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorVideo;
-  itemHighlightedTextColorVideo = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorVideo, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorVideo, QString::fromLatin1( "highlightedTextColorVideo" ) );
+  itemHighlightedTextColorVideo = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorVideo, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorVideo, TQString::tqfromLatin1( "highlightedTextColorVideo" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - album" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - album" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateAlbum;
-  itemTemplateAlbum = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateAlbum, QString::fromLatin1( "Album" ) );
-  addItem( itemTemplateAlbum, QString::fromLatin1( "templateAlbum" ) );
+  itemTemplateAlbum = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateAlbum, TQString::tqfromLatin1( "Album" ) );
+  addItem( itemTemplateAlbum, TQString::tqfromLatin1( "templateAlbum" ) );
   KConfigSkeleton::ItemFont  *itemFontAlbum;
-  itemFontAlbum = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontAlbum, KGlobalSettings::generalFont() );
-  addItem( itemFontAlbum, QString::fromLatin1( "fontAlbum" ) );
+  itemFontAlbum = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontAlbum, KGlobalSettings::generalFont() );
+  addItem( itemFontAlbum, TQString::tqfromLatin1( "fontAlbum" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorAlbum;
-  itemBaseColorAlbum = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorAlbum, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorAlbum, QString::fromLatin1( "baseColorAlbum" ) );
+  itemBaseColorAlbum = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorAlbum, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorAlbum, TQString::tqfromLatin1( "baseColorAlbum" ) );
   KConfigSkeleton::ItemColor  *itemTextColorAlbum;
-  itemTextColorAlbum = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorAlbum, KGlobalSettings::textColor() );
-  addItem( itemTextColorAlbum, QString::fromLatin1( "textColorAlbum" ) );
+  itemTextColorAlbum = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorAlbum, KGlobalSettings::textColor() );
+  addItem( itemTextColorAlbum, TQString::tqfromLatin1( "textColorAlbum" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorAlbum;
-  itemHighlightedBaseColorAlbum = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorAlbum, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorAlbum, QString::fromLatin1( "highlightedBaseColorAlbum" ) );
+  itemHighlightedBaseColorAlbum = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorAlbum, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorAlbum, TQString::tqfromLatin1( "highlightedBaseColorAlbum" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorAlbum;
-  itemHighlightedTextColorAlbum = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorAlbum, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorAlbum, QString::fromLatin1( "highlightedTextColorAlbum" ) );
+  itemHighlightedTextColorAlbum = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorAlbum, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorAlbum, TQString::tqfromLatin1( "highlightedTextColorAlbum" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - bibtex" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - bibtex" ) );
 
   KConfigSkeleton::ItemPath  *itemLyxpipe;
-  itemLyxpipe = new KConfigSkeleton::ItemPath( currentGroup(), QString::fromLatin1( "lyxpipe" ), mLyxpipe, QString::fromLatin1( "$HOME/.lyx/lyxpipe" ) );
-  addItem( itemLyxpipe, QString::fromLatin1( "lyxpipe" ) );
+  itemLyxpipe = new KConfigSkeleton::ItemPath( currentGroup(), TQString::tqfromLatin1( "lyxpipe" ), mLyxpipe, TQString::tqfromLatin1( "$HOME/.lyx/lyxpipe" ) );
+  addItem( itemLyxpipe, TQString::tqfromLatin1( "lyxpipe" ) );
   KConfigSkeleton::ItemString  *itemTemplateBibtex;
-  itemTemplateBibtex = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateBibtex, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateBibtex, QString::fromLatin1( "templateBibtex" ) );
+  itemTemplateBibtex = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateBibtex, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateBibtex, TQString::tqfromLatin1( "templateBibtex" ) );
   KConfigSkeleton::ItemFont  *itemFontBibtex;
-  itemFontBibtex = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontBibtex, KGlobalSettings::generalFont() );
-  addItem( itemFontBibtex, QString::fromLatin1( "fontBibtex" ) );
+  itemFontBibtex = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontBibtex, KGlobalSettings::generalFont() );
+  addItem( itemFontBibtex, TQString::tqfromLatin1( "fontBibtex" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorBibtex;
-  itemBaseColorBibtex = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorBibtex, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorBibtex, QString::fromLatin1( "baseColorBibtex" ) );
+  itemBaseColorBibtex = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorBibtex, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorBibtex, TQString::tqfromLatin1( "baseColorBibtex" ) );
   KConfigSkeleton::ItemColor  *itemTextColorBibtex;
-  itemTextColorBibtex = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorBibtex, KGlobalSettings::textColor() );
-  addItem( itemTextColorBibtex, QString::fromLatin1( "textColorBibtex" ) );
+  itemTextColorBibtex = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorBibtex, KGlobalSettings::textColor() );
+  addItem( itemTextColorBibtex, TQString::tqfromLatin1( "textColorBibtex" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorBibtex;
-  itemHighlightedBaseColorBibtex = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorBibtex, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorBibtex, QString::fromLatin1( "highlightedBaseColorBibtex" ) );
+  itemHighlightedBaseColorBibtex = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorBibtex, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorBibtex, TQString::tqfromLatin1( "highlightedBaseColorBibtex" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorBibtex;
-  itemHighlightedTextColorBibtex = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorBibtex, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorBibtex, QString::fromLatin1( "highlightedTextColorBibtex" ) );
+  itemHighlightedTextColorBibtex = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorBibtex, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorBibtex, TQString::tqfromLatin1( "highlightedTextColorBibtex" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - comic" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - comic" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateComicBook;
-  itemTemplateComicBook = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateComicBook, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateComicBook, QString::fromLatin1( "templateComicBook" ) );
+  itemTemplateComicBook = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateComicBook, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateComicBook, TQString::tqfromLatin1( "templateComicBook" ) );
   KConfigSkeleton::ItemFont  *itemFontComicBook;
-  itemFontComicBook = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontComicBook, KGlobalSettings::generalFont() );
-  addItem( itemFontComicBook, QString::fromLatin1( "fontComicBook" ) );
+  itemFontComicBook = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontComicBook, KGlobalSettings::generalFont() );
+  addItem( itemFontComicBook, TQString::tqfromLatin1( "fontComicBook" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorComicBook;
-  itemBaseColorComicBook = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorComicBook, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorComicBook, QString::fromLatin1( "baseColorComicBook" ) );
+  itemBaseColorComicBook = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorComicBook, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorComicBook, TQString::tqfromLatin1( "baseColorComicBook" ) );
   KConfigSkeleton::ItemColor  *itemTextColorComicBook;
-  itemTextColorComicBook = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorComicBook, KGlobalSettings::textColor() );
-  addItem( itemTextColorComicBook, QString::fromLatin1( "textColorComicBook" ) );
+  itemTextColorComicBook = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorComicBook, KGlobalSettings::textColor() );
+  addItem( itemTextColorComicBook, TQString::tqfromLatin1( "textColorComicBook" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorComicBook;
-  itemHighlightedBaseColorComicBook = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorComicBook, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorComicBook, QString::fromLatin1( "highlightedBaseColorComicBook" ) );
+  itemHighlightedBaseColorComicBook = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorComicBook, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorComicBook, TQString::tqfromLatin1( "highlightedBaseColorComicBook" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorComicBook;
-  itemHighlightedTextColorComicBook = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorComicBook, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorComicBook, QString::fromLatin1( "highlightedTextColorComicBook" ) );
+  itemHighlightedTextColorComicBook = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorComicBook, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorComicBook, TQString::tqfromLatin1( "highlightedTextColorComicBook" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - wine" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - wine" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateWine;
-  itemTemplateWine = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateWine, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateWine, QString::fromLatin1( "templateWine" ) );
+  itemTemplateWine = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateWine, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateWine, TQString::tqfromLatin1( "templateWine" ) );
   KConfigSkeleton::ItemFont  *itemFontWine;
-  itemFontWine = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontWine, KGlobalSettings::generalFont() );
-  addItem( itemFontWine, QString::fromLatin1( "fontWine" ) );
+  itemFontWine = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontWine, KGlobalSettings::generalFont() );
+  addItem( itemFontWine, TQString::tqfromLatin1( "fontWine" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorWine;
-  itemBaseColorWine = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorWine, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorWine, QString::fromLatin1( "baseColorWine" ) );
+  itemBaseColorWine = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorWine, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorWine, TQString::tqfromLatin1( "baseColorWine" ) );
   KConfigSkeleton::ItemColor  *itemTextColorWine;
-  itemTextColorWine = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorWine, KGlobalSettings::textColor() );
-  addItem( itemTextColorWine, QString::fromLatin1( "textColorWine" ) );
+  itemTextColorWine = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorWine, KGlobalSettings::textColor() );
+  addItem( itemTextColorWine, TQString::tqfromLatin1( "textColorWine" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorWine;
-  itemHighlightedBaseColorWine = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorWine, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorWine, QString::fromLatin1( "highlightedBaseColorWine" ) );
+  itemHighlightedBaseColorWine = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorWine, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorWine, TQString::tqfromLatin1( "highlightedBaseColorWine" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorWine;
-  itemHighlightedTextColorWine = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorWine, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorWine, QString::fromLatin1( "highlightedTextColorWine" ) );
+  itemHighlightedTextColorWine = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorWine, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorWine, TQString::tqfromLatin1( "highlightedTextColorWine" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - coin" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - coin" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateCoin;
-  itemTemplateCoin = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateCoin, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateCoin, QString::fromLatin1( "templateCoin" ) );
+  itemTemplateCoin = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateCoin, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateCoin, TQString::tqfromLatin1( "templateCoin" ) );
   KConfigSkeleton::ItemFont  *itemFontCoin;
-  itemFontCoin = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontCoin, KGlobalSettings::generalFont() );
-  addItem( itemFontCoin, QString::fromLatin1( "fontCoin" ) );
+  itemFontCoin = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontCoin, KGlobalSettings::generalFont() );
+  addItem( itemFontCoin, TQString::tqfromLatin1( "fontCoin" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorCoin;
-  itemBaseColorCoin = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorCoin, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorCoin, QString::fromLatin1( "baseColorCoin" ) );
+  itemBaseColorCoin = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorCoin, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorCoin, TQString::tqfromLatin1( "baseColorCoin" ) );
   KConfigSkeleton::ItemColor  *itemTextColorCoin;
-  itemTextColorCoin = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorCoin, KGlobalSettings::textColor() );
-  addItem( itemTextColorCoin, QString::fromLatin1( "textColorCoin" ) );
+  itemTextColorCoin = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorCoin, KGlobalSettings::textColor() );
+  addItem( itemTextColorCoin, TQString::tqfromLatin1( "textColorCoin" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorCoin;
-  itemHighlightedBaseColorCoin = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorCoin, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorCoin, QString::fromLatin1( "highlightedBaseColorCoin" ) );
+  itemHighlightedBaseColorCoin = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorCoin, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorCoin, TQString::tqfromLatin1( "highlightedBaseColorCoin" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorCoin;
-  itemHighlightedTextColorCoin = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorCoin, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorCoin, QString::fromLatin1( "highlightedTextColorCoin" ) );
+  itemHighlightedTextColorCoin = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorCoin, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorCoin, TQString::tqfromLatin1( "highlightedTextColorCoin" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - stamp" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - stamp" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateStamp;
-  itemTemplateStamp = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateStamp, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateStamp, QString::fromLatin1( "templateStamp" ) );
+  itemTemplateStamp = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateStamp, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateStamp, TQString::tqfromLatin1( "templateStamp" ) );
   KConfigSkeleton::ItemFont  *itemFontStamp;
-  itemFontStamp = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontStamp, KGlobalSettings::generalFont() );
-  addItem( itemFontStamp, QString::fromLatin1( "fontStamp" ) );
+  itemFontStamp = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontStamp, KGlobalSettings::generalFont() );
+  addItem( itemFontStamp, TQString::tqfromLatin1( "fontStamp" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorStamp;
-  itemBaseColorStamp = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorStamp, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorStamp, QString::fromLatin1( "baseColorStamp" ) );
+  itemBaseColorStamp = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorStamp, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorStamp, TQString::tqfromLatin1( "baseColorStamp" ) );
   KConfigSkeleton::ItemColor  *itemTextColorStamp;
-  itemTextColorStamp = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorStamp, KGlobalSettings::textColor() );
-  addItem( itemTextColorStamp, QString::fromLatin1( "textColorStamp" ) );
+  itemTextColorStamp = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorStamp, KGlobalSettings::textColor() );
+  addItem( itemTextColorStamp, TQString::tqfromLatin1( "textColorStamp" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorStamp;
-  itemHighlightedBaseColorStamp = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorStamp, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorStamp, QString::fromLatin1( "highlightedBaseColorStamp" ) );
+  itemHighlightedBaseColorStamp = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorStamp, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorStamp, TQString::tqfromLatin1( "highlightedBaseColorStamp" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorStamp;
-  itemHighlightedTextColorStamp = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorStamp, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorStamp, QString::fromLatin1( "highlightedTextColorStamp" ) );
+  itemHighlightedTextColorStamp = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorStamp, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorStamp, TQString::tqfromLatin1( "highlightedTextColorStamp" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - card" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - card" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateCard;
-  itemTemplateCard = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateCard, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateCard, QString::fromLatin1( "templateCard" ) );
+  itemTemplateCard = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateCard, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateCard, TQString::tqfromLatin1( "templateCard" ) );
   KConfigSkeleton::ItemFont  *itemFontCard;
-  itemFontCard = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontCard, KGlobalSettings::generalFont() );
-  addItem( itemFontCard, QString::fromLatin1( "fontCard" ) );
+  itemFontCard = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontCard, KGlobalSettings::generalFont() );
+  addItem( itemFontCard, TQString::tqfromLatin1( "fontCard" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorCard;
-  itemBaseColorCard = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorCard, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorCard, QString::fromLatin1( "baseColorCard" ) );
+  itemBaseColorCard = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorCard, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorCard, TQString::tqfromLatin1( "baseColorCard" ) );
   KConfigSkeleton::ItemColor  *itemTextColorCard;
-  itemTextColorCard = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorCard, KGlobalSettings::textColor() );
-  addItem( itemTextColorCard, QString::fromLatin1( "textColorCard" ) );
+  itemTextColorCard = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorCard, KGlobalSettings::textColor() );
+  addItem( itemTextColorCard, TQString::tqfromLatin1( "textColorCard" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorCard;
-  itemHighlightedBaseColorCard = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorCard, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorCard, QString::fromLatin1( "highlightedBaseColorCard" ) );
+  itemHighlightedBaseColorCard = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorCard, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorCard, TQString::tqfromLatin1( "highlightedBaseColorCard" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorCard;
-  itemHighlightedTextColorCard = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorCard, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorCard, QString::fromLatin1( "highlightedTextColorCard" ) );
+  itemHighlightedTextColorCard = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorCard, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorCard, TQString::tqfromLatin1( "highlightedTextColorCard" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - game" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - game" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateGame;
-  itemTemplateGame = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateGame, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateGame, QString::fromLatin1( "templateGame" ) );
+  itemTemplateGame = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateGame, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateGame, TQString::tqfromLatin1( "templateGame" ) );
   KConfigSkeleton::ItemFont  *itemFontGame;
-  itemFontGame = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontGame, KGlobalSettings::generalFont() );
-  addItem( itemFontGame, QString::fromLatin1( "fontGame" ) );
+  itemFontGame = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontGame, KGlobalSettings::generalFont() );
+  addItem( itemFontGame, TQString::tqfromLatin1( "fontGame" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorGame;
-  itemBaseColorGame = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorGame, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorGame, QString::fromLatin1( "baseColorGame" ) );
+  itemBaseColorGame = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorGame, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorGame, TQString::tqfromLatin1( "baseColorGame" ) );
   KConfigSkeleton::ItemColor  *itemTextColorGame;
-  itemTextColorGame = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorGame, KGlobalSettings::textColor() );
-  addItem( itemTextColorGame, QString::fromLatin1( "textColorGame" ) );
+  itemTextColorGame = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorGame, KGlobalSettings::textColor() );
+  addItem( itemTextColorGame, TQString::tqfromLatin1( "textColorGame" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorGame;
-  itemHighlightedBaseColorGame = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorGame, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorGame, QString::fromLatin1( "highlightedBaseColorGame" ) );
+  itemHighlightedBaseColorGame = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorGame, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorGame, TQString::tqfromLatin1( "highlightedBaseColorGame" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorGame;
-  itemHighlightedTextColorGame = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorGame, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorGame, QString::fromLatin1( "highlightedTextColorGame" ) );
+  itemHighlightedTextColorGame = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorGame, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorGame, TQString::tqfromLatin1( "highlightedTextColorGame" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - file" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - file" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateFile;
-  itemTemplateFile = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateFile, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateFile, QString::fromLatin1( "templateFile" ) );
+  itemTemplateFile = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateFile, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateFile, TQString::tqfromLatin1( "templateFile" ) );
   KConfigSkeleton::ItemFont  *itemFontFile;
-  itemFontFile = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontFile, KGlobalSettings::generalFont() );
-  addItem( itemFontFile, QString::fromLatin1( "fontFile" ) );
+  itemFontFile = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontFile, KGlobalSettings::generalFont() );
+  addItem( itemFontFile, TQString::tqfromLatin1( "fontFile" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorFile;
-  itemBaseColorFile = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorFile, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorFile, QString::fromLatin1( "baseColorFile" ) );
+  itemBaseColorFile = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorFile, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorFile, TQString::tqfromLatin1( "baseColorFile" ) );
   KConfigSkeleton::ItemColor  *itemTextColorFile;
-  itemTextColorFile = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorFile, KGlobalSettings::textColor() );
-  addItem( itemTextColorFile, QString::fromLatin1( "textColorFile" ) );
+  itemTextColorFile = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorFile, KGlobalSettings::textColor() );
+  addItem( itemTextColorFile, TQString::tqfromLatin1( "textColorFile" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorFile;
-  itemHighlightedBaseColorFile = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorFile, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorFile, QString::fromLatin1( "highlightedBaseColorFile" ) );
+  itemHighlightedBaseColorFile = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorFile, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorFile, TQString::tqfromLatin1( "highlightedBaseColorFile" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorFile;
-  itemHighlightedTextColorFile = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorFile, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorFile, QString::fromLatin1( "highlightedTextColorFile" ) );
+  itemHighlightedTextColorFile = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorFile, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorFile, TQString::tqfromLatin1( "highlightedTextColorFile" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - boardgame" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - boardgame" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateBoardGame;
-  itemTemplateBoardGame = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateBoardGame, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateBoardGame, QString::fromLatin1( "templateBoardGame" ) );
+  itemTemplateBoardGame = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateBoardGame, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateBoardGame, TQString::tqfromLatin1( "templateBoardGame" ) );
   KConfigSkeleton::ItemFont  *itemFontBoardGame;
-  itemFontBoardGame = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontBoardGame, KGlobalSettings::generalFont() );
-  addItem( itemFontBoardGame, QString::fromLatin1( "fontBoardGame" ) );
+  itemFontBoardGame = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontBoardGame, KGlobalSettings::generalFont() );
+  addItem( itemFontBoardGame, TQString::tqfromLatin1( "fontBoardGame" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorBoardGame;
-  itemBaseColorBoardGame = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorBoardGame, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorBoardGame, QString::fromLatin1( "baseColorBoardGame" ) );
+  itemBaseColorBoardGame = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorBoardGame, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorBoardGame, TQString::tqfromLatin1( "baseColorBoardGame" ) );
   KConfigSkeleton::ItemColor  *itemTextColorBoardGame;
-  itemTextColorBoardGame = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorBoardGame, KGlobalSettings::textColor() );
-  addItem( itemTextColorBoardGame, QString::fromLatin1( "textColorBoardGame" ) );
+  itemTextColorBoardGame = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorBoardGame, KGlobalSettings::textColor() );
+  addItem( itemTextColorBoardGame, TQString::tqfromLatin1( "textColorBoardGame" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorBoardGame;
-  itemHighlightedBaseColorBoardGame = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorBoardGame, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorBoardGame, QString::fromLatin1( "highlightedBaseColorBoardGame" ) );
+  itemHighlightedBaseColorBoardGame = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorBoardGame, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorBoardGame, TQString::tqfromLatin1( "highlightedBaseColorBoardGame" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorBoardGame;
-  itemHighlightedTextColorBoardGame = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorBoardGame, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorBoardGame, QString::fromLatin1( "highlightedTextColorBoardGame" ) );
+  itemHighlightedTextColorBoardGame = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorBoardGame, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorBoardGame, TQString::tqfromLatin1( "highlightedTextColorBoardGame" ) );
 
-  setCurrentGroup( QString::fromLatin1( "Options - entry" ) );
+  setCurrentGroup( TQString::tqfromLatin1( "Options - entry" ) );
 
   KConfigSkeleton::ItemString  *itemTemplateBase;
-  itemTemplateBase = new KConfigSkeleton::ItemString( currentGroup(), QString::fromLatin1( "Entry Template" ), mTemplateBase, QString::fromLatin1( "Fancy" ) );
-  addItem( itemTemplateBase, QString::fromLatin1( "templateBase" ) );
+  itemTemplateBase = new KConfigSkeleton::ItemString( currentGroup(), TQString::tqfromLatin1( "Entry Template" ), mTemplateBase, TQString::tqfromLatin1( "Fancy" ) );
+  addItem( itemTemplateBase, TQString::tqfromLatin1( "templateBase" ) );
   KConfigSkeleton::ItemFont  *itemFontBase;
-  itemFontBase = new KConfigSkeleton::ItemFont( currentGroup(), QString::fromLatin1( "Template Font" ), mFontBase, KGlobalSettings::generalFont() );
-  addItem( itemFontBase, QString::fromLatin1( "fontBase" ) );
+  itemFontBase = new KConfigSkeleton::ItemFont( currentGroup(), TQString::tqfromLatin1( "Template Font" ), mFontBase, KGlobalSettings::generalFont() );
+  addItem( itemFontBase, TQString::tqfromLatin1( "fontBase" ) );
   KConfigSkeleton::ItemColor  *itemBaseColorBase;
-  itemBaseColorBase = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Base Color" ), mBaseColorBase, KGlobalSettings::baseColor() );
-  addItem( itemBaseColorBase, QString::fromLatin1( "baseColorBase" ) );
+  itemBaseColorBase = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Base Color" ), mBaseColorBase, KGlobalSettings::baseColor() );
+  addItem( itemBaseColorBase, TQString::tqfromLatin1( "baseColorBase" ) );
   KConfigSkeleton::ItemColor  *itemTextColorBase;
-  itemTextColorBase = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Text Color" ), mTextColorBase, KGlobalSettings::textColor() );
-  addItem( itemTextColorBase, QString::fromLatin1( "textColorBase" ) );
+  itemTextColorBase = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Text Color" ), mTextColorBase, KGlobalSettings::textColor() );
+  addItem( itemTextColorBase, TQString::tqfromLatin1( "textColorBase" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedBaseColorBase;
-  itemHighlightedBaseColorBase = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlight Color" ), mHighlightedBaseColorBase, KGlobalSettings::highlightColor() );
-  addItem( itemHighlightedBaseColorBase, QString::fromLatin1( "highlightedBaseColorBase" ) );
+  itemHighlightedBaseColorBase = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlight Color" ), mHighlightedBaseColorBase, KGlobalSettings::highlightColor() );
+  addItem( itemHighlightedBaseColorBase, TQString::tqfromLatin1( "highlightedBaseColorBase" ) );
   KConfigSkeleton::ItemColor  *itemHighlightedTextColorBase;
-  itemHighlightedTextColorBase = new KConfigSkeleton::ItemColor( currentGroup(), QString::fromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorBase, KGlobalSettings::highlightedTextColor() );
-  addItem( itemHighlightedTextColorBase, QString::fromLatin1( "highlightedTextColorBase" ) );
+  itemHighlightedTextColorBase = new KConfigSkeleton::ItemColor( currentGroup(), TQString::tqfromLatin1( "Template Highlighted Text Color" ), mHighlightedTextColorBase, KGlobalSettings::highlightedTextColor() );
+  addItem( itemHighlightedTextColorBase, TQString::tqfromLatin1( "highlightedTextColorBase" ) );
 }
 
 Config::~Config()
diff --git a/src/core/tellico_config_addons.cpp b/src/core/tellico_config_addons.cpp
index 9b388d5..e4e7260 100644
--- a/src/core/tellico_config_addons.cpp
+++ b/src/core/tellico_config_addons.cpp
@@ -54,7 +54,7 @@
   SET(name, BoardGame, value)
 
 namespace {
-  static const QRegExp commaSplit = QRegExp(QString::fromLatin1("\\s*,\\s*"));
+  static const TQRegExp commaSplit = TQRegExp(TQString::tqfromLatin1("\\s*,\\s*"));
 }
 
 using Tellico::Config;
@@ -64,96 +64,96 @@ void Config::deleteAndReset() {
   mSelf = 0;
 }
 
-QStringList Config::noCapitalizationList() {
-  return QStringList::split(commaSplit, Config::noCapitalizationString());
+TQStringList Config::noCapitalizationList() {
+  return TQStringList::split(commaSplit, Config::noCapitalizationString());
 }
 
-QStringList Config::articleList() {
-  return QStringList::split(commaSplit, Config::articlesString());
+TQStringList Config::articleList() {
+  return TQStringList::split(commaSplit, Config::articlesString());
 }
 
-QStringList Config::nameSuffixList() {
-  return QStringList::split(commaSplit, Config::nameSuffixesString());
+TQStringList Config::nameSuffixList() {
+  return TQStringList::split(commaSplit, Config::nameSuffixesString());
 }
 
-QStringList Config::surnamePrefixList() {
-  return QStringList::split(commaSplit, Config::surnamePrefixesString());
+TQStringList Config::surnamePrefixList() {
+  return TQStringList::split(commaSplit, Config::surnamePrefixesString());
 }
 
 
-QString Config::templateName(int type_) {
+TQString Config::templateName(int type_) {
   switch(type_) {
     ALL_GET(template);
   }
-  return QString();
+  return TQString();
 }
 
-QFont Config::templateFont(int type_) {
+TQFont Config::templateFont(int type_) {
   switch(type_) {
     ALL_GET(font);
   }
-  return QFont();
+  return TQFont();
 }
 
-QColor Config::templateBaseColor(int type_) {
+TQColor Config::templateBaseColor(int type_) {
   switch(type_) {
     ALL_GET(baseColor)
   }
-  return QColor();
+  return TQColor();
 }
 
-QColor Config::templateTextColor(int type_) {
+TQColor Config::templateTextColor(int type_) {
   switch(type_) {
     ALL_GET(textColor)
   }
-  return QColor();
+  return TQColor();
 }
 
-QColor Config::templateHighlightedBaseColor(int type_) {
+TQColor Config::templateHighlightedBaseColor(int type_) {
   switch(type_) {
     ALL_GET(highlightedBaseColor)
   }
-  return QColor();
+  return TQColor();
 }
 
-QColor Config::templateHighlightedTextColor(int type_) {
+TQColor Config::templateHighlightedTextColor(int type_) {
   switch(type_) {
     ALL_GET(highlightedTextColor)
   }
-  return QColor();
+  return TQColor();
 }
 
-void Config::setTemplateName(int type_, const QString& name_) {
+void Config::setTemplateName(int type_, const TQString& name_) {
   switch(type_) {
     ALL_SET(setTemplate,name_)
   }
 }
 
-void Config::setTemplateFont(int type_, const QFont& font_) {
+void Config::setTemplateFont(int type_, const TQFont& font_) {
   switch(type_) {
     ALL_SET(setFont,font_)
   }
 }
 
-void Config::setTemplateBaseColor(int type_, const QColor& color_) {
+void Config::setTemplateBaseColor(int type_, const TQColor& color_) {
   switch(type_) {
     ALL_SET(setBaseColor,color_)
   }
 }
 
-void Config::setTemplateTextColor(int type_, const QColor& color_) {
+void Config::setTemplateTextColor(int type_, const TQColor& color_) {
   switch(type_) {
     ALL_SET(setTextColor,color_)
   }
 }
 
-void Config::setTemplateHighlightedBaseColor(int type_, const QColor& color_) {
+void Config::setTemplateHighlightedBaseColor(int type_, const TQColor& color_) {
   switch(type_) {
     ALL_SET(setHighlightedBaseColor,color_)
   }
 }
 
-void Config::setTemplateHighlightedTextColor(int type_, const QColor& color_) {
+void Config::setTemplateHighlightedTextColor(int type_, const TQColor& color_) {
   switch(type_) {
     ALL_SET(setHighlightedTextColor,color_)
   }
diff --git a/src/core/tellico_config_addons.h b/src/core/tellico_config_addons.h
index 7573257..7f243a3 100644
--- a/src/core/tellico_config_addons.h
+++ b/src/core/tellico_config_addons.h
@@ -16,21 +16,21 @@
 public:
   static void deleteAndReset();
 
-  static QStringList noCapitalizationList();
-  static QStringList articleList();
-  static QStringList nameSuffixList();
-  static QStringList surnamePrefixList();
+  static TQStringList noCapitalizationList();
+  static TQStringList articleList();
+  static TQStringList nameSuffixList();
+  static TQStringList surnamePrefixList();
 
-  static QString templateName(int type);
-  static QFont templateFont(int type);
-  static QColor templateBaseColor(int type);
-  static QColor templateTextColor(int type);
-  static QColor templateHighlightedBaseColor(int type);
-  static QColor templateHighlightedTextColor(int type);
+  static TQString templateName(int type);
+  static TQFont templateFont(int type);
+  static TQColor templateBaseColor(int type);
+  static TQColor templateTextColor(int type);
+  static TQColor templateHighlightedBaseColor(int type);
+  static TQColor templateHighlightedTextColor(int type);
 
-  static void setTemplateName(int type, const QString& name);
-  static void setTemplateFont(int type, const QFont& font);
-  static void setTemplateBaseColor(int type, const QColor& color);
-  static void setTemplateTextColor(int type, const QColor& color);
-  static void setTemplateHighlightedBaseColor(int type, const QColor& color);
-  static void setTemplateHighlightedTextColor(int type, const QColor& color);
+  static void setTemplateName(int type, const TQString& name);
+  static void setTemplateFont(int type, const TQFont& font);
+  static void setTemplateBaseColor(int type, const TQColor& color);
+  static void setTemplateTextColor(int type, const TQColor& color);
+  static void setTemplateHighlightedBaseColor(int type, const TQColor& color);
+  static void setTemplateHighlightedTextColor(int type, const TQColor& color);