Rename a number of old tq methods that are no longer tq specific

1 files changed, 133 insertions, 133 deletions

diff --git a/kmail/kmmsgbase.cpp b/kmail/kmmsgbase.cpp
index f1341d6c8..05a128411 100644
--- a/kmail/kmmsgbase.cpp
+++ b/kmail/kmmsgbase.cpp
@@ -22,7 +22,7 @@ using KMail::MessageProperty;
 #include <mimelib/mimepp.h>
 #include <kmime_codecs.h>
 
-#include <tqtextcodec.h>
+#include <textcodec.h>
 #include <tqdeepcopy.h>
 #include <tqregexp.h>
 
@@ -72,7 +72,7 @@ using KMail::MessageProperty;
 //-----------------------------------------------------------------------------
 KMMsgBase::KMMsgBase(KMFolder* aParentFolder)
   : mParent( aParentFolder ), mIndexOffset( 0 ),
-    mIndexLength( 0 ), mDirty( false ), mEnableUndo( false ), mtqStatus( KMMsgStatusUnknown )
+    mIndexLength( 0 ), mDirty( false ), mEnableUndo( false ), mStatus( KMMsgStatusUnknown )
 {
 }
 
@@ -121,145 +121,145 @@ bool KMMsgBase::isMessage(void) const
   return false;
 }
 //-----------------------------------------------------------------------------
-void KMMsgBase::toggletqStatus(const KMMsgtqStatus atqStatus, int idx)
+void KMMsgBase::toggleStatus(const KMMsgStatus aStatus, int idx)
 {
   mDirty = true;
-  KMMsgtqStatus oldtqStatus = status();
-  if ( status() & atqStatus ) {
-    mtqStatus &= ~atqStatus;
+  KMMsgStatus oldStatus = status();
+  if ( status() & aStatus ) {
+    mStatus &= ~aStatus;
   } else {
-    mtqStatus |= atqStatus;
+    mStatus |= aStatus;
     // Ignored and Watched are toggleable, yet mutually exclusive.
     // That is an arbitrary restriction on my part. HAR HAR HAR :) -till
-    if (atqStatus == KMMsgStatusWatched)
-      mtqStatus &= ~KMMsgStatusIgnored;
-    if (atqStatus == KMMsgStatusIgnored)
-      mtqStatus &= ~KMMsgStatusWatched;
-    if (atqStatus == KMMsgStatusSpam)
-      mtqStatus &= ~KMMsgStatusHam;
-    if (atqStatus == KMMsgStatusHam)
-      mtqStatus &= ~KMMsgStatusSpam;
+    if (aStatus == KMMsgStatusWatched)
+      mStatus &= ~KMMsgStatusIgnored;
+    if (aStatus == KMMsgStatusIgnored)
+      mStatus &= ~KMMsgStatusWatched;
+    if (aStatus == KMMsgStatusSpam)
+      mStatus &= ~KMMsgStatusHam;
+    if (aStatus == KMMsgStatusHam)
+      mStatus &= ~KMMsgStatusSpam;
   }
   if (storage()) {
      if (idx < 0)
        idx = storage()->find( this );
-     storage()->msgStatusChanged( oldtqStatus, status(), idx );
+     storage()->msgStatusChanged( oldStatus, status(), idx );
      storage()->headerOfMsgChanged(this, idx);
   }
 
 }
 
 //-----------------------------------------------------------------------------
-void KMMsgBase::setqStatus(const KMMsgtqStatus atqStatus, int idx)
+void KMMsgBase::seStatus(const KMMsgStatus aStatus, int idx)
 {
   mDirty = true;
-  KMMsgtqStatus oldtqStatus = status();
-  switch (atqStatus) {
+  KMMsgStatus oldStatus = status();
+  switch (aStatus) {
     case KMMsgStatusRead:
       // Unset unread and new, set read
-      mtqStatus &= ~KMMsgStatusUnread;
-      mtqStatus &= ~KMMsgStatusNew;
-      mtqStatus |= KMMsgStatusRead;
+      mStatus &= ~KMMsgStatusUnread;
+      mStatus &= ~KMMsgStatusNew;
+      mStatus |= KMMsgStatusRead;
       break;
 
     case KMMsgStatusUnread:
       // unread overrides read
-      mtqStatus &= ~KMMsgStatusOld;
-      mtqStatus &= ~KMMsgStatusRead;
-      mtqStatus &= ~KMMsgStatusNew;
-      mtqStatus |= KMMsgStatusUnread;
+      mStatus &= ~KMMsgStatusOld;
+      mStatus &= ~KMMsgStatusRead;
+      mStatus &= ~KMMsgStatusNew;
+      mStatus |= KMMsgStatusUnread;
       break;
 
     case KMMsgStatusOld:
       // old can't be new or unread
-      mtqStatus &= ~KMMsgStatusNew;
-      mtqStatus &= ~KMMsgStatusUnread;
-      mtqStatus |= KMMsgStatusOld;
+      mStatus &= ~KMMsgStatusNew;
+      mStatus &= ~KMMsgStatusUnread;
+      mStatus |= KMMsgStatusOld;
       break;
 
     case KMMsgStatusNew:
       // new overrides old and read
-      mtqStatus &= ~KMMsgStatusOld;
-      mtqStatus &= ~KMMsgStatusRead;
-      mtqStatus &= ~KMMsgStatusUnread;
-      mtqStatus |= KMMsgStatusNew;
+      mStatus &= ~KMMsgStatusOld;
+      mStatus &= ~KMMsgStatusRead;
+      mStatus &= ~KMMsgStatusUnread;
+      mStatus |= KMMsgStatusNew;
       break;
 
     case KMMsgStatusDeleted:
-      mtqStatus |= KMMsgStatusDeleted;
+      mStatus |= KMMsgStatusDeleted;
       break;
 
     case KMMsgStatusReplied:
-      mtqStatus |= KMMsgStatusReplied;
+      mStatus |= KMMsgStatusReplied;
       break;
 
     case KMMsgStatusForwarded:
-      mtqStatus |= KMMsgStatusForwarded;
+      mStatus |= KMMsgStatusForwarded;
       break;
 
     case KMMsgStatusQueued:
-      mtqStatus |= KMMsgStatusQueued;
+      mStatus |= KMMsgStatusQueued;
       break;
 
     case KMMsgStatusTodo:
-      mtqStatus |= KMMsgStatusTodo;
+      mStatus |= KMMsgStatusTodo;
       break;
 
     case KMMsgStatusSent:
-      mtqStatus &= ~KMMsgStatusQueued;
-      mtqStatus &= ~KMMsgStatusUnread;
-      mtqStatus &= ~KMMsgStatusNew;
-      mtqStatus |= KMMsgStatusSent;
+      mStatus &= ~KMMsgStatusQueued;
+      mStatus &= ~KMMsgStatusUnread;
+      mStatus &= ~KMMsgStatusNew;
+      mStatus |= KMMsgStatusSent;
       break;
 
     case KMMsgStatusFlag:
-      mtqStatus |= KMMsgStatusFlag;
+      mStatus |= KMMsgStatusFlag;
       break;
 
     // Watched and ignored are mutually exclusive
     case KMMsgStatusWatched:
-      mtqStatus &= ~KMMsgStatusIgnored;
-      mtqStatus |= KMMsgStatusWatched;
+      mStatus &= ~KMMsgStatusIgnored;
+      mStatus |= KMMsgStatusWatched;
       break;
 
     case KMMsgStatusIgnored:
-      mtqStatus &= ~KMMsgStatusWatched;
-      mtqStatus |= KMMsgStatusIgnored;
+      mStatus &= ~KMMsgStatusWatched;
+      mStatus |= KMMsgStatusIgnored;
       break;
     // as are ham and spam
     case KMMsgStatusSpam:
-      mtqStatus &= ~KMMsgStatusHam;
-      mtqStatus |= KMMsgStatusSpam;
+      mStatus &= ~KMMsgStatusHam;
+      mStatus |= KMMsgStatusSpam;
       break;
     case KMMsgStatusHam:
-      mtqStatus &= ~KMMsgStatusSpam;
-      mtqStatus |= KMMsgStatusHam;
+      mStatus &= ~KMMsgStatusSpam;
+      mStatus |= KMMsgStatusHam;
       break;
     case KMMsgStatusHasAttach:
-      mtqStatus &= ~KMMsgStatusHasNoAttach;
-      mtqStatus |= KMMsgStatusHasAttach;
+      mStatus &= ~KMMsgStatusHasNoAttach;
+      mStatus |= KMMsgStatusHasAttach;
       break;
     case KMMsgStatusHasNoAttach:
-      mtqStatus &= ~KMMsgStatusHasAttach;
-      mtqStatus |= KMMsgStatusHasNoAttach;
+      mStatus &= ~KMMsgStatusHasAttach;
+      mStatus |= KMMsgStatusHasNoAttach;
       break;
     case KMMsgStatusHasInvitation:
-      mtqStatus &= ~KMMsgStatusHasNoInvitation;
-      mtqStatus |= KMMsgStatusHasInvitation;
+      mStatus &= ~KMMsgStatusHasNoInvitation;
+      mStatus |= KMMsgStatusHasInvitation;
       break;
     case KMMsgStatusHasNoInvitation:
-      mtqStatus &= ~KMMsgStatusHasInvitation;
-      mtqStatus |= KMMsgStatusHasNoInvitation;
+      mStatus &= ~KMMsgStatusHasInvitation;
+      mStatus |= KMMsgStatusHasNoInvitation;
       break;
     default:
-      mtqStatus = atqStatus;
+      mStatus = aStatus;
       break;
   }
 
-  if ( oldtqStatus != mtqStatus && storage() ) {
+  if ( oldStatus != mStatus && storage() ) {
     if (idx < 0)
       idx = storage()->find( this );
-    storage()->msgStatusChanged( oldtqStatus, status(), idx );
+    storage()->msgStatusChanged( oldStatus, status(), idx );
     storage()->headerOfMsgChanged( this, idx );
   }
 }
@@ -267,40 +267,40 @@ void KMMsgBase::setqStatus(const KMMsgtqStatus atqStatus, int idx)
 
 
 //-----------------------------------------------------------------------------
-void KMMsgBase::setqStatus(const char* aStatusStr, const char* aXStatusStr)
+void KMMsgBase::seStatus(const char* aStatusStr, const char* aXStatusStr)
 {
   // first try to find status from "X-Status" field if given
   if (aXStatusStr) {
-    if (strchr(aXStatusStr, 'N')) setqStatus(KMMsgStatusNew);
-    if (strchr(aXStatusStr, 'U')) setqStatus(KMMsgStatusUnread);
-    if (strchr(aXStatusStr, 'O')) setqStatus(KMMsgStatusOld);
-    if (strchr(aXStatusStr, 'R')) setqStatus(KMMsgStatusRead);
-    if (strchr(aXStatusStr, 'D')) setqStatus(KMMsgStatusDeleted);
-    if (strchr(aXStatusStr, 'A')) setqStatus(KMMsgStatusReplied);
-    if (strchr(aXStatusStr, 'F')) setqStatus(KMMsgStatusForwarded);
-    if (strchr(aXStatusStr, 'Q')) setqStatus(KMMsgStatusQueued);
-    if (strchr(aXStatusStr, 'K')) setqStatus(KMMsgStatusTodo);
-    if (strchr(aXStatusStr, 'S')) setqStatus(KMMsgStatusSent);
-    if (strchr(aXStatusStr, 'G')) setqStatus(KMMsgStatusFlag);
-    if (strchr(aXStatusStr, 'P')) setqStatus(KMMsgStatusSpam);
-    if (strchr(aXStatusStr, 'H')) setqStatus(KMMsgStatusHam);
-    if (strchr(aXStatusStr, 'T')) setqStatus(KMMsgStatusHasAttach);
-    if (strchr(aXStatusStr, 'C')) setqStatus(KMMsgStatusHasNoAttach);
+    if (strchr(aXStatusStr, 'N')) seStatus(KMMsgStatusNew);
+    if (strchr(aXStatusStr, 'U')) seStatus(KMMsgStatusUnread);
+    if (strchr(aXStatusStr, 'O')) seStatus(KMMsgStatusOld);
+    if (strchr(aXStatusStr, 'R')) seStatus(KMMsgStatusRead);
+    if (strchr(aXStatusStr, 'D')) seStatus(KMMsgStatusDeleted);
+    if (strchr(aXStatusStr, 'A')) seStatus(KMMsgStatusReplied);
+    if (strchr(aXStatusStr, 'F')) seStatus(KMMsgStatusForwarded);
+    if (strchr(aXStatusStr, 'Q')) seStatus(KMMsgStatusQueued);
+    if (strchr(aXStatusStr, 'K')) seStatus(KMMsgStatusTodo);
+    if (strchr(aXStatusStr, 'S')) seStatus(KMMsgStatusSent);
+    if (strchr(aXStatusStr, 'G')) seStatus(KMMsgStatusFlag);
+    if (strchr(aXStatusStr, 'P')) seStatus(KMMsgStatusSpam);
+    if (strchr(aXStatusStr, 'H')) seStatus(KMMsgStatusHam);
+    if (strchr(aXStatusStr, 'T')) seStatus(KMMsgStatusHasAttach);
+    if (strchr(aXStatusStr, 'C')) seStatus(KMMsgStatusHasNoAttach);
   }
 
   // Merge the contents of the "Status" field
   if (aStatusStr) {
     if ((aStatusStr[0]== 'R' && aStatusStr[1]== 'O') ||
         (aStatusStr[0]== 'O' && aStatusStr[1]== 'R')) {
-      setqStatus( KMMsgStatusOld );
-      setqStatus( KMMsgStatusRead );
+      seStatus( KMMsgStatusOld );
+      seStatus( KMMsgStatusRead );
     }
     else if (aStatusStr[0] == 'R')
-      setqStatus(KMMsgStatusRead);
+      seStatus(KMMsgStatusRead);
     else if (aStatusStr[0] == 'D')
-      setqStatus(KMMsgStatusDeleted);
+      seStatus(KMMsgStatusDeleted);
     else
-      setqStatus(KMMsgStatusNew);
+      seStatus(KMMsgStatusNew);
   }
 }
 
@@ -363,117 +363,117 @@ void KMMsgBase::setSignatureStateChar( TQChar status, int idx )
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isUnread(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusUnread && !(st & KMMsgStatusIgnored));
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isNew(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusNew && !(st & KMMsgStatusIgnored));
 }
 
 //-----------------------------------------------------------------------------
-bool KMMsgBase::isOfUnknowntqStatus(void) const
+bool KMMsgBase::isOfUnknownStatus(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st == KMMsgStatusUnknown);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isOld(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusOld);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isRead(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusRead || st & KMMsgStatusIgnored);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isDeleted(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusDeleted);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isReplied(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusReplied);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isForwarded(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusForwarded);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isQueued(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusQueued);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isTodo(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusTodo);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isSent(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusSent);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isImportant(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusFlag);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isWatched(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusWatched);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isIgnored(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusIgnored);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isSpam(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusSpam);
 }
 
 //-----------------------------------------------------------------------------
 bool KMMsgBase::isHam(void) const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   return (st & KMMsgStatusHam);
 }
 
 //-----------------------------------------------------------------------------
-TQCString KMMsgBase::statusToStr(const KMMsgtqStatus status)
+TQCString KMMsgBase::statusToStr(const KMMsgStatus status)
 {
   TQCString sstr;
   if (status & KMMsgStatusNew) sstr += 'N';
@@ -587,8 +587,8 @@ TQCString KMMsgBase::toUsAscii(const TQString& _str, bool *ok)
   TQString result = _str;
   int len = result.length();
   for (int i = 0; i < len; i++)
-    if (result.tqat(i).tqunicode() >= 128) {
-      result.tqat(i) = '?';
+    if (result.at(i).unicode() >= 128) {
+      result.at(i) = '?';
       all_ok = false;
     }
   if (ok)
@@ -800,7 +800,7 @@ TQCString KMMsgBase::encodeRFC2047String(const TQString& _str,
   unsigned int nonAscii = 0;
   unsigned int strLength(_str.length());
   for (unsigned int i = 0; i < strLength; i++)
-    if (_str.tqat(i).tqunicode() >= 128) nonAscii++;
+    if (_str.at(i).unicode() >= 128) nonAscii++;
   bool useBase64 = (nonAscii * 6 > strLength);
 
   unsigned int start, stop, p, pos = 0, encLength;
@@ -813,17 +813,17 @@ TQCString KMMsgBase::encodeRFC2047String(const TQString& _str,
     start = pos; p = pos;
     while (p < strLength)
     {
-      if (!breakLine && (_str.tqat(p) == ' ' || dontQuote.find(_str.tqat(p)) != -1))
+      if (!breakLine && (_str.at(p) == ' ' || dontQuote.find(_str.at(p)) != -1))
         start = p + 1;
-      if (_str.tqat(p).tqunicode() >= 128 || _str.tqat(p).tqunicode() < 32)
+      if (_str.at(p).unicode() >= 128 || _str.at(p).unicode() < 32)
         break;
       p++;
     }
     if (breakLine || p < strLength)
     {
-      while (dontQuote.find(_str.tqat(start)) != -1) start++;
+      while (dontQuote.find(_str.at(start)) != -1) start++;
       stop = start;
-      while (stop < strLength && dontQuote.find(_str.tqat(stop)) == -1)
+      while (stop < strLength && dontQuote.find(_str.at(stop)) == -1)
         stop++;
       result += _str.mid(pos, start - pos).latin1();
       encLength = encodeRFC2047Quoted(codec->fromUnicode(_str.
@@ -843,7 +843,7 @@ TQCString KMMsgBase::encodeRFC2047String(const TQString& _str,
         stop = start + dif;
       }
       p = stop;
-      while (p > start && _str.tqat(p) != ' ') p--;
+      while (p > start && _str.at(p) != ' ') p--;
       if (p > start) stop = p;
       if (result.right(3) == "?= ") start--;
       if (result.right(5) == "?=\n  ") {
@@ -956,13 +956,13 @@ TQString KMMsgBase::decodeRFC2231String(const TQCString& _str)
   p = 0;
   while (p < (int)st.length())
   {
-    if (st.tqat(p) == 37)
+    if (st.at(p) == 37)
     {
-      ch = st.tqat(p+1) - 48;
+      ch = st.at(p+1) - 48;
       if (ch > 16) ch -= 7;
-      ch2 = st.tqat(p+2) - 48;
+      ch2 = st.at(p+2) - 48;
       if (ch2 > 16) ch2 -= 7;
-      st.tqat(p) = ch * 16 + ch2;
+      st.at(p) = ch * 16 + ch2;
       st.remove( p+1, 2 );
     }
     p++;
@@ -1037,7 +1037,7 @@ TQCString KMMsgBase::autoDetectCharset(const TQCString &_encoding, const TQStrin
     TQStringList charsets = encodingList;
     if (!_encoding.isEmpty())
     {
-       TQString currentCharset = TQString::tqfromLatin1(_encoding);
+       TQString currentCharset = TQString::fromLatin1(_encoding);
        charsets.remove(currentCharset);
        charsets.prepend(currentCharset);
     }
@@ -1093,7 +1093,7 @@ unsigned long KMMsgBase::getMsgSerNum() const
 //-----------------------------------------------------------------------------
 KMMsgAttachmentState KMMsgBase::attachmentState() const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   if (st & KMMsgStatusHasAttach)
     return KMMsgHasAttachment;
   else if (st & KMMsgStatusHasNoAttach)
@@ -1105,7 +1105,7 @@ KMMsgAttachmentState KMMsgBase::attachmentState() const
 
 KMMsgInvitationState KMMsgBase::invitationState() const
 {
-  KMMsgtqStatus st = status();
+  KMMsgStatus st = status();
   if (st & KMMsgStatusHasInvitation)
     return KMMsgHasInvitation;
   else if (st & KMMsgStatusHasNoInvitation)
@@ -1119,9 +1119,9 @@ static void swapEndian(TQString &str)
 {
   uint len = str.length();
   str = TQDeepCopy<TQString>(str);
-  TQChar *tqunicode = const_cast<TQChar*>( str.tqunicode() );
+  TQChar *unicode = const_cast<TQChar*>( str.unicode() );
   for (uint i = 0; i < len; i++)
-    tqunicode[i] = kmail_swap_16(tqunicode[i].tqunicode());
+    unicode[i] = kmail_swap_16(unicode[i].unicode());
 }
 
 //-----------------------------------------------------------------------------
@@ -1193,7 +1193,7 @@ retry:
     }
     if(type == t) {
         // This works because the TQString constructor does a memcpy.
-        // Otherwise we would need to be concerned about the tqalignment.
+        // Otherwise we would need to be concerned about the alignment.
 	if(l)
 	    ret = TQString((TQChar *)(g_chunk + g_chunk_offset), l/2);
 	break;
@@ -1371,23 +1371,23 @@ const uchar *KMMsgBase::asIndexString(int &length) const
 
   //these is at the beginning because it is queried quite often
   tmp_str = msgIdMD5().stripWhiteSpace();
-  STORE_DATA_LEN(MsgIdMD5Part, tmp_str.tqunicode(), tmp_str.length() * 2, true);
-  tmp = mLegacytqStatus;
+  STORE_DATA_LEN(MsgIdMD5Part, tmp_str.unicode(), tmp_str.length() * 2, true);
+  tmp = mLegacyStatus;
   STORE_DATA(MsgLegacyStatusPart, tmp);
 
   //these are completely arbitrary order
   tmp_str = fromStrip().stripWhiteSpace();
-  STORE_DATA_LEN(MsgFromStripPart, tmp_str.tqunicode(), tmp_str.length() * 2, true);
+  STORE_DATA_LEN(MsgFromStripPart, tmp_str.unicode(), tmp_str.length() * 2, true);
   tmp_str = subject().stripWhiteSpace();
-  STORE_DATA_LEN(MsgSubjectPart, tmp_str.tqunicode(), tmp_str.length() * 2, true);
+  STORE_DATA_LEN(MsgSubjectPart, tmp_str.unicode(), tmp_str.length() * 2, true);
   tmp_str = toStrip().stripWhiteSpace();
-  STORE_DATA_LEN(MsgToStripPart, tmp_str.tqunicode(), tmp_str.length() * 2, true);
+  STORE_DATA_LEN(MsgToStripPart, tmp_str.unicode(), tmp_str.length() * 2, true);
   tmp_str = replyToIdMD5().stripWhiteSpace();
-  STORE_DATA_LEN(MsgReplyToIdMD5Part, tmp_str.tqunicode(), tmp_str.length() * 2, true);
+  STORE_DATA_LEN(MsgReplyToIdMD5Part, tmp_str.unicode(), tmp_str.length() * 2, true);
   tmp_str = xmark().stripWhiteSpace();
-  STORE_DATA_LEN(MsgXMarkPart, tmp_str.tqunicode(), tmp_str.length() * 2, true);
+  STORE_DATA_LEN(MsgXMarkPart, tmp_str.unicode(), tmp_str.length() * 2, true);
   tmp_str = fileName().stripWhiteSpace();
-  STORE_DATA_LEN(MsgFilePart, tmp_str.tqunicode(), tmp_str.length() * 2, true);
+  STORE_DATA_LEN(MsgFilePart, tmp_str.unicode(), tmp_str.length() * 2, true);
   tmp = msgSize();
   STORE_DATA(MsgSizePart, tmp);
   tmp = folderOffset();
@@ -1400,10 +1400,10 @@ const uchar *KMMsgBase::asIndexString(int &length) const
   STORE_DATA(MsgMDNSentPart, tmp);
 
   tmp_str = replyToAuxIdMD5().stripWhiteSpace();
-  STORE_DATA_LEN(MsgReplyToAuxIdMD5Part, tmp_str.tqunicode(), tmp_str.length() * 2, true);
+  STORE_DATA_LEN(MsgReplyToAuxIdMD5Part, tmp_str.unicode(), tmp_str.length() * 2, true);
 
   tmp_str = strippedSubjectMD5().stripWhiteSpace();
-  STORE_DATA_LEN(MsgStrippedSubjectMD5Part, tmp_str.tqunicode(), tmp_str.length() * 2, true);
+  STORE_DATA_LEN(MsgStrippedSubjectMD5Part, tmp_str.unicode(), tmp_str.length() * 2, true);
 
   tmp = status();
   STORE_DATA(MsgStatusPart, tmp);
@@ -1414,10 +1414,10 @@ const uchar *KMMsgBase::asIndexString(int &length) const
   STORE_DATA(MsgUIDPart, tmp);
 
   tmp_str = from();
-  STORE_DATA_LEN( MsgFromPart, tmp_str.tqunicode(), tmp_str.length() * 2, true );
+  STORE_DATA_LEN( MsgFromPart, tmp_str.unicode(), tmp_str.length() * 2, true );
 
   tmp_str = to();
-  STORE_DATA_LEN( MsgToPart, tmp_str.tqunicode(), tmp_str.length() * 2, true );
+  STORE_DATA_LEN( MsgToPart, tmp_str.unicode(), tmp_str.length() * 2, true );
 
   return ret;
 }
@@ -1476,8 +1476,8 @@ TQString KMMsgBase::replacePrefixes( const TQString& str,
   // construct a big regexp that
   // 1. is anchored to the beginning of str (sans whitespace)
   // 2. matches at least one of the part regexps in prefixRegExps
-  TQString bigRegExp = TQString::tqfromLatin1("^(?:\\s+|(?:%1))+\\s*")
-                      .tqarg( prefixRegExps.join(")|(?:") );
+  TQString bigRegExp = TQString::fromLatin1("^(?:\\s+|(?:%1))+\\s*")
+                      .arg( prefixRegExps.join(")|(?:") );
   TQRegExp rx( bigRegExp, false /*case insens.*/ );
   if ( !rx.isValid() ) {
     kdWarning(5006) << "KMMessage::replacePrefixes(): bigRegExp = \""