Trinity Qt initial conversion

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

1 files changed, 149 insertions, 149 deletions

diff --git a/kalarm/kamail.cpp b/kalarm/kamail.cpp
index 3042a270..18bb0394 100644
--- a/kalarm/kamail.cpp
+++ b/kalarm/kamail.cpp
@@ -27,8 +27,8 @@
 #include <sys/time.h>
 #include <pwd.h>
 
-#include <qfile.h>
-#include <qregexp.h>
+#include <tqfile.h>
+#include <tqregexp.h>
 
 #include <kstandarddirs.h>
 #include <dcopclient.h>
@@ -63,29 +63,29 @@ namespace HeaderParsing
 bool parseAddress( const char* & scursor, const char * const send,
                    KMime::Types::Address & result, bool isCRLF=false );
 bool parseAddressList( const char* & scursor, const char * const send,
-                       QValueList<KMime::Types::Address> & result, bool isCRLF=false );
+                       TQValueList<KMime::Types::Address> & result, bool isCRLF=false );
 }
 
 namespace
 {
-QString getHostName();
+TQString getHostName();
 }
 
 struct KAMailData
 {
-	KAMailData(const KAEvent& e, const QString& fr, const QString& bc, bool allownotify)
+	KAMailData(const KAEvent& e, const TQString& fr, const TQString& bc, bool allownotify)
 	                 : event(e), from(fr), bcc(bc), allowNotify(allownotify) { }
 	const KAEvent& event;
-	QString        from;
-	QString        bcc;
+	TQString        from;
+	TQString        bcc;
 	bool           allowNotify;
 };
 
 
-QString KAMail::i18n_NeedFromEmailAddress()
+TQString KAMail::i18n_NeedFromEmailAddress()
 { return i18n("A 'From' email address must be configured in order to execute email alarms."); }
 
-QString KAMail::i18n_sent_mail()
+TQString KAMail::i18n_sent_mail()
 { return i18n("KMail folder name: this should be translated the same as in kmail", "sent-mail"); }
 
 KPIM::IdentityManager* KAMail::mIdentityManager = 0;
@@ -102,10 +102,10 @@ KPIM::IdentityManager* KAMail::identityManager()
 * Reply = true if the message was sent - 'errmsgs' may contain copy error messages.
 *       = false if the message was not sent - 'errmsgs' contains the error messages.
 */
-bool KAMail::send(const KAEvent& event, QStringList& errmsgs, bool allowNotify)
+bool KAMail::send(const KAEvent& event, TQStringList& errmsgs, bool allowNotify)
 {
-	QString err;
-	QString from;
+	TQString err;
+	TQString from;
 	KPIM::Identity identity;
 	if (!event.emailFromId())
 		from = Preferences::emailAddress();
@@ -144,7 +144,7 @@ bool KAMail::send(const KAEvent& event, QStringList& errmsgs, bool allowNotify)
 		return false;
 	}
 	KAMailData data(event, from,
-	                (event.emailBcc() ? Preferences::emailBccAddress() : QString::null),
+	                (event.emailBcc() ? Preferences::emailBccAddress() : TQString::null),
 	                allowNotify);
 	kdDebug(5950) << "KAlarmApp::sendEmail(): To: " << event.emailAddresses(", ")
 	              << "\nSubject: " << event.emailSubject() << endl;
@@ -152,31 +152,31 @@ bool KAMail::send(const KAEvent& event, QStringList& errmsgs, bool allowNotify)
 	if (Preferences::emailClient() == Preferences::SENDMAIL)
 	{
 		// Use sendmail to send the message
-		QString textComplete;
-		QString command = KStandardDirs::findExe(QString::fromLatin1("sendmail"),
-		                                         QString::fromLatin1("/sbin:/usr/sbin:/usr/lib"));
+		TQString textComplete;
+		TQString command = KStandardDirs::findExe(TQString::fromLatin1("sendmail"),
+		                                         TQString::fromLatin1("/sbin:/usr/sbin:/usr/lib"));
 		if (!command.isNull())
 		{
-			command += QString::fromLatin1(" -f ");
+			command += TQString::fromLatin1(" -f ");
 			command += KPIM::getEmailAddress(from);
-			command += QString::fromLatin1(" -oi -t ");
+			command += TQString::fromLatin1(" -oi -t ");
 			textComplete = initHeaders(data, false);
 		}
 		else
 		{
-			command = KStandardDirs::findExe(QString::fromLatin1("mail"));
+			command = KStandardDirs::findExe(TQString::fromLatin1("mail"));
 			if (command.isNull())
 			{
-				errmsgs = errors(i18n("%1 not found").arg(QString::fromLatin1("sendmail"))); // give up
+				errmsgs = errors(i18n("%1 not found").arg(TQString::fromLatin1("sendmail"))); // give up
 				return false;
 			}
 
-			command += QString::fromLatin1(" -s ");
+			command += TQString::fromLatin1(" -s ");
 			command += KShellProcess::quote(event.emailSubject());
 
 			if (!data.bcc.isEmpty())
 			{
-				command += QString::fromLatin1(" -b ");
+				command += TQString::fromLatin1(" -b ");
 				command += KShellProcess::quote(data.bcc);
 			}
 
@@ -233,29 +233,29 @@ bool KAMail::send(const KAEvent& event, QStringList& errmsgs, bool allowNotify)
 * Reply = reason for failure (which may be the empty string)
 *       = null string if success.
 */
-QString KAMail::sendKMail(const KAMailData& data)
+TQString KAMail::sendKMail(const KAMailData& data)
 {
-	QString err = KAlarm::runKMail(true);
+	TQString err = KAlarm::runKMail(true);
 	if (!err.isNull())
 		return err;
 
 	// KMail is now running. Determine which DCOP call to use.
 	bool useSend = false;
-	QCString sendFunction = "sendMessage(QString,QString,QString,QString,QString,QString,KURL::List)";
+	TQCString sendFunction = "sendMessage(TQString,TQString,TQString,TQString,TQString,TQString,KURL::List)";
 	QCStringList funcs = kapp->dcopClient()->remoteFunctions("kmail", "MailTransportServiceIface");
 	for (QCStringList::Iterator it=funcs.begin();  it != funcs.end() && !useSend;  ++it)
 	{
-		QCString func = DCOPClient::normalizeFunctionSignature(*it);
+		TQCString func = DCOPClient::normalizeFunctionSignature(*it);
 		if (func.left(5) == "bool ")
 		{
 			func = func.mid(5);
-			func.replace(QRegExp(" [0-9A-Za-z_:]+"), "");
+			func.replace(TQRegExp(" [0-9A-Za-z_:]+"), "");
 			useSend = (func == sendFunction);
 		}
 	}
 
-	QByteArray  callData;
-	QDataStream arg(callData, IO_WriteOnly);
+	TQByteArray  callData;
+	TQDataStream arg(callData, IO_WriteOnly);
 	kdDebug(5950) << "KAMail::sendKMail(): using " << (useSend ? "sendMessage()" : "dcopAddMessage()") << endl;
 	if (useSend)
 	{
@@ -281,7 +281,7 @@ QString KAMail::sendKMail(const KAMailData& data)
 	}
 	if (data.allowNotify)
 		notifyQueued(data.event);
-	return QString::null;
+	return TQString::null;
 }
 
 /******************************************************************************
@@ -289,14 +289,14 @@ QString KAMail::sendKMail(const KAMailData& data)
 * Reply = reason for failure (which may be the empty string)
 *       = null string if success.
 */
-QString KAMail::addToKMailFolder(const KAMailData& data, const char* folder, bool checkKmailRunning)
+TQString KAMail::addToKMailFolder(const KAMailData& data, const char* folder, bool checkKmailRunning)
 {
-	QString err;
+	TQString err;
 	if (checkKmailRunning)
 		err = KAlarm::runKMail(true);
 	if (err.isNull())
 	{
-		QString message = initHeaders(data, true);
+		TQString message = initHeaders(data, true);
 		err = appendBodyAttachments(message, data.event);
 		if (!err.isNull())
 			return err;
@@ -304,26 +304,26 @@ QString KAMail::addToKMailFolder(const KAMailData& data, const char* folder, boo
 		// Write to a temporary file for feeding to KMail
 		KTempFile tmpFile;
 		tmpFile.setAutoDelete(true);     // delete file when it is destructed
-		QTextStream* stream = tmpFile.textStream();
+		TQTextStream* stream = tmpFile.textStream();
 		if (!stream)
 		{
 			kdError(5950) << "KAMail::addToKMailFolder(" << folder << "): Unable to open a temporary mail file" << endl;
-			return QString("");
+			return TQString("");
 		}
 		*stream << message;
 		tmpFile.close();
 		if (tmpFile.status())
 		{
 			kdError(5950) << "KAMail::addToKMailFolder(" << folder << "): Error " << tmpFile.status() << " writing to temporary mail file" << endl;
-			return QString("");
+			return TQString("");
 		}
 
 		// Notify KMail of the message in the temporary file
-		QByteArray  callData;
-		QDataStream arg(callData, IO_WriteOnly);
-		arg << QString::fromLatin1(folder) << tmpFile.name();
-		if (callKMail(callData, "KMailIface", "dcopAddMessage(QString,QString)", "int"))
-			return QString::null;
+		TQByteArray  callData;
+		TQDataStream arg(callData, IO_WriteOnly);
+		arg << TQString::fromLatin1(folder) << tmpFile.name();
+		if (callKMail(callData, "KMailIface", "dcopAddMessage(TQString,TQString)", "int"))
+			return TQString::null;
 		err = i18n("Error calling KMail");
 	}
 	kdError(5950) << "KAMail::addToKMailFolder(" << folder << "): " << err << endl;
@@ -333,21 +333,21 @@ QString KAMail::addToKMailFolder(const KAMailData& data, const char* folder, boo
 /******************************************************************************
 * Call KMail via DCOP. The DCOP function must return an 'int'.
 */
-bool KAMail::callKMail(const QByteArray& callData, const QCString& iface, const QCString& function, const QCString& funcType)
+bool KAMail::callKMail(const TQByteArray& callData, const TQCString& iface, const TQCString& function, const TQCString& funcType)
 {
-	QCString   replyType;
-	QByteArray replyData;
+	TQCString   replyType;
+	TQByteArray replyData;
 	if (!kapp->dcopClient()->call("kmail", iface, function, callData, replyType, replyData)
 	||  replyType != funcType)
 	{
-		QCString funcname = function;
-		funcname.replace(QRegExp("(.+$"), "()");
+		TQCString funcname = function;
+		funcname.replace(TQRegExp("(.+$"), "()");
 		kdError(5950) << "KAMail::callKMail(): kmail " << funcname << " call failed\n";;
 		return false;
 	}
-	QDataStream replyStream(replyData, IO_ReadOnly);
-	QCString funcname = function;
-	funcname.replace(QRegExp("(.+$"), "()");
+	TQDataStream replyStream(replyData, IO_ReadOnly);
+	TQCString funcname = function;
+	funcname.replace(TQRegExp("(.+$"), "()");
 	if (replyType == "int")
 	{
 		int result;
@@ -374,9 +374,9 @@ bool KAMail::callKMail(const QByteArray& callData, const QCString& iface, const
 /******************************************************************************
 * Create the headers part of the email.
 */
-QString KAMail::initHeaders(const KAMailData& data, bool dateId)
+TQString KAMail::initHeaders(const KAMailData& data, bool dateId)
 {
-	QString message;
+	TQString message;
 	if (dateId)
 	{
 		struct timeval tod;
@@ -384,17 +384,17 @@ QString KAMail::initHeaders(const KAMailData& data, bool dateId)
 		time_t timenow = tod.tv_sec;
 		char buff[64];
 		strftime(buff, sizeof(buff), "Date: %a, %d %b %Y %H:%M:%S %z", localtime(&timenow));
-		QString from = data.from;
-		from.replace(QRegExp("^.*<"), QString::null).replace(QRegExp(">.*$"), QString::null);
-		message = QString::fromLatin1(buff);
-		message += QString::fromLatin1("\nMessage-Id: <%1.%2.%3>\n").arg(timenow).arg(tod.tv_usec).arg(from);
+		TQString from = data.from;
+		from.replace(TQRegExp("^.*<"), TQString::null).replace(TQRegExp(">.*$"), TQString::null);
+		message = TQString::fromLatin1(buff);
+		message += TQString::fromLatin1("\nMessage-Id: <%1.%2.%3>\n").arg(timenow).arg(tod.tv_usec).arg(from);
 	}
-	message += QString::fromLatin1("From: ") + data.from;
-	message += QString::fromLatin1("\nTo: ") + data.event.emailAddresses(", ");
+	message += TQString::fromLatin1("From: ") + data.from;
+	message += TQString::fromLatin1("\nTo: ") + data.event.emailAddresses(", ");
 	if (!data.bcc.isEmpty())
-		message += QString::fromLatin1("\nBcc: ") + data.bcc;
-	message += QString::fromLatin1("\nSubject: ") + data.event.emailSubject();
-	message += QString::fromLatin1("\nX-Mailer: %1/" KALARM_VERSION).arg(kapp->aboutData()->programName());
+		message += TQString::fromLatin1("\nBcc: ") + data.bcc;
+	message += TQString::fromLatin1("\nSubject: ") + data.event.emailSubject();
+	message += TQString::fromLatin1("\nX-Mailer: %1/" KALARM_VERSION).arg(kapp->aboutData()->programName());
 	return message;
 }
 
@@ -403,7 +403,7 @@ QString KAMail::initHeaders(const KAMailData& data, bool dateId)
 * Reply = reason for error
 *       = 0 if successful.
 */
-QString KAMail::appendBodyAttachments(QString& message, const KAEvent& event)
+TQString KAMail::appendBodyAttachments(TQString& message, const KAEvent& event)
 {
 	static const char* textMimeTypes[] = {
 		"application/x-sh", "application/x-csh", "application/x-shellscript",
@@ -411,7 +411,7 @@ QString KAMail::appendBodyAttachments(QString& message, const KAEvent& event)
 		"application/x-perl", "application/x-desktop",
 		0
 	};
-	QStringList attachments = event.emailAttachments();
+	TQStringList attachments = event.emailAttachments();
 	if (!attachments.count())
 	{
 		// There are no attachments, so simply append the message body
@@ -424,23 +424,23 @@ QString KAMail::appendBodyAttachments(QString& message, const KAEvent& event)
 		// Create a boundary string
 		time_t timenow;
 		time(&timenow);
-		QCString boundary;
+		TQCString boundary;
 		boundary.sprintf("------------_%lu_-%lx=", 2*timenow, timenow);
-		message += QString::fromLatin1("\nMIME-Version: 1.0");
-		message += QString::fromLatin1("\nContent-Type: multipart/mixed;\n  boundary=\"%1\"\n").arg(boundary);
+		message += TQString::fromLatin1("\nMIME-Version: 1.0");
+		message += TQString::fromLatin1("\nContent-Type: multipart/mixed;\n  boundary=\"%1\"\n").arg(boundary);
 
 		if (!event.message().isEmpty())
 		{
 			// There is a message body
-			message += QString::fromLatin1("\n--%1\nContent-Type: text/plain\nContent-Transfer-Encoding: 8bit\n\n").arg(boundary);
+			message += TQString::fromLatin1("\n--%1\nContent-Type: text/plain\nContent-Transfer-Encoding: 8bit\n\n").arg(boundary);
 			message += event.message();
 		}
 
 		// Append each attachment in turn
-		QString attachError = i18n("Error attaching file:\n%1");
-		for (QStringList::Iterator at = attachments.begin();  at != attachments.end();  ++at)
+		TQString attachError = i18n("Error attaching file:\n%1");
+		for (TQStringList::Iterator at = attachments.begin();  at != attachments.end();  ++at)
 		{
-			QString attachment = (*at).local8Bit();
+			TQString attachment = (*at).local8Bit();
 			KURL url(attachment);
 			url.cleanPath();
 			KIO::UDSEntry uds;
@@ -455,7 +455,7 @@ QString KAMail::appendBodyAttachments(QString& message, const KAEvent& event)
 			}
 
 			// Check if the attachment is a text file
-			QString mimeType = fi.mimetype();
+			TQString mimeType = fi.mimetype();
 			bool text = mimeType.startsWith("text/");
 			if (!text)
 			{
@@ -463,29 +463,29 @@ QString KAMail::appendBodyAttachments(QString& message, const KAEvent& event)
 					text = (mimeType == textMimeTypes[i]);
 			}
 
-			message += QString::fromLatin1("\n--%1").arg(boundary);
-			message += QString::fromLatin1("\nContent-Type: %2; name=\"%3\"").arg(mimeType).arg(fi.text());
-			message += QString::fromLatin1("\nContent-Transfer-Encoding: %1").arg(QString::fromLatin1(text ? "8bit" : "BASE64"));
-			message += QString::fromLatin1("\nContent-Disposition: attachment; filename=\"%4\"\n\n").arg(fi.text());
+			message += TQString::fromLatin1("\n--%1").arg(boundary);
+			message += TQString::fromLatin1("\nContent-Type: %2; name=\"%3\"").arg(mimeType).arg(fi.text());
+			message += TQString::fromLatin1("\nContent-Transfer-Encoding: %1").arg(TQString::fromLatin1(text ? "8bit" : "BASE64"));
+			message += TQString::fromLatin1("\nContent-Disposition: attachment; filename=\"%4\"\n\n").arg(fi.text());
 
 			// Read the file contents
-			QString tmpFile;
+			TQString tmpFile;
 			if (!KIO::NetAccess::download(url, tmpFile, MainWindow::mainMainWindow())) {
 				kdError(5950) << "KAMail::appendBodyAttachments(): load failure: " << attachment << endl;
 				return attachError.arg(attachment);
 			}
-			QFile file(tmpFile);
+			TQFile file(tmpFile);
 			if (!file.open(IO_ReadOnly) ) {
 				kdDebug(5950) << "KAMail::appendBodyAttachments() tmp load error: " << attachment << endl;
 				return attachError.arg(attachment);
 			}
-			QIODevice::Offset size = file.size();
+			TQIODevice::Offset size = file.size();
 			char* contents = new char [size + 1];
 			Q_LONG bytes = file.readBlock(contents, size);
 			file.close();
 			contents[size] = 0;
 			bool atterror = false;
-			if (bytes == -1  ||  (QIODevice::Offset)bytes < size) {
+			if (bytes == -1  ||  (TQIODevice::Offset)bytes < size) {
 				kdDebug(5950) << "KAMail::appendBodyAttachments() read error: " << attachment << endl;
 				atterror = true;
 			}
@@ -497,23 +497,23 @@ QString KAMail::appendBodyAttachments(QString& message, const KAEvent& event)
 			else
 			{
 				// Convert the attachment to BASE64 encoding
-				QIODevice::Offset base64Size;
+				TQIODevice::Offset base64Size;
 				char* base64 = base64Encode(contents, size, base64Size);
-				if (base64Size == (QIODevice::Offset)-1) {
+				if (base64Size == (TQIODevice::Offset)-1) {
 					kdDebug(5950) << "KAMail::appendBodyAttachments() base64 buffer overflow: " << attachment << endl;
 					atterror = true;
 				}
 				else
-					message += QString::fromLatin1(base64, base64Size);
+					message += TQString::fromLatin1(base64, base64Size);
 				delete[] base64;
 			}
 			delete[] contents;
 			if (atterror)
 				return attachError.arg(attachment);
 		}
-		message += QString::fromLatin1("\n--%1--\n.\n").arg(boundary);
+		message += TQString::fromLatin1("\n--%1--\n.\n").arg(boundary);
 	}
-	return QString::null;
+	return TQString::null;
 }
 
 /******************************************************************************
@@ -523,23 +523,23 @@ QString KAMail::appendBodyAttachments(QString& message, const KAEvent& event)
 void KAMail::notifyQueued(const KAEvent& event)
 {
 	KMime::Types::Address addr;
-	QString localhost = QString::fromLatin1("localhost");
-	QString hostname  = getHostName();
+	TQString localhost = TQString::fromLatin1("localhost");
+	TQString hostname  = getHostName();
 	const EmailAddressList& addresses = event.emailAddresses();
-	for (QValueList<KCal::Person>::ConstIterator it = addresses.begin();  it != addresses.end();  ++it)
+	for (TQValueList<KCal::Person>::ConstIterator it = addresses.begin();  it != addresses.end();  ++it)
 	{
-		QCString email = (*it).email().local8Bit();
+		TQCString email = (*it).email().local8Bit();
 		const char* em = email;
 		if (!email.isEmpty()
 		&&  HeaderParsing::parseAddress(em, em + email.length(), addr))
 		{
-			QString domain = addr.mailboxList.first().addrSpec.domain;
+			TQString domain = addr.mailboxList.first().addrSpec.domain;
 			if (!domain.isEmpty()  &&  domain != localhost  &&  domain != hostname)
 			{
-				QString text = (Preferences::emailClient() == Preferences::KMAIL)
+				TQString text = (Preferences::emailClient() == Preferences::KMAIL)
 				             ? i18n("An email has been queued to be sent by KMail")
 				             : i18n("An email has been queued to be sent");
-				KMessageBox::information(0, text, QString::null, Preferences::EMAIL_QUEUED_NOTIFY);
+				KMessageBox::information(0, text, TQString::null, Preferences::EMAIL_QUEUED_NOTIFY);
 				return;
 			}
 		}
@@ -558,7 +558,7 @@ bool KAMail::identitiesExist()
 /******************************************************************************
 *  Fetch the uoid of an email identity name or uoid string.
 */
-uint KAMail::identityUoid(const QString& identityUoidOrName)
+uint KAMail::identityUoid(const TQString& identityUoidOrName)
 {
 	bool ok;
 	uint id = identityUoidOrName.toUInt(&ok);
@@ -581,7 +581,7 @@ uint KAMail::identityUoid(const QString& identityUoidOrName)
 /******************************************************************************
 *  Fetch the user's email address configured in the KDE Control Centre.
 */
-QString KAMail::controlCentreAddress()
+TQString KAMail::controlCentreAddress()
 {
 	KEMailSettings e;
 	return e.getSetting(KEMailSettings::EmailAddress);
@@ -592,26 +592,26 @@ QString KAMail::controlCentreAddress()
 *  entered by the user.
 *  Reply = the invalid item if error, else empty string.
 */
-QString KAMail::convertAddresses(const QString& items, EmailAddressList& list)
+TQString KAMail::convertAddresses(const TQString& items, EmailAddressList& list)
 {
 	list.clear();
-	QCString addrs = items.local8Bit();
+	TQCString addrs = items.local8Bit();
 	const char* ad = static_cast<const char*>(addrs);
 
 	// parse an address-list
-	QValueList<KMime::Types::Address> maybeAddressList;
+	TQValueList<KMime::Types::Address> maybeAddressList;
 	if (!HeaderParsing::parseAddressList(ad, ad + addrs.length(), maybeAddressList))
-		return QString::fromLocal8Bit(ad);    // return the address in error
+		return TQString::fromLocal8Bit(ad);    // return the address in error
 
 	// extract the mailboxes and complain if there are groups
-	for (QValueList<KMime::Types::Address>::ConstIterator it = maybeAddressList.begin();
+	for (TQValueList<KMime::Types::Address>::ConstIterator it = maybeAddressList.begin();
 	     it != maybeAddressList.end();  ++it)
 	{
-		QString bad = convertAddress(*it, list);
+		TQString bad = convertAddress(*it, list);
 		if (!bad.isEmpty())
 			return bad;
 	}
-	return QString::null;
+	return TQString::null;
 }
 
 #if 0
@@ -620,9 +620,9 @@ QString KAMail::convertAddresses(const QString& items, EmailAddressList& list)
 *  user, and append it to the specified list.
 *  Reply = the invalid item if error, else empty string.
 */
-QString KAMail::convertAddress(const QString& item, EmailAddressList& list)
+TQString KAMail::convertAddress(const TQString& item, EmailAddressList& list)
 {
-	QCString addr = item.local8Bit();
+	TQCString addr = item.local8Bit();
 	const char* ad = static_cast<const char*>(addr);
 	KMime::Types::Address maybeAddress;
 	if (!HeaderParsing::parseAddress(ad, ad + addr.length(), maybeAddress))
@@ -635,33 +635,33 @@ QString KAMail::convertAddress(const QString& item, EmailAddressList& list)
 *  Convert a single KMime::Types address to a KCal::Person instance and append
 *  it to the specified list.
 */
-QString KAMail::convertAddress(KMime::Types::Address addr, EmailAddressList& list)
+TQString KAMail::convertAddress(KMime::Types::Address addr, EmailAddressList& list)
 {
 	if (!addr.displayName.isEmpty())
 	{
 		kdDebug(5950) << "mailbox groups not allowed! Name: \"" << addr.displayName << "\"" << endl;
 		return addr.displayName;
 	}
-	const QValueList<KMime::Types::Mailbox>& mblist = addr.mailboxList;
-	for (QValueList<KMime::Types::Mailbox>::ConstIterator mb = mblist.begin();
+	const TQValueList<KMime::Types::Mailbox>& mblist = addr.mailboxList;
+	for (TQValueList<KMime::Types::Mailbox>::ConstIterator mb = mblist.begin();
 	     mb != mblist.end();  ++mb)
 	{
-		QString addrPart = (*mb).addrSpec.localPart;
+		TQString addrPart = (*mb).addrSpec.localPart;
 		if (!(*mb).addrSpec.domain.isEmpty())
 		{
-			addrPart += QChar('@');
+			addrPart += TQChar('@');
 			addrPart += (*mb).addrSpec.domain;
 		}
 		list += KCal::Person((*mb).displayName, addrPart);
 	}
-	return QString::null;
+	return TQString::null;
 }
 
 /*
-QString KAMail::convertAddresses(const QString& items, QStringList& list)
+TQString KAMail::convertAddresses(const TQString& items, TQStringList& list)
 {
 	EmailAddressList addrs;
-	QString item = convertAddresses(items, addrs);
+	TQString item = convertAddresses(items, addrs);
 	if (!item.isEmpty())
 		return item;
 	for (EmailAddressList::Iterator ad = addrs.begin();  ad != addrs.end();  ++ad)
@@ -678,7 +678,7 @@ QString KAMail::convertAddresses(const QString& items, QStringList& list)
 				return item;
 		}
 	}
-	return QString::null;
+	return TQString::null;
 }*/
 
 /******************************************************************************
@@ -687,7 +687,7 @@ QString KAMail::convertAddresses(const QString& items, QStringList& list)
 *  email address rules, only some basic checks are made.
 *  Reply = 1 if alright, 0 if empty, -1 if error.
 */
-int KAMail::checkAddress(QString& address)
+int KAMail::checkAddress(TQString& address)
 {
 	address = address.stripWhiteSpace();
 	// Check that there are no list separator characters present
@@ -733,10 +733,10 @@ int KAMail::checkAddress(QString& address)
 
 /******************************************************************************
 *  Convert a comma or semicolon delimited list of attachments into a
-*  QStringList. The items are checked for validity.
+*  TQStringList. The items are checked for validity.
 *  Reply = the invalid item if error, else empty string.
 */
-QString KAMail::convertAttachments(const QString& items, QStringList& list)
+TQString KAMail::convertAttachments(const TQString& items, TQStringList& list)
 {
 	KURL url;
 	list.clear();
@@ -752,7 +752,7 @@ QString KAMail::convertAttachments(const QString& items, QStringList& list)
 			sc = items.length();
 		if (sc < i)
 			i = sc;
-		QString item = items.mid(next, i - next).stripWhiteSpace();
+		TQString item = items.mid(next, i - next).stripWhiteSpace();
 		switch (checkAttachment(item))
 		{
 			case 1:   list += item;  break;
@@ -762,7 +762,7 @@ QString KAMail::convertAttachments(const QString& items, QStringList& list)
 		}
 		next = i + 1;
 	}
-	return QString::null;
+	return TQString::null;
 }
 
 #if 0
@@ -771,11 +771,11 @@ QString KAMail::convertAttachments(const QString& items, QStringList& list)
 *  KURL::List. The items are checked for validity.
 *  Reply = the invalid item if error, else empty string.
 */
-QString KAMail::convertAttachments(const QString& items, KURL::List& list)
+TQString KAMail::convertAttachments(const TQString& items, KURL::List& list)
 {
 	KURL url;
 	list.clear();
-	QCString addrs = items.local8Bit();
+	TQCString addrs = items.local8Bit();
 	int length = items.length();
 	for (int next = 0;  next < length;  )
 	{
@@ -788,7 +788,7 @@ QString KAMail::convertAttachments(const QString& items, KURL::List& list)
 			sc = items.length();
 		if (sc < i)
 			i = sc;
-		QString item = items.mid(next, i - next);
+		TQString item = items.mid(next, i - next);
 		switch (checkAttachment(item, &url))
 		{
 			case 1:   list += url;  break;
@@ -798,7 +798,7 @@ QString KAMail::convertAttachments(const QString& items, KURL::List& list)
 		}
 		next = i + 1;
 	}
-	return QString::null;
+	return TQString::null;
 }
 #endif
 
@@ -809,7 +809,7 @@ QString KAMail::convertAttachments(const QString& items, KURL::List& list)
 *        = 0 if null name
 *        = -1 if doesn't exist.
 */
-int KAMail::checkAttachment(QString& attachment, KURL* url)
+int KAMail::checkAttachment(TQString& attachment, KURL* url)
 {
 	attachment = attachment.stripWhiteSpace();
 	if (attachment.isEmpty())
@@ -847,7 +847,7 @@ bool KAMail::checkAttachment(const KURL& url)
 *            -1 if overflow.
 *  Reply = BASE64 buffer, which the caller must delete[] afterwards.
 */
-char* KAMail::base64Encode(const char* in, QIODevice::Offset size, QIODevice::Offset& outSize)
+char* KAMail::base64Encode(const char* in, TQIODevice::Offset size, TQIODevice::Offset& outSize)
 {
 	const int MAX_LINELEN = 72;
 	static unsigned char dtable[65] =
@@ -856,10 +856,10 @@ char* KAMail::base64Encode(const char* in, QIODevice::Offset size, QIODevice::Of
 		"0123456789+/";
 
 	char* out = new char [2*size + 5];
-	outSize = (QIODevice::Offset)-1;
-	QIODevice::Offset outIndex = 0;
+	outSize = (TQIODevice::Offset)-1;
+	TQIODevice::Offset outIndex = 0;
 	int lineLength = 0;
-	for (QIODevice::Offset inIndex = 0;  inIndex < size;  )
+	for (TQIODevice::Offset inIndex = 0;  inIndex < size;  )
 	{
 		unsigned char igroup[3];
 		int n;
@@ -919,13 +919,13 @@ char* KAMail::base64Encode(const char* in, QIODevice::Offset size, QIODevice::Of
 /******************************************************************************
 * Set the appropriate error messages for a given error string.
 */
-QStringList KAMail::errors(const QString& err, bool sendfail)
+TQStringList KAMail::errors(const TQString& err, bool sendfail)
 {
-	QString error1 = sendfail ? i18n("Failed to send email")
+	TQString error1 = sendfail ? i18n("Failed to send email")
 	                          : i18n("Error copying sent email to KMail %1 folder").arg(i18n_sent_mail());
 	if (err.isEmpty())
-		return QStringList(error1);
-	QStringList errs(QString::fromLatin1("%1:").arg(error1));
+		return TQStringList(error1);
+	TQStringList errs(TQString::fromLatin1("%1:").arg(error1));
 	errs += err;
 	return errs;
 }
@@ -933,20 +933,20 @@ QStringList KAMail::errors(const QString& err, bool sendfail)
 /******************************************************************************
 *  Get the body of an email, given its serial number.
 */
-QString KAMail::getMailBody(Q_UINT32 serialNumber)
+TQString KAMail::getMailBody(Q_UINT32 serialNumber)
 {
 	// Get the body of the email from KMail
-	QCString    replyType;
-	QByteArray  replyData;
-	QByteArray  data;
-	QDataStream arg(data, IO_WriteOnly);
+	TQCString    replyType;
+	TQByteArray  replyData;
+	TQByteArray  data;
+	TQDataStream arg(data, IO_WriteOnly);
 	arg << serialNumber;
 	arg << (int)0;
-	QString body;
+	TQString body;
 	if (kapp->dcopClient()->call("kmail", "KMailIface", "getDecodedBodyPart(Q_UINT32,int)", data, replyType, replyData)
-	&&  replyType == "QString")
+	&&  replyType == "TQString")
 	{
-		QDataStream reply_stream(replyData, IO_ReadOnly);
+		TQDataStream reply_stream(replyData, IO_ReadOnly);
 		reply_stream >> body;
 	}
 	else
@@ -959,12 +959,12 @@ namespace
 /******************************************************************************
 * Get the local system's host name.
 */
-QString getHostName()
+TQString getHostName()
 {
         char hname[256];
         if (gethostname(hname, sizeof(hname)))
-                return QString::null;
-        return QString::fromLocal8Bit(hname);
+                return TQString::null;
+        return TQString::fromLocal8Bit(hname);
 }
 }
 
@@ -987,10 +987,10 @@ using namespace KMime::HeaderParsing;
 *  Allow a local user name to be specified as an email address.
 */
 bool parseUserName( const char* & scursor, const char * const send,
-                    QString & result, bool isCRLF ) {
+                    TQString & result, bool isCRLF ) {
 
-  QString maybeLocalPart;
-  QString tmp;
+  TQString maybeLocalPart;
+  TQString tmp;
 
   if ( scursor != send ) {
     // first, eat any whitespace
@@ -1005,7 +1005,7 @@ bool parseUserName( const char* & scursor, const char * const send,
 
     default: // atom
       scursor--; // re-set scursor to point to ch again
-      tmp = QString::null;
+      tmp = TQString::null;
       if ( parseAtom( scursor, send, result, false /* no 8bit */ ) ) {
         if (getpwnam(result.local8Bit()))
           return true;
@@ -1033,7 +1033,7 @@ bool parseAddress( const char* & scursor, const char * const send,
   const char * oldscursor = scursor;
   if ( parseMailbox( scursor, send, maybeMailbox, isCRLF ) ) {
     // yes, it is:
-    result.displayName = QString::null;
+    result.displayName = TQString::null;
     result.mailboxList.append( maybeMailbox );
     return true;
   }
@@ -1041,13 +1041,13 @@ bool parseAddress( const char* & scursor, const char * const send,
 
   // KAlarm: Allow a local user name to be specified
   // no, it's not a single mailbox. Try if it's a local user name:
-  QString maybeUserName;
+  TQString maybeUserName;
   if ( parseUserName( scursor, send, maybeUserName, isCRLF ) ) {
     // yes, it is:
-    maybeMailbox.displayName = QString::null;
+    maybeMailbox.displayName = TQString::null;
     maybeMailbox.addrSpec.localPart = maybeUserName;
-    maybeMailbox.addrSpec.domain = QString::null;
-    result.displayName = QString::null;
+    maybeMailbox.addrSpec.domain = TQString::null;
+    result.displayName = TQString::null;
     result.mailboxList.append( maybeMailbox );
     return true;
   }
@@ -1071,7 +1071,7 @@ bool parseAddress( const char* & scursor, const char * const send,
 *  Allow either ',' or ';' to be used as an email address separator.
 */
 bool parseAddressList( const char* & scursor, const char * const send,
-		       QValueList<Address> & result, bool isCRLF ) {
+		       TQValueList<Address> & result, bool isCRLF ) {
   while ( scursor != send ) {
     eatCFWS( scursor, send, isCRLF );
     // end of header: this is OK.