TQt4 port koffice

This should enable compilation under both Qt3 and Qt4; fixes for any missed components will be forthcoming


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

1 files changed, 181 insertions, 181 deletions

diff --git a/kexi/kexidb/queryschema.cpp b/kexi/kexidb/queryschema.cpp
index 4da4d2b8..4fae1cf1 100644
--- a/kexi/kexidb/queryschema.cpp
+++ b/kexi/kexidb/queryschema.cpp
@@ -27,18 +27,18 @@
 
 #include <assert.h>
 
-#include <qvaluelist.h>
-#include <qasciidict.h>
-#include <qptrdict.h>
-#include <qintdict.h>
-#include <qbitarray.h>
+#include <tqvaluelist.h>
+#include <tqasciidict.h>
+#include <tqptrdict.h>
+#include <tqintdict.h>
+#include <tqbitarray.h>
 
 #include <kdebug.h>
 #include <klocale.h>
 
 using namespace KexiDB;
 
-QueryColumnInfo::QueryColumnInfo(Field *f, const QCString& _alias, bool _visible, 
+QueryColumnInfo::QueryColumnInfo(Field *f, const TQCString& _alias, bool _visible, 
 	QueryColumnInfo *foreignColumn)
  : field(f), alias(_alias), visible(_visible), m_indexForVisibleLookupValue(-1)
  , m_foreignColumn(foreignColumn)
@@ -49,11 +49,11 @@ QueryColumnInfo::~QueryColumnInfo()
 {
 }
 
-QString QueryColumnInfo::debugString() const
+TQString QueryColumnInfo::debugString() const
 {
 	return field->name() + 
-		( alias.isEmpty() ? QString::null 
-			: (QString::fromLatin1(" AS ") + QString(alias)) );
+		( alias.isEmpty() ? TQString() 
+			: (TQString::tqfromLatin1(" AS ") + TQString(alias)) );
 }
 
 //=======================================
@@ -109,14 +109,14 @@ class QuerySchemaPrivate
 				if (copy->autoincFields)
 					autoincFields = new QueryColumnInfo::List(*copy->autoincFields);
 				if (copy->columnsOrder)
-					columnsOrder = new QMap<QueryColumnInfo*,int>(*copy->columnsOrder);
+					columnsOrder = new TQMap<QueryColumnInfo*,int>(*copy->columnsOrder);
 				if (copy->columnsOrderWithoutAsterisks)
-					columnsOrderWithoutAsterisks = new QMap<QueryColumnInfo*,int>(
+					columnsOrderWithoutAsterisks = new TQMap<QueryColumnInfo*,int>(
 						*copy->columnsOrderWithoutAsterisks);
 				if (copy->columnsOrderExpanded)
-					columnsOrderExpanded = new QMap<QueryColumnInfo*,int>(*copy->columnsOrderExpanded);
+					columnsOrderExpanded = new TQMap<QueryColumnInfo*,int>(*copy->columnsOrderExpanded);
 				if (copy->pkeyFieldsOrder)
-					pkeyFieldsOrder = new QValueVector<int>(*copy->pkeyFieldsOrder);
+					pkeyFieldsOrder = new TQValueVector<int>(*copy->pkeyFieldsOrder);
 				if (copy->whereExpr)
 					whereExpr = copy->whereExpr->copy();
 				if (copy->fakeRowIDCol)
@@ -156,7 +156,7 @@ class QuerySchemaPrivate
 			delete pkeyFieldsOrder;
 			pkeyFieldsOrder=0;
 			visibility.fill(false);
-			tablesBoundToColumns = QValueVector<int>(64,-1);
+			tablesBoundToColumns = TQValueVector<int>(64,-1);
 			tablePositionsForAliases.clear();
 			columnPositionsForAliases.clear();
 		}
@@ -177,7 +177,7 @@ class QuerySchemaPrivate
 				columnsOrderExpanded = 0;
 				delete autoincFields;
 				autoincFields = 0;
-				autoIncrementSQLFieldsList = QString::null;
+				autoIncrementSQLFieldsList = TQString();
 				columnInfosByNameExpanded.clear();
 				columnInfosByName.clear();
 				delete ownedVisibleColumns;
@@ -185,16 +185,16 @@ class QuerySchemaPrivate
 			}
 		}
 
-		void setColumnAliasInternal(uint position, const QCString& alias)
+		void setColumnAliasInternal(uint position, const TQCString& alias)
 		{
-			columnAliases.replace(position, new QCString(alias));
-			columnPositionsForAliases.replace(alias, new int(position));
-			maxIndexWithAlias = QMAX( maxIndexWithAlias, (int)position );
+			columnAliases.tqreplace(position, new TQCString(alias));
+			columnPositionsForAliases.tqreplace(alias, new int(position));
+			maxIndexWithAlias = TQMAX( maxIndexWithAlias, (int)position );
 		}
 
-		void setColumnAlias(uint position, const QCString& alias)
+		void setColumnAlias(uint position, const TQCString& alias)
 		{
-			QCString *oldAlias = columnAliases.take(position);
+			TQCString *oldAlias = columnAliases.take(position);
 			if (oldAlias) {
 				tablePositionsForAliases.remove(*oldAlias);
 				delete oldAlias;
@@ -213,7 +213,7 @@ class QuerySchemaPrivate
 			return !columnAliases.isEmpty();
 		}
 
-		QCString* columnAlias(uint position)
+		TQCString* columnAlias(uint position)
 		{
 			tryRegenerateExprAliases();
 			return columnAliases[position];
@@ -241,14 +241,14 @@ class QuerySchemaPrivate
 			Field *f;
 			uint p=0;
 			uint colNum=0; //used to generate a name
-			QCString columnAlias;
+			TQCString columnAlias;
 			for (Field::ListIterator it(query->fieldsIterator()); (f = it.current()); ++it, p++) {
 				if (f->isExpression() && !columnAliases[p]) {
 					//missing
-					for (;;) { //find 1st unused
+					for (;;) { //tqfind 1st unused
 						colNum++;
 						columnAlias = (i18n("short for 'expression' word (only latin letters, please)", "expr") 
-							+ QString::number(colNum)).latin1();
+							+ TQString::number(colNum)).latin1();
 						if (!tablePositionsForAliases[columnAlias])
 							break;
 					}
@@ -259,11 +259,11 @@ class QuerySchemaPrivate
 		}
 
 		/*! Used to mapping columns to its aliases for this query */
-		QIntDict<QCString> columnAliases;
+		TQIntDict<TQCString> columnAliases;
 
 	public:
 		/*! Used to mapping tables to its aliases for this query */
-		QIntDict<QCString> tableAliases;
+		TQIntDict<TQCString> tableAliases;
 		
 		/*! Helper used with aliases */
 		int maxIndexWithAlias;
@@ -272,7 +272,7 @@ class QuerySchemaPrivate
 		int maxIndexWithTableAlias;
 		
 		/*! Used to store visibility flag for every field */
-		QBitArray visibility;
+		TQBitArray visibility;
 
 		/*! List of asterisks defined for this query  */
 		Field::List asterisks;
@@ -299,30 +299,30 @@ class QuerySchemaPrivate
 		QueryColumnInfo::List *autoincFields;
 		
 		/*! A cache for autoIncrementSQLFieldsList(). */
-		QString autoIncrementSQLFieldsList;
-		QGuardedPtr<Driver> lastUsedDriverForAutoIncrementSQLFieldsList;
+		TQString autoIncrementSQLFieldsList;
+		TQGuardedPtr<Driver> lastUsedDriverForAutoIncrementSQLFieldsList;
 
 		/*! A map for fast lookup of query columns' order (unexpanded version). */
-		QMap<QueryColumnInfo*,int> *columnsOrder;
+		TQMap<QueryColumnInfo*,int> *columnsOrder;
 
 		/*! A map for fast lookup of query columns' order (unexpanded version without asterisks). */
-		QMap<QueryColumnInfo*,int> *columnsOrderWithoutAsterisks;
+		TQMap<QueryColumnInfo*,int> *columnsOrderWithoutAsterisks;
 
 		/*! A map for fast lookup of query columns' order.
 		 This is exactly opposite information compared to vector returned 
 		 by fieldsExpanded() */
-		QMap<QueryColumnInfo*,int> *columnsOrderExpanded;
+		TQMap<QueryColumnInfo*,int> *columnsOrderExpanded;
 
-//		QValueList<bool> detailedVisibility;
+//		TQValueList<bool> detailedVisibility;
 
 		/*! order of PKEY fields (e.g. for updateRow() ) */
-		QValueVector<int> *pkeyFieldsOrder;
+		TQValueVector<int> *pkeyFieldsOrder;
 
 		/*! number of PKEY fields within the query */
 		uint pkeyFieldsCount;
 
 		/*! forced (predefined) statement */
-		QString statement;
+		TQString statement;
 
 		/*! Relationships defined for this query. */
 		Relationship::List relations;
@@ -342,20 +342,20 @@ class QuerySchemaPrivate
 		 - second coulmn is not specially bound (othertable.x isn't ambiguous)
 		 - third column is bound to table 1 "t2"
 		*/
-		QValueVector<int> tablesBoundToColumns;
+		TQValueVector<int> tablesBoundToColumns;
 		
 		/*! Collects table positions for aliases: used in tablePositionForAlias(). */
-		QAsciiDict<int> tablePositionsForAliases;
+		TQAsciiDict<int> tablePositionsForAliases;
 
 		/*! Collects column positions for aliases: used in columnPositionForAlias(). */
-		QAsciiDict<int> columnPositionsForAliases;
+		TQAsciiDict<int> columnPositionsForAliases;
 
 		/*! WHERE expression */
 		BaseExpr *whereExpr;
 
-		QDict<QueryColumnInfo> columnInfosByNameExpanded;
+		TQDict<QueryColumnInfo> columnInfosByNameExpanded;
 
-		QDict<QueryColumnInfo> columnInfosByName; //!< Same as columnInfosByNameExpanded but asterisks are skipped
+		TQDict<QueryColumnInfo> columnInfosByName; //!< Same as columnInfosByNameExpanded but asterisks are skipped
 
 		//! field schemas created for multiple joined columns like a||' '||b||' '||c
 		Field::List *ownedVisibleColumns;
@@ -396,27 +396,27 @@ OrderByColumn::~OrderByColumn()
 {
 }
 
-QString OrderByColumn::debugString() const
+TQString OrderByColumn::debugString() const
 {
-	QString orderString( m_ascending ? "ascending" : "descending" );
+	TQString orderString( m_ascending ? "ascending" : "descending" );
 	if (m_column) {
 		if (m_pos>-1)
-			return QString("COLUMN_AT_POSITION_%1(%2, %3)")
-				.arg(m_pos+1).arg(m_column->debugString()).arg(orderString);
+			return TQString("COLUMN_AT_POSITION_%1(%2, %3)")
+				.tqarg(m_pos+1).tqarg(m_column->debugString()).tqarg(orderString);
 		else
-			return QString("COLUMN(%1, %2)").arg(m_column->debugString()).arg(orderString);
+			return TQString("COLUMN(%1, %2)").tqarg(m_column->debugString()).tqarg(orderString);
 	}
-	return m_field ? QString("FIELD(%1, %2)").arg(m_field->debugString()).arg(orderString)
-	 : QString("NONE");
+	return m_field ? TQString("FIELD(%1, %2)").tqarg(m_field->debugString()).tqarg(orderString)
+	 : TQString("NONE");
 }
 
-QString OrderByColumn::toSQLString(bool includeTableName, Driver *drv, int identifierEscaping) const
+TQString OrderByColumn::toSQLString(bool includeTableName, Driver *drv, int identifierEscaping) const
 {
-	const QString orderString( m_ascending ? "" : " DESC" );
-	QString fieldName, tableName;
+	const TQString orderString( m_ascending ? "" : " DESC" );
+	TQString fieldName, tableName;
 	if (m_column) {
 		if (m_pos>-1)
-			return QString::number(m_pos+1) + orderString;
+			return TQString::number(m_pos+1) + orderString;
 		else {
 			if (includeTableName && m_column->alias.isEmpty()) {
 				tableName = m_column->field->table()->name();
@@ -451,11 +451,11 @@ OrderByColumnList::OrderByColumnList()
 }
 
 bool OrderByColumnList::appendFields(QuerySchema& querySchema,
-	const QString& field1, bool ascending1, 
-	const QString& field2, bool ascending2, 
-	const QString& field3, bool ascending3, 
-	const QString& field4, bool ascending4, 
-	const QString& field5, bool ascending5)
+	const TQString& field1, bool ascending1, 
+	const TQString& field2, bool ascending2, 
+	const TQString& field3, bool ascending3, 
+	const TQString& field4, bool ascending4, 
+	const TQString& field5, bool ascending5)
 {
 	uint numAdded = 0;
 #define ADD_COL(fieldName, ascending) \
@@ -504,7 +504,7 @@ void OrderByColumnList::appendField(Field& field, bool ascending)
 }
 
 bool OrderByColumnList::appendField(QuerySchema& querySchema, 
-	const QString& fieldName, bool ascending)
+	const TQString& fieldName, bool ascending)
 {
 	QueryColumnInfo *columnInfo = querySchema.columnInfo( fieldName );
 	if (columnInfo) {
@@ -517,7 +517,7 @@ bool OrderByColumnList::appendField(QuerySchema& querySchema,
 		return true;
 	}
 	KexiDBWarn << "OrderByColumnList::addColumn(QuerySchema& querySchema, "
-		"const QString& column, bool ascending): no such field \"" << fieldName << "\"" << endl;
+		"const TQString& column, bool ascending): no such field \"" << fieldName << "\"" << endl;
 	return false;
 }
 		
@@ -526,11 +526,11 @@ void OrderByColumnList::appendColumn(const OrderByColumn& column)
 	append( column );
 }
 
-QString OrderByColumnList::debugString() const
+TQString OrderByColumnList::debugString() const
 {
 	if (isEmpty())
 		return "NONE";
-	QString dbg;
+	TQString dbg;
 	for (OrderByColumn::ListConstIterator it=constBegin(); it!=constEnd(); ++it) {
 		if (!dbg.isEmpty())
 			dbg += "\n";
@@ -539,9 +539,9 @@ QString OrderByColumnList::debugString() const
 	return dbg;
 }
 
-QString OrderByColumnList::toSQLString(bool includeTableNames, Driver *drv, int identifierEscaping) const
+TQString OrderByColumnList::toSQLString(bool includeTableNames, Driver *drv, int identifierEscaping) const
 {
-	QString string;
+	TQString string;
 	for (OrderByColumn::ListConstIterator it=constBegin(); it!=constEnd(); ++it) {
 		if (!string.isEmpty())
 			string += ", ";
@@ -569,7 +569,7 @@ QuerySchema::QuerySchema(TableSchema& tableSchema)
 	init();
 /*	if (!d->masterTable) {
 		KexiDBWarn << "QuerySchema(TableSchema*): !d->masterTable" << endl;
-		m_name = QString::null;
+		m_name = TQString();
 		return;
 	}*/
 	addTable(d->masterTable);
@@ -663,12 +663,12 @@ FieldList& QuerySchema::insertField(uint position, Field *field,
 		d->asterisks.append(field);
 		//if this is single-table asterisk,
 		//add a table to list if doesn't exist there:
-		if (field->table() && (d->tables.findRef(field->table())==-1))
+		if (field->table() && (d->tables.tqfindRef(field->table())==-1))
 			d->tables.append(field->table());
 	}
 	else if (field->table()) {
 		//add a table to list if doesn't exist there:
-		if (d->tables.findRef(field->table())==-1)
+		if (d->tables.tqfindRef(field->table())==-1)
 			d->tables.append(field->table());
 	}
 //	//visible by default
@@ -697,9 +697,9 @@ FieldList& QuerySchema::insertField(uint position, Field *field,
 	else
 		KexiDBDbg << " name=" << d->tables.at(bindToTable)->name() 
 			<< " alias=" << tableAlias(bindToTable) <<  endl;
-	QString s;
+	TQString s;
 	for (uint i=0; i<fieldCount();i++)
-		s+= (QString::number(d->tablesBoundToColumns[i]) + " ");
+		s+= (TQString::number(d->tablesBoundToColumns[i]) + " ");
 	KexiDBDbg << "tablesBoundToColumns == [" << s << "]" <<endl;
 
 	if (field->isExpression())
@@ -763,7 +763,7 @@ FieldList& QuerySchema::addAsterisk(QueryAsterisk *asterisk, bool visible)
 		return *this;
 	//make unique name
 	asterisk->m_name = (asterisk->table() ? asterisk->table()->name() + ".*" : "*") 
-		+ QString::number(asterisks()->count());
+		+ TQString::number(asterisks()->count());
 	return addField(asterisk, visible);
 }
 
@@ -773,19 +773,19 @@ Connection* QuerySchema::connection() const
 	return mt ? mt->connection() : 0;
 }
 
-QString QuerySchema::debugString()
+TQString QuerySchema::debugString()
 {
-	QString dbg;
+	TQString dbg;
 	dbg.reserve(1024);
 	//fields
 	TableSchema *mt = masterTable();
-	dbg = QString("QUERY ") + schemaDataDebugString() + "\n"
+	dbg = TQString("TQUERY ") + schemaDataDebugString() + "\n"
 		+ "-masterTable=" + (mt ? mt->name() :"<NULL>")
 		+ "\n-COLUMNS:\n"
 		+ ((fieldCount()>0) ? FieldList::debugString() : "<NONE>") + "\n"
 		+ "-FIELDS EXPANDED ";
 
-	QString dbg1;
+	TQString dbg1;
 	uint fieldsExpandedCount = 0;
 	if (fieldCount()>0) {
 		QueryColumnInfo::Vector fe( fieldsExpanded() );
@@ -801,7 +801,7 @@ QString QuerySchema::debugString()
 	else {
 		dbg1 = "<NONE>\n";
 	}
-	dbg1.prepend( QString("(%1):\n").arg(fieldsExpandedCount) );
+	dbg1.prepend( TQString("(%1):\n").tqarg(fieldsExpandedCount) );
 	dbg += dbg1;
 
 	//it's safer to delete fieldsExpanded for now 
@@ -809,15 +809,15 @@ QString QuerySchema::debugString()
 //causes a crash	d->clearCachedData();
 
 	//bindings
-	QString dbg2;
+	TQString dbg2;
 	dbg2.reserve(512);
 	for (uint i = 0; i<fieldCount(); i++) {
 		int tablePos = tableBoundToColumn(i);
 		if (tablePos>=0) {
-			QCString tAlias = tableAlias(tablePos);
+			TQCString tAlias = tableAlias(tablePos);
 			if (!tAlias.isEmpty()) {
-				dbg2 += (QString::fromLatin1(" field \"") + FieldList::field(i)->name() 
-					+ "\" uses alias \"" + QString(tAlias) + "\" of table \""
+				dbg2 += (TQString::tqfromLatin1(" field \"") + FieldList::field(i)->name() 
+					+ "\" uses alias \"" + TQString(tAlias) + "\" of table \""
 					+ d->tables.at(tablePos)->name() + "\"\n");
 			}
 		}
@@ -829,50 +829,50 @@ QString QuerySchema::debugString()
 	
 	//tables	
 	TableSchema *table;
-	QString table_names;
+	TQString table_names;
 	table_names.reserve(512);
 	for ( table = d->tables.first(); table; table = d->tables.next() ) {
 		if (!table_names.isEmpty())
 			table_names += ", ";
-		table_names += (QString("'") + table->name() + "'");
+		table_names += (TQString("'") + table->name() + "'");
 	}
 	if (d->tables.isEmpty())
 		table_names = "<NONE>";
-	dbg += (QString("-TABLES:\n") + table_names);
-	QString aliases;
+	dbg += (TQString("-TABLES:\n") + table_names);
+	TQString aliases;
 	if (!d->hasColumnAliases())
 		aliases = "<NONE>\n";
 	else {
 		Field::ListIterator it( m_fields );
 		for (int i=0; it.current(); ++it, i++) {
-			QCString *alias = d->columnAlias(i);
+			TQCString *alias = d->columnAlias(i);
 			if (alias)
-				aliases += (QString("field #%1: ").arg(i) 
+				aliases += (TQString("field #%1: ").tqarg(i) 
 					+ (it.current()->name().isEmpty() ? "<noname>" : it.current()->name())
 					+ " -> " + (const char*)*alias + "\n");
 		}
 	}
 	//aliases
-	dbg += QString("\n-COLUMN ALIASES:\n" + aliases);
+	dbg += TQString("\n-COLUMN ALIASES:\n" + aliases);
 	if (d->tableAliases.isEmpty())
 		aliases = "<NONE>";
 	else {
 		aliases = "";
 		TableSchema::ListIterator t_it(d->tables);
 		for (int i=0; t_it.current(); ++t_it, i++) {
-			QCString *alias = d->tableAliases[i];
+			TQCString *alias = d->tableAliases[i];
 			if (alias)
-				aliases += (QString("table #%1: ").arg(i) 
+				aliases += (TQString("table #%1: ").tqarg(i) 
 					+ (t_it.current()->name().isEmpty() ? "<noname>" : t_it.current()->name())
 					+ " -> " + (const char*)*alias + "\n");
 		}
 	}
-	dbg += QString("-TABLE ALIASES:\n" + aliases);
-	QString where = d->whereExpr ? d->whereExpr->debugString() : QString::null;
+	dbg += TQString("-TABLE ALIASES:\n" + aliases);
+	TQString where = d->whereExpr ? d->whereExpr->debugString() : TQString();
 	if (!where.isEmpty())
-		dbg += (QString("\n-WHERE EXPRESSION:\n") + where);
+		dbg += (TQString("\n-WHERE EXPRESSION:\n") + where);
 	if (!orderByColumnList().isEmpty())
-		dbg += (QString("\n-ORDER BY (%1):\n").arg(orderByColumnList().count()) 
+		dbg += (TQString("\n-ORDER BY (%1):\n").tqarg(orderByColumnList().count()) 
 			+ orderByColumnList().debugString());
 	return dbg;
 }
@@ -886,7 +886,7 @@ TableSchema* QuerySchema::masterTable() const
 
 	//try to find master table if there's only one table (with possible aliasses)
 	int num = 0;
-	QString tableNameLower;
+	TQString tableNameLower;
 	for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
 		if (!tableNameLower.isEmpty() && it.current()->name().lower()!=tableNameLower) {
 			//two or more different tables
@@ -908,7 +908,7 @@ TableSchema::List* QuerySchema::tables() const
 	return &d->tables;
 }
 
-void QuerySchema::addTable(TableSchema *table, const QCString& alias)
+void QuerySchema::addTable(TableSchema *table, const TQCString& alias)
 {
 	KexiDBDbg << "QuerySchema::addTable() " << (void *)table 
 		<< " alias=" << alias << endl;
@@ -918,13 +918,13 @@ void QuerySchema::addTable(TableSchema *table, const QCString& alias)
 	//only append table if:
 	//-it has alias
 	//-it has no alias but there is no such table on the list
-	if (alias.isEmpty() && d->tables.findRef(table)!=-1) {
-		const QString& tableNameLower = table->name().lower();
-		const QString& aliasLower = QString(alias.lower());
+	if (alias.isEmpty() && d->tables.tqfindRef(table)!=-1) {
+		const TQString& tableNameLower = table->name().lower();
+		const TQString& aliasLower = TQString(alias.lower());
 		int num = 0;
 		for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
 			if (it.current()->name().lower()==tableNameLower) {
-				const QString& tAlias = tableAlias(num);
+				const TQString& tAlias = tableAlias(num);
 				if (tAlias == aliasLower) {
 					KexiDBWarn << "QuerySchema::addTable(): table with \"" 
 						<< tAlias << "\" alias already added!" << endl;
@@ -950,7 +950,7 @@ void QuerySchema::removeTable(TableSchema *table)
 	//todo: remove fields!
 }
 
-TableSchema* QuerySchema::table(const QString& tableName) const
+TableSchema* QuerySchema::table(const TQString& tableName) const
 {
 //TODO: maybe use tables_byname?
 	for (TableSchema::ListIterator it(d->tables); it.current(); ++it) {
@@ -960,14 +960,14 @@ TableSchema* QuerySchema::table(const QString& tableName) const
 	return 0;
 }
 
-bool QuerySchema::contains(TableSchema *table) const
+bool QuerySchema::tqcontains(TableSchema *table) const
 {
-	return d->tables.findRef(table)!=-1;
+	return d->tables.tqfindRef(table)!=-1;
 }
 
-Field* QuerySchema::findTableField(const QString &tableOrTableAndFieldName) const
+Field* QuerySchema::findTableField(const TQString &tableOrTableAndFieldName) const
 {
-	QString tableName, fieldName;
+	TQString tableName, fieldName;
 	if (!KexiDB::splitToTableAndFieldParts(tableOrTableAndFieldName, 
 		tableName, fieldName, KexiDB::SetFieldNameIfNoTableName)) {
 		return 0;
@@ -985,10 +985,10 @@ Field* QuerySchema::findTableField(const QString &tableOrTableAndFieldName) cons
 	return tableSchema->field(fieldName);
 }
 
-QCString QuerySchema::columnAlias(uint position) const
+TQCString QuerySchema::columnAlias(uint position) const
 {
-	QCString *a = d->columnAlias(position);
-	return a ? *a : QCString();
+	TQCString *a = d->columnAlias(position);
+	return a ? *a : TQCString();
 }
 
 bool QuerySchema::hasColumnAlias(uint position) const
@@ -996,14 +996,14 @@ bool QuerySchema::hasColumnAlias(uint position) const
 	return d->columnAlias(position)!=0;
 }
 
-void QuerySchema::setColumnAlias(uint position, const QCString& alias)
+void QuerySchema::setColumnAlias(uint position, const TQCString& alias)
 {
 	if (position >= m_fields.count()) {
 		KexiDBWarn << "QuerySchema::setColumnAlias(): position ("  << position 
 			<< ") out of range!" << endl;
 		return;
 	}
-	QCString fixedAlias = alias.stripWhiteSpace();
+	TQCString fixedAlias = alias.stripWhiteSpace();
 	Field *f = FieldList::field(position);
 	if (f->captionOrName().isEmpty() && fixedAlias.isEmpty()) {
 		KexiDBWarn << "QuerySchema::setColumnAlias(): position ("  << position 
@@ -1013,13 +1013,13 @@ void QuerySchema::setColumnAlias(uint position, const QCString& alias)
 	d->setColumnAlias(position, fixedAlias);
 }
 
-QCString QuerySchema::tableAlias(uint position) const
+TQCString QuerySchema::tableAlias(uint position) const
 {
-	QCString *a = d->tableAliases[position];
-	return a ? *a : QCString();
+	TQCString *a = d->tableAliases[position];
+	return a ? *a : TQCString();
 }
 
-int QuerySchema::tablePositionForAlias(const QCString& name) const
+int QuerySchema::tablePositionForAlias(const TQCString& name) const
 {
 	int *num = d->tablePositionsForAliases[name];
 	if (!num)
@@ -1027,7 +1027,7 @@ int QuerySchema::tablePositionForAlias(const QCString& name) const
 	return *num;
 }
 
-int QuerySchema::tablePosition(const QString& tableName) const
+int QuerySchema::tablePosition(const TQString& tableName) const
 {
 	int num = 0;
 	for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
@@ -1037,11 +1037,11 @@ int QuerySchema::tablePosition(const QString& tableName) const
 	return -1;
 }
 
-QValueList<int> QuerySchema::tablePositions(const QString& tableName) const
+TQValueList<int> QuerySchema::tablePositions(const TQString& tableName) const
 {
 	int num = 0;
-	QValueList<int> result;
-	const QString& tableNameLower = tableName.lower();
+	TQValueList<int> result;
+	const TQString& tableNameLower = tableName.lower();
 	for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
 		if (it.current()->name().lower()==tableNameLower) {
 			result += num;
@@ -1055,7 +1055,7 @@ bool QuerySchema::hasTableAlias(uint position) const
 	return d->tableAliases[position]!=0;
 }
 
-int QuerySchema::columnPositionForAlias(const QCString& name) const
+int QuerySchema::columnPositionForAlias(const TQCString& name) const
 {
 	int *num = d->columnPositionsForAliases[name];
 	if (!num)
@@ -1063,16 +1063,16 @@ int QuerySchema::columnPositionForAlias(const QCString& name) const
 	return *num;
 }
 
-void QuerySchema::setTableAlias(uint position, const QCString& alias)
+void QuerySchema::setTableAlias(uint position, const TQCString& alias)
 {
 	if (position >= d->tables.count()) {
 		KexiDBWarn << "QuerySchema::setTableAlias(): position ("  << position 
 			<< ") out of range!" << endl;
 		return;
 	}
-	QCString fixedAlias = alias.stripWhiteSpace();
+	TQCString fixedAlias = alias.stripWhiteSpace();
 	if (fixedAlias.isEmpty()) {
-		QCString *oldAlias = d->tableAliases.take(position);
+		TQCString *oldAlias = d->tableAliases.take(position);
 		if (oldAlias) {
 			d->tablePositionsForAliases.remove(*oldAlias);
 			delete oldAlias;
@@ -1080,9 +1080,9 @@ void QuerySchema::setTableAlias(uint position, const QCString& alias)
 //			d->maxIndexWithTableAlias = -1;
 	}
 	else {
-		d->tableAliases.replace(position, new QCString(fixedAlias));
-		d->tablePositionsForAliases.replace(fixedAlias, new int(position));
-//		d->maxIndexWithTableAlias = QMAX( d->maxIndexWithTableAlias, (int)index );
+		d->tableAliases.tqreplace(position, new TQCString(fixedAlias));
+		d->tablePositionsForAliases.tqreplace(fixedAlias, new int(position));
+//		d->maxIndexWithTableAlias = TQMAX( d->maxIndexWithTableAlias, (int)index );
 	}
 }
 
@@ -1096,23 +1096,23 @@ Field::List* QuerySchema::asterisks() const
 	return &d->asterisks;
 }
 		
-QString QuerySchema::statement() const
+TQString QuerySchema::statement() const
 {
 	return d->statement;
 }
 
-void QuerySchema::setStatement(const QString &s)
+void QuerySchema::setStatement(const TQString &s)
 {
 	d->statement = s;
 }
 
-Field* QuerySchema::field(const QString& identifier, bool expanded)
+Field* QuerySchema::field(const TQString& identifier, bool expanded)
 {
 	QueryColumnInfo *ci = columnInfo(identifier, expanded);
 	return ci ? ci->field : 0;
 }
 
-QueryColumnInfo* QuerySchema::columnInfo(const QString& identifier, bool expanded)
+QueryColumnInfo* QuerySchema::columnInfo(const TQString& identifier, bool expanded)
 {
 	computeFieldsExpanded();
 	return expanded ? d->columnInfosByNameExpanded[identifier] : d->columnInfosByName[identifier];
@@ -1144,7 +1144,7 @@ QueryColumnInfo::Vector QuerySchema::fieldsExpanded(FieldsExpandedOptions option
 			if (options == WithInternalFieldsAndRowID) {
 				if (!d->fakeRowIDField) {
 					d->fakeRowIDField = new Field("rowID", Field::BigInteger);
-					d->fakeRowIDCol = new QueryColumnInfo(d->fakeRowIDField, QCString(), true);
+					d->fakeRowIDCol = new QueryColumnInfo(d->fakeRowIDField, TQCString(), true);
 				}
 				tmpFieldsExpandedWithInternal->insert( 
 					fieldsExpandedVectorSize + internalFieldsCount, d->fakeRowIDCol );
@@ -1157,14 +1157,14 @@ QueryColumnInfo::Vector QuerySchema::fieldsExpanded(FieldsExpandedOptions option
 		return *d->fieldsExpanded;
 
 	//options == Unique:
-	QDict<char> columnsAlreadyFound;
+	TQDict<char> columnsAlreadyFound;
 	QueryColumnInfo::Vector result( d->fieldsExpanded->count() ); //initial size is set
-//	QMapConstIterator<QueryColumnInfo*, bool> columnsAlreadyFoundIt;
+//	TQMapConstIterator<QueryColumnInfo*, bool> columnsAlreadyFoundIt;
 	//compute unique list
 	uint uniqueListCount = 0;
 	for (uint i=0; i<d->fieldsExpanded->count(); i++) {
 		QueryColumnInfo *ci = (*d->fieldsExpanded)[i];
-//		columnsAlreadyFoundIt = columnsAlreadyFound.find(ci);
+//		columnsAlreadyFoundIt = columnsAlreadyFound.tqfind(ci);
 //		uint foundColumnIndex = -1;
 		if (!columnsAlreadyFound[ci->aliasOrName()]) {// columnsAlreadyFoundIt==columnsAlreadyFound.constEnd())
 			columnsAlreadyFound.insert(ci->aliasOrName(), (char*)1);
@@ -1187,9 +1187,9 @@ QueryColumnInfo* QuerySchema::expandedOrInternalField(uint index)
 	return (index < vector.size()) ? vector[index] : 0;
 }
 
-inline QString lookupColumnKey(Field *foreignField, Field* field)
+inline TQString lookupColumnKey(Field *foreignField, Field* field)
 {
-	QString res;
+	TQString res;
 	if (field->table()) // can be 0 for anonymous fields built as joined multiple visible columns
 		res = field->table()->name() + ".";
 	return res + field->name() + "_" + foreignField->table()->name() + "." + foreignField->name();
@@ -1201,8 +1201,8 @@ void QuerySchema::computeFieldsExpanded()
 		return;
 
 	if (!d->columnsOrder) {
-		d->columnsOrder = new QMap<QueryColumnInfo*,int>();
-		d->columnsOrderWithoutAsterisks = new QMap<QueryColumnInfo*,int>();
+		d->columnsOrder = new TQMap<QueryColumnInfo*,int>();
+		d->columnsOrderWithoutAsterisks = new TQMap<QueryColumnInfo*,int>();
 	}
 	else {
 		d->columnsOrder->clear();
@@ -1214,7 +1214,7 @@ void QuerySchema::computeFieldsExpanded()
 	//collect all fields in a list (not a vector yet, because we do not know its size)
 	QueryColumnInfo::List list; //temporary
 	QueryColumnInfo::List lookup_list; //temporary, for collecting additional fields related to lookup fields
-	QMap<QueryColumnInfo*, bool> columnInfosOutsideAsterisks; //helper for filling d->columnInfosByName
+	TQMap<QueryColumnInfo*, bool> columnInfosOutsideAsterisks; //helper for filling d->columnInfosByName
 	uint i = 0;
 	uint fieldPosition = 0;
 	uint numberOfColumnsWithMultipleVisibleFields = 0; //used to find an unique name for anonymous field
@@ -1225,7 +1225,7 @@ void QuerySchema::computeFieldsExpanded()
 				Field::List *ast_fields = static_cast<QueryAsterisk*>(f)->table()->fields();
 				for (Field *ast_f = ast_fields->first(); ast_f; ast_f=ast_fields->next()) {
 //					d->detailedVisibility += isFieldVisible(fieldPosition);
-					QueryColumnInfo *ci = new QueryColumnInfo(ast_f, QCString()/*no field for asterisk!*/,
+					QueryColumnInfo *ci = new QueryColumnInfo(ast_f, TQCString()/*no field for asterisk!*/,
 						isColumnVisible(fieldPosition));
 					list.append( ci );
 					KexiDBDbg << "QuerySchema::computeFieldsExpanded(): caching (unexpanded) columns order: "
@@ -1242,7 +1242,7 @@ void QuerySchema::computeFieldsExpanded()
 //! \todo (js): perhaps not all fields should be appended here
 //						d->detailedVisibility += isFieldVisible(fieldPosition);
 //						list.append(tab_f);
-						QueryColumnInfo *ci = new QueryColumnInfo(tab_f, QCString()/*no field for asterisk!*/,
+						QueryColumnInfo *ci = new QueryColumnInfo(tab_f, TQCString()/*no field for asterisk!*/,
 							isColumnVisible(fieldPosition));
 						list.append( ci );
 						KexiDBDbg << "QuerySchema::computeFieldsExpanded(): caching (unexpanded) columns order: "
@@ -1291,10 +1291,10 @@ void QuerySchema::computeFieldsExpanded()
 						// (the expression object will be owned by column info)
 						visibleColumn = new Field();
 						visibleColumn->setName(
-							QString::fromLatin1("[multiple_visible_fields_%1]")
-							.arg( ++numberOfColumnsWithMultipleVisibleFields ));
+							TQString::tqfromLatin1("[multiple_visible_fields_%1]")
+							.tqarg( ++numberOfColumnsWithMultipleVisibleFields ));
 						visibleColumn->setExpression( 
-							new ConstExpr(CHARACTER_STRING_LITERAL, QVariant()/*not important*/));
+							new ConstExpr(CHARACTER_STRING_LITERAL, TQVariant()/*not important*/));
 						if (!d->ownedVisibleColumns) {
 							d->ownedVisibleColumns = new Field::List();
 							d->ownedVisibleColumns->setAutoDelete(true);
@@ -1303,14 +1303,14 @@ void QuerySchema::computeFieldsExpanded()
 					}
 
 					lookup_list.append( 
-						new QueryColumnInfo(visibleColumn, QCString(), true/*visible*/, ci/*foreign*/) );
+						new QueryColumnInfo(visibleColumn, TQCString(), true/*visible*/, ci/*foreign*/) );
 /*
 					//add visibleField to the list of SELECTed fields if it is not yes present there
 					if (!findTableField( visibleField->table()->name()+"."+visibleField->name() )) {
 						if (!table( visibleField->table()->name() )) {
 						}
 						if (!sql.isEmpty())
-							sql += QString::fromLatin1(", ");
+							sql += TQString::tqfromLatin1(", ");
 						sql += (escapeIdentifier(visibleField->table()->name(), drvEscaping) + "."
 							+ escapeIdentifier(visibleField->name(), drvEscaping));
 					}*/
@@ -1330,10 +1330,10 @@ void QuerySchema::computeFieldsExpanded()
 				Field *boundField = boundColumnInfo->field;
 				if (!boundField)
 					continue;
-				const QValueList<uint> visibleColumns( lookupFieldSchema->visibleColumns() );
+				const TQValueList<uint> visibleColumns( lookupFieldSchema->visibleColumns() );
 				bool ok = true;
 				// all indices in visibleColumns should be in [0..lookupQueryFieldsExpanded.size()-1]
-				foreach (QValueList<uint>::ConstIterator, visibleColumnsIt, visibleColumns) {
+				foreach (TQValueList<uint>::ConstIterator, visibleColumnsIt, visibleColumns) {
 					if ((*visibleColumnsIt) >= lookupQueryFieldsExpanded.count()) {
 						ok = false;
 						break;
@@ -1351,10 +1351,10 @@ void QuerySchema::computeFieldsExpanded()
 					// (the expression object will be owned by column info)
 					visibleColumn = new Field();
 					visibleColumn->setName(
-						QString::fromLatin1("[multiple_visible_fields_%1]")
-						.arg( ++numberOfColumnsWithMultipleVisibleFields ));
+						TQString::tqfromLatin1("[multiple_visible_fields_%1]")
+						.tqarg( ++numberOfColumnsWithMultipleVisibleFields ));
 					visibleColumn->setExpression( 
-						new ConstExpr(CHARACTER_STRING_LITERAL, QVariant()/*not important*/));
+						new ConstExpr(CHARACTER_STRING_LITERAL, TQVariant()/*not important*/));
 					if (!d->ownedVisibleColumns) {
 						d->ownedVisibleColumns = new Field::List();
 						d->ownedVisibleColumns->setAutoDelete(true);
@@ -1363,14 +1363,14 @@ void QuerySchema::computeFieldsExpanded()
 				}
 
 				lookup_list.append( 
-					new QueryColumnInfo(visibleColumn, QCString(), true/*visible*/, ci/*foreign*/) );
+					new QueryColumnInfo(visibleColumn, TQCString(), true/*visible*/, ci/*foreign*/) );
 /*
 				//add visibleField to the list of SELECTed fields if it is not yes present there
 				if (!findTableField( visibleField->table()->name()+"."+visibleField->name() )) {
 					if (!table( visibleField->table()->name() )) {
 					}
 					if (!sql.isEmpty())
-						sql += QString::fromLatin1(", ");
+						sql += TQString::tqfromLatin1(", ");
 					sql += (escapeIdentifier(visibleField->table()->name(), drvEscaping) + "."
 						+ escapeIdentifier(visibleField->name(), drvEscaping));
 				}*/
@@ -1381,7 +1381,7 @@ void QuerySchema::computeFieldsExpanded()
 	if (!d->fieldsExpanded) {
 		d->fieldsExpanded = new QueryColumnInfo::Vector( list.count() );// Field::Vector( list.count() );
 		d->fieldsExpanded->setAutoDelete(true);
-		d->columnsOrderExpanded = new QMap<QueryColumnInfo*,int>();
+		d->columnsOrderExpanded = new TQMap<QueryColumnInfo*,int>();
 	}
 	else {//for future:
 		d->fieldsExpanded->clear();
@@ -1406,13 +1406,13 @@ void QuerySchema::computeFieldsExpanded()
 			//store alias and table.alias
 			if (!d->columnInfosByNameExpanded[ ci->alias ])
 				d->columnInfosByNameExpanded.insert( ci->alias, ci );
-			QString tableAndAlias( ci->alias );
+			TQString tableAndAlias( ci->alias );
 			if (ci->field->table())
 				tableAndAlias.prepend(ci->field->table()->name() + ".");
 			if (!d->columnInfosByNameExpanded[ tableAndAlias ])
 				d->columnInfosByNameExpanded.insert( tableAndAlias, ci );
 			//the same for "unexpanded" list
-			if (columnInfosOutsideAsterisks.contains(ci)) {
+			if (columnInfosOutsideAsterisks.tqcontains(ci)) {
 				if (!d->columnInfosByName[ ci->alias ])
 					d->columnInfosByName.insert( ci->alias, ci );
 				if (!d->columnInfosByName[ tableAndAlias ])
@@ -1423,13 +1423,13 @@ void QuerySchema::computeFieldsExpanded()
 			//no alias: store name and table.name
 			if (!d->columnInfosByNameExpanded[ ci->field->name() ])
 				d->columnInfosByNameExpanded.insert( ci->field->name(), ci );
-			QString tableAndName( ci->field->name() );
+			TQString tableAndName( ci->field->name() );
 			if (ci->field->table())
 				tableAndName.prepend(ci->field->table()->name() + ".");
 			if (!d->columnInfosByNameExpanded[ tableAndName ])
 				d->columnInfosByNameExpanded.insert( tableAndName, ci );
 			//the same for "unexpanded" list
-			if (columnInfosOutsideAsterisks.contains(ci)) {
+			if (columnInfosOutsideAsterisks.tqcontains(ci)) {
 				if (!d->columnInfosByName[ ci->field->name() ])
 					d->columnInfosByName.insert( ci->field->name(), ci );
 				if (!d->columnInfosByName[ tableAndName ])
@@ -1439,13 +1439,13 @@ void QuerySchema::computeFieldsExpanded()
 	}
 
 	//remove duplicates for lookup fields
-	QDict<uint> lookup_dict(101); //used to fight duplicates and to update QueryColumnInfo::indexForVisibleLookupValue()
+	TQDict<uint> lookup_dict(101); //used to fight duplicates and to update QueryColumnInfo::indexForVisibleLookupValue()
 	                         // (a mapping from table.name string to uint* lookupFieldIndex
 	lookup_dict.setAutoDelete(true);
 	i=0;
 	for (QueryColumnInfo::ListIterator it(lookup_list); (ci = it.current());)
 	{
-		const QString key( lookupColumnKey(ci->foreignColumn()->field, ci->field) );
+		const TQString key( lookupColumnKey(ci->foreignColumn()->field, ci->field) );
 		if ( /* not needed   columnInfo( tableAndFieldName ) || */
 			lookup_dict[ key ]) {
 			// this table.field is already fetched by this query
@@ -1453,7 +1453,7 @@ void QuerySchema::computeFieldsExpanded()
 			lookup_list.removeRef( ci );
 		}
 		else {
-			lookup_dict.replace( key, new uint( i ) );
+			lookup_dict.tqreplace( key, new uint( i ) );
 			++it;
 			i++;
 		}
@@ -1502,15 +1502,15 @@ void QuerySchema::computeFieldsExpanded()
 				if (visibleColumns->fieldCount() == 1) 
 				{
 					visibleColumn = visibleColumns->fields()->first();
-					const QString key( lookupColumnKey(ci->field, visibleColumn) );
+					const TQString key( lookupColumnKey(ci->field, visibleColumn) );
 					uint *index = lookup_dict[ key ];
 					if (index)
 						ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
 				}
 				else {
-					const QString key( QString::fromLatin1("[multiple_visible_fields_%1]_%2.%3")
-						.arg( ++numberOfColumnsWithMultipleVisibleFields )
-						.arg(ci->field->table()->name()).arg(ci->field->name()) );
+					const TQString key( TQString::tqfromLatin1("[multiple_visible_fields_%1]_%2.%3")
+						.tqarg( ++numberOfColumnsWithMultipleVisibleFields )
+						.tqarg(ci->field->table()->name()).tqarg(ci->field->name()) );
 					uint *index = lookup_dict[ key ];
 					if (index)
 						ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
@@ -1531,20 +1531,20 @@ void QuerySchema::computeFieldsExpanded()
 			Field *boundField = boundColumnInfo->field;
 			if (!boundField)
 				continue;
-			const QValueList<uint> visibleColumns( lookupFieldSchema->visibleColumns() );
+			const TQValueList<uint> visibleColumns( lookupFieldSchema->visibleColumns() );
 			Field *visibleColumn = 0;
 			// for single visible column, just add it as-is
 			if (visibleColumns.count() == 1) {
 				visibleColumn = lookupQueryFieldsExpanded[ visibleColumns.first() ]->field;
-				const QString key( lookupColumnKey(ci->field, visibleColumn) );
+				const TQString key( lookupColumnKey(ci->field, visibleColumn) );
 				uint *index = lookup_dict[ key ];
 				if (index)
 					ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
 			}
 			else {
-				const QString key( QString::fromLatin1("[multiple_visible_fields_%1]_%2.%3")
-					.arg( ++numberOfColumnsWithMultipleVisibleFields )
-					.arg(ci->field->table()->name()).arg(ci->field->name()) );
+				const TQString key( TQString::tqfromLatin1("[multiple_visible_fields_%1]_%2.%3")
+					.tqarg( ++numberOfColumnsWithMultipleVisibleFields )
+					.tqarg(ci->field->table()->name()).tqarg(ci->field->name()) );
 				uint *index = lookup_dict[ key ];
 				if (index)
 					ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
@@ -1557,7 +1557,7 @@ void QuerySchema::computeFieldsExpanded()
 	}
 }
 
-QMap<QueryColumnInfo*,int> QuerySchema::columnsOrder(ColumnsOrderOptions options)
+TQMap<QueryColumnInfo*,int> QuerySchema::columnsOrder(ColumnsOrderOptions options)
 {
 	if (!d->columnsOrder)
 		computeFieldsExpanded();
@@ -1568,20 +1568,20 @@ QMap<QueryColumnInfo*,int> QuerySchema::columnsOrder(ColumnsOrderOptions options
 	return *d->columnsOrderExpanded;
 }
 
-QValueVector<int> QuerySchema::pkeyFieldsOrder()
+TQValueVector<int> QuerySchema::pkeyFieldsOrder()
 {
 	if (d->pkeyFieldsOrder)
 		return *d->pkeyFieldsOrder;
 
 	TableSchema *tbl = masterTable();
 	if (!tbl || !tbl->primaryKey())
-		return QValueVector<int>();
+		return TQValueVector<int>();
 
 	//get order of PKEY fields (e.g. for rows updating or inserting )
 	IndexSchema *pkey = tbl->primaryKey();
 	pkey->debug();
 	debug();
-	d->pkeyFieldsOrder = new QValueVector<int>( pkey->fieldCount(), -1 );
+	d->pkeyFieldsOrder = new TQValueVector<int>( pkey->fieldCount(), -1 );
 
 	const uint fCount = fieldsExpanded().count();
 	d->pkeyFieldsCount = 0;
@@ -1600,7 +1600,7 @@ QValueVector<int> QuerySchema::pkeyFieldsOrder()
 		}
 	}
 	KexiDBDbg << "QuerySchema::pkeyFieldsOrder(): " << d->pkeyFieldsCount
-		<< " OUT OF " << pkey->fieldCount() << " PKEY'S FIELDS FOUND IN QUERY " << name() << endl;
+		<< " OUT OF " << pkey->fieldCount() << " PKEY'S FIELDS FOUND IN TQUERY " << name() << endl;
 	return *d->pkeyFieldsOrder;
 }
 
@@ -1645,11 +1645,11 @@ QueryColumnInfo::List* QuerySchema::autoIncrementFields()
 	return d->autoincFields;
 }
 
-QString QuerySchema::sqlColumnsList(QueryColumnInfo::List* infolist, Driver *driver)
+TQString QuerySchema::sqlColumnsList(QueryColumnInfo::List* infolist, Driver *driver)
 {
 	if (!infolist)
-		return QString::null;
-	QString result;
+		return TQString();
+	TQString result;
 	result.reserve(256);
 	QueryColumnInfo::ListIterator it( *infolist );
 	bool start = true;
@@ -1663,7 +1663,7 @@ QString QuerySchema::sqlColumnsList(QueryColumnInfo::List* infolist, Driver *dri
 	return result;
 }
 
-QString QuerySchema::autoIncrementSQLFieldsList(Driver *driver)
+TQString QuerySchema::autoIncrementSQLFieldsList(Driver *driver)
 {
 	if ((Driver *)d->lastUsedDriverForAutoIncrementSQLFieldsList != driver
 		|| d->autoIncrementSQLFieldsList.isEmpty())
@@ -1680,7 +1680,7 @@ void QuerySchema::setWhereExpression(BaseExpr *expr)
 	d->whereExpr = expr;
 }
 
-void QuerySchema::addToWhereExpression(KexiDB::Field *field, const QVariant& value, int relation)
+void QuerySchema::addToWhereExpression(KexiDB::Field *field, const TQVariant& value, int relation)
 {
 	int token;
 	if (value.isNull())
@@ -1700,7 +1700,7 @@ void QuerySchema::addToWhereExpression(KexiDB::Field *field, const QVariant& val
 		KexiDBExpr_Relational, 
 		new ConstExpr( token, value ),
 		relation,
-		new VariableExpr((field->table() ? (field->table()->name()+".") : QString::null)+field->name())
+		new VariableExpr((field->table() ? (field->table()->name()+".") : TQString())+field->name())
 	);
 	if (d->whereExpr) {
 		d->whereExpr = new BinaryExpr(
@@ -1716,7 +1716,7 @@ void QuerySchema::addToWhereExpression(KexiDB::Field *field, const QVariant& val
 }
 
 /*
-void QuerySchema::addToWhereExpression(KexiDB::Field *field, const QVariant& value)
+void QuerySchema::addToWhereExpression(KexiDB::Field *field, const TQVariant& value)
 		switch (value.type()) {
 		case Int: case UInt: case Bool: case LongLong: case ULongLong:
 			token = INTEGER_CONST;
@@ -1837,13 +1837,13 @@ void QueryAsterisk::setTable(TableSchema *table)
 	m_table=table;
 }
 
-QString QueryAsterisk::debugString() const
+TQString QueryAsterisk::debugString() const
 {
-	QString dbg;
+	TQString dbg;
 	if (isAllTableAsterisk()) {
 		dbg += "ALL-TABLES ASTERISK (*) ON TABLES(";
 		TableSchema *table;
-		QString table_names;
+		TQString table_names;
 		for (TableSchema::ListIterator it( *query()->tables() ); (table = it.current()); ++it) {
 			if (!table_names.isEmpty())
 				table_names += ", ";