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

10 files changed, 508 insertions, 506 deletions

diff --git a/filters/olefilters/powerpoint97/powerpoint.cc b/filters/olefilters/powerpoint97/powerpoint.cc
index f01c71c7..b240a690 100644
--- a/filters/olefilters/powerpoint97/powerpoint.cc
+++ b/filters/olefilters/powerpoint97/powerpoint.cc
@@ -40,15 +40,15 @@ Powerpoint::~Powerpoint()
 
 void Powerpoint::invokeHandler(
     Header &op,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
-    typedef void (Powerpoint::*method)(Header &op, Q_UINT32 bytes, QDataStream &operands);
+    typedef void (Powerpoint::*method)(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
 
     typedef struct
     {
         const char *name;
-        Q_UINT16 opcode;
+        TQ_UINT16 opcode;
         method handler;
     } opcodeEntry;
 
@@ -104,9 +104,9 @@ void Powerpoint::invokeHandler(
         { "EXPLAINATOM",                4039,   0 /* &Powerpoint::opExPlainAtom */ },
         { "EXPLAINLINK",                4054,   0 /* &Powerpoint::opExPlainLink */ },
         { "EXPLAINLINKATOM",            4036,   0 /* &Powerpoint::opExPlainLinkAtom */ },
-        { "EXQUICKTIME",                4073,   0 /* &Powerpoint::opExQuickTime */ },
-        { "EXQUICKTIMEMOVIE",           4074,   0 /* &Powerpoint::opExQuickTimeMovie */ },
-        { "EXQUICKTIMEMOVIEDATA",       4075,   0 /* &Powerpoint::opExQuickTimeMovieData */ },
+        { "EXTQUICKTIME",                4073,   0 /* &Powerpoint::opExQuickTime */ },
+        { "EXTQUICKTIMEMOVIE",           4074,   0 /* &Powerpoint::opExQuickTimeMovie */ },
+        { "EXTQUICKTIMEMOVIEDATA",       4075,   0 /* &Powerpoint::opExQuickTimeMovieData */ },
         { "EXSUBSCRIPTION",             4076,   0 /* &Powerpoint::opExSubscription */ },
         { "EXSUBSCRIPTIONSECTION",      4077,   0 /* &Powerpoint::opExSubscriptionSection */ },
         { "EXTERNALOBJECT",             4027,   0 /* &Powerpoint::opExternalObject */ },
@@ -265,19 +265,19 @@ void Powerpoint::invokeHandler(
 
         if (bytes)
         {
-            QByteArray *record = new QByteArray(bytes);
-            QDataStream *body;
+            TQByteArray *record = new TQByteArray(bytes);
+            TQDataStream *body;
 
             operands.readRawBytes(record->data(), bytes);
-            body = new QDataStream(*record, IO_ReadOnly);
-            body->setByteOrder(QDataStream::LittleEndian);
+            body = new TQDataStream(*record, IO_ReadOnly);
+            body->setByteOrder(TQDataStream::LittleEndian);
             (this->*result)(op, bytes, *body);
             delete body;
             delete record;
         }
         else
         {
-            QDataStream *body = new QDataStream();
+            TQDataStream *body = new TQDataStream();
 
             (this->*result)(op, bytes, *body);
             delete body;
@@ -331,19 +331,19 @@ bool Powerpoint::parse(
 
 void Powerpoint::opColorSchemeAtom(
     Header & /* op */,
-    Q_UINT32,
-    QDataStream &operands)
+    TQ_UINT32,
+    TQDataStream &operands)
 {
     struct
     {
-        Q_UINT32 background;
-        Q_UINT32 textAndLines;
-        Q_UINT32 shadows;
-        Q_UINT32 titleText;
-        Q_UINT32 fills;
-        Q_UINT32 accent;
-        Q_UINT32 accentAndHyperlink;
-        Q_UINT32 accentAndFollowedHyperlink;
+        TQ_UINT32 background;
+        TQ_UINT32 textAndLines;
+        TQ_UINT32 shadows;
+        TQ_UINT32 titleText;
+        TQ_UINT32 fills;
+        TQ_UINT32 accent;
+        TQ_UINT32 accentAndHyperlink;
+        TQ_UINT32 accentAndFollowedHyperlink;
     } data;
 
     operands >> data.background >> data.textAndLines >> data.shadows >>
@@ -356,15 +356,15 @@ void Powerpoint::opColorSchemeAtom(
 //
 void Powerpoint::opCString(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
-    QString value;
+    TQString value;
     unsigned i;
 
     for (i = 0; i < bytes / 2; i++)
     {
-        Q_UINT16 tmp;
+        TQ_UINT16 tmp;
 
         operands >> tmp;
         value += tmp;
@@ -374,11 +374,11 @@ void Powerpoint::opCString(
 
 void Powerpoint::opCurrentUserAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &operands)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &operands)
 {
 
-    const Q_UINT32 MAGIC_NUMBER = (Q_UINT32)(-476987297);
+    const TQ_UINT32 MAGIC_NUMBER = (TQ_UINT32)(-476987297);
     //unsigned i;
 
     operands >> mCurrentUserAtom.size >> mCurrentUserAtom.magic >> mCurrentUserAtom.offsetToCurrentEdit >>
@@ -429,31 +429,31 @@ void Powerpoint::opCurrentUserAtom(
 
 void Powerpoint::opDocument(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opDocumentAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opEndDocument(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opEnvironment(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
@@ -464,8 +464,8 @@ void Powerpoint::opEnvironment(
 //
 void Powerpoint::opExEmbed(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
@@ -475,15 +475,15 @@ void Powerpoint::opExEmbed(
 //
 void Powerpoint::opExEmbedAtom(
     Header & /* op */,
-    Q_UINT32,
-    QDataStream &operands)
+    TQ_UINT32,
+    TQDataStream &operands)
 {
     struct
     {
-        Q_INT32 followColorScheme;
-        Q_UINT8 cantLockServerB;
-        Q_UINT8 noSizeToServerB;
-        Q_UINT8 isTable;
+        TQ_INT32 followColorScheme;
+        TQ_UINT8 cantLockServerB;
+        TQ_UINT8 noSizeToServerB;
+        TQ_UINT8 isTable;
     } data;
 
     operands >> data.followColorScheme;
@@ -494,54 +494,54 @@ void Powerpoint::opExEmbedAtom(
 
 void Powerpoint::opFontCollection(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opFontEntityAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opHeadersFooters(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opHeadersFootersAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opList(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opMainMaster(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opMsod(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     char *data;
 
@@ -561,21 +561,21 @@ kdError() <<"       drgid: "<< m_pptSlide->getPsrReference() << endl;
 
 void Powerpoint::opNotes(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opNotesAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &operands)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &operands)
 {
     struct
     {
-        Q_INT32 slideId;    // Id for the corresponding slide.
-        Q_UINT16 flags;
+        TQ_INT32 slideId;    // Id for the corresponding slide.
+        TQ_UINT16 flags;
     } data;
 
     operands >> data.slideId >> data.flags;
@@ -586,8 +586,8 @@ void Powerpoint::opNotesAtom(
 //
 void Powerpoint::opExObjList(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
@@ -597,10 +597,10 @@ void Powerpoint::opExObjList(
 //
 void Powerpoint::opExObjListAtom(
     Header & /* op */,
-    Q_UINT32,
-    QDataStream &operands)
+    TQ_UINT32,
+    TQDataStream &operands)
 {
-    Q_UINT32 objectSeedId;
+    TQ_UINT32 objectSeedId;
 
     operands >> objectSeedId;
     kdDebug(s_area) << "next OLE obj id: " << objectSeedId << endl;
@@ -608,30 +608,30 @@ void Powerpoint::opExObjListAtom(
 
 void Powerpoint::opExObjRefAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opExOleObj(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opExOleObjAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &operands)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &operands)
 {
     struct
     {
-        Q_UINT32 drawAspect;
-        Q_INT32 type;
-        Q_INT32 objID;
-        Q_INT32 subType;
-        Q_INT8 isBlank;
+        TQ_UINT32 drawAspect;
+        TQ_INT32 type;
+        TQ_INT32 objID;
+        TQ_INT32 subType;
+        TQ_INT8 isBlank;
     } data;
 
     operands >> data.drawAspect;
@@ -645,26 +645,26 @@ void Powerpoint::opExOleObjAtom(
 
 void Powerpoint::opExOleObjStg(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opOutlineViewInfo(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opPersistPtrIncrementalBlock2(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
     //PSR_UserEditAtom userEdit;
-    //Q_INT16 offsetToEdit = mCurrentUserAtom.offsetToCurrentEdit;
+    //TQ_INT16 offsetToEdit = mCurrentUserAtom.offsetToCurrentEdit;
 
     /* huh?
     while(0 < offsetToEdit)
@@ -678,23 +678,23 @@ void Powerpoint::opPersistPtrIncrementalBlock2(
 
 void Powerpoint::opPersistPtrIncrementalBlock(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     struct
     {
         union
         {
-            Q_UINT32 info;
+            TQ_UINT32 info;
             struct
             {
-                Q_UINT32 offsetNumber: 20;
-                Q_UINT32 offsetCount: 12;
+                TQ_UINT32 offsetNumber: 20;
+                TQ_UINT32 offsetCount: 12;
             } fields;
         } header;
-        Q_UINT32 offset;
+        TQ_UINT32 offset;
     } data;
-    Q_UINT32 length = 0;
+    TQ_UINT32 length = 0;
 
     while (length < bytes)
     {
@@ -724,7 +724,7 @@ void Powerpoint::opPersistPtrIncrementalBlock(
 
                 // Create a record of this persistent reference.
 
-                if (m_persistentReferences.end() == m_persistentReferences.find(reference))
+                if (m_persistentReferences.end() == m_persistentReferences.tqfind(reference))
                 {
 		    if(reference < 5)
 		    {
@@ -753,44 +753,44 @@ void Powerpoint::opPersistPtrIncrementalBlock(
 
 void Powerpoint::opPPDrawing(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opPPDrawingGroup(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opSlide(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opSlideAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &operands)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &operands)
 {
     struct
     {
-        Q_UINT8 layout[12];  // Slide layout descriptor.
-        Q_INT32 masterId;   // Id of the master of the slide. Zero for a master slide.
-        Q_INT32 notesId;    // Id for the corresponding notes slide. Zero if slide has no notes.
-        Q_UINT16 flags;
+        TQ_UINT8 tqlayout[12];  // Slide tqlayout descriptor.
+        TQ_INT32 masterId;   // Id of the master of the slide. Zero for a master slide.
+        TQ_INT32 notesId;    // Id for the corresponding notes slide. Zero if slide has no notes.
+        TQ_UINT16 flags;
     } data;
 
     Header tmp;
     tmp.type = 1015;
-    tmp.length = sizeof(data.layout);
+    tmp.length = sizeof(data.tqlayout);
     invokeHandler(tmp, tmp.length, operands);
     operands >> data.masterId >> data.notesId >> data.flags;
 
@@ -805,24 +805,24 @@ void Powerpoint::opSlideAtom(
 
 void Powerpoint::opSlideListWithText(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opSlidePersistAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &operands)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &operands)
 {
     struct
     {
-        Q_UINT32 psrReference;   // Logical reference to the slide persist object.
-        Q_UINT32 flags;          // If bit 3 set then slide contains shapes other than placeholders.
-        Q_INT32 numberTexts;    // Number of placeholder texts stored with the persist object.
-        Q_INT32 slideId;        // Unique slide identifier, used for OLE link monikers for example.
-        Q_UINT32 reserved;
+        TQ_UINT32 psrReference;   // Logical reference to the slide persist object.
+        TQ_UINT32 flags;          // If bit 3 set then slide contains tqshapes other than placeholders.
+        TQ_INT32 numberTexts;    // Number of placeholder texts stored with the persist object.
+        TQ_INT32 slideId;        // Unique slide identifier, used for OLE link monikers for example.
+        TQ_UINT32 reserved;
     } data;
 
     operands >> data.psrReference >> data.flags >> data.numberTexts >>
@@ -855,31 +855,31 @@ void Powerpoint::opSlidePersistAtom(
 
 void Powerpoint::opSlideViewInfo(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opSrKinsoku(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
 void Powerpoint::opSSDocInfoAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opSSSlideLayoutAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &operands)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &operands)
 {
 
     PSR_SSlideLayoutAtom data;
@@ -906,18 +906,18 @@ void Powerpoint::opSSSlideLayoutAtom(
 //this is where we set bold/italic/etc and paragraph styles
 void Powerpoint::opStyleTextPropAtom(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
 
-	Q_UINT16 totalLength = 0;
-	Q_UINT16 length = 0;
-	Q_UINT32 style1 = 0;
-	Q_UINT32 style2 = 0;
-	Q_UINT16 style3 = 0;
-	Q_UINT32 BOLD 		= 0x00010000;
-	Q_UINT32 ITALIC		= 0x00020000;
-	Q_UINT32 UNDERLINE 	= 0x00040000;
+	TQ_UINT16 totalLength = 0;
+	TQ_UINT16 length = 0;
+	TQ_UINT32 style1 = 0;
+	TQ_UINT32 style2 = 0;
+	TQ_UINT16 style3 = 0;
+	TQ_UINT32 BOLD 		= 0x00010000;
+	TQ_UINT32 ITALIC		= 0x00020000;
+	TQ_UINT32 UNDERLINE 	= 0x00040000;
 
 	//--get the paragraph style?
 	operands >> length >> style1 >> style2;
@@ -967,15 +967,15 @@ void Powerpoint::opStyleTextPropAtom(
 
 void Powerpoint::opTextBytesAtom(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
-    QString data;
+    TQString data;
     unsigned i;
 
     for (i = 0; i < bytes; i++)
     {
-        Q_UINT8 tmp;
+        TQ_UINT8 tmp;
 
         operands >> tmp;
         data += tmp;
@@ -1007,15 +1007,15 @@ void Powerpoint::opTextBytesAtom(
 
 void Powerpoint::opTextCharsAtom(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
-    QString data;
+    TQString data;
     unsigned i;
 
     for (i = 0; i < bytes / 2; i++)
     {
-        Q_UINT16 tmp;
+        TQ_UINT16 tmp;
 
         operands >> tmp;
         data += tmp;
@@ -1045,18 +1045,18 @@ void Powerpoint::opTextCharsAtom(
 
 void Powerpoint::opTextHeaderAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &operands)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &operands)
 {
     struct
     {
-        Q_UINT32 txType;    // Type of text:
+        TQ_UINT32 txType;    // Type of text:
                             //
                             // 0 Title
                             // 1 Body
                             // 2 Notes
                             // 3 Not Used
-                            // 4 Other (Text in a shape)
+                            // 4 Other (Text in a tqshape)
                             // 5 Center body (subtitle in title slide)
                             // 6 Center title (title in title slide)
                             // 7 Half body (body in two-column slide)
@@ -1080,22 +1080,22 @@ void Powerpoint::opTextHeaderAtom(
 
 void Powerpoint::opTextSpecInfoAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opTxMasterStyleAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
 void Powerpoint::opTxSIStyleAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &/*operands*/)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &/*operands*/)
 {
 }
 
@@ -1105,8 +1105,8 @@ void Powerpoint::opTxSIStyleAtom(
 //
 void Powerpoint::opUserEditAtom(
     Header & /* op */,
-    Q_UINT32 /*bytes*/,
-    QDataStream &operands)
+    TQ_UINT32 /*bytes*/,
+    TQDataStream &operands)
 {
 
     operands >> mUserEditAtom.lastSlideID  >> mUserEditAtom.version >> mUserEditAtom.offsetLastEdit >>
@@ -1154,13 +1154,13 @@ void Powerpoint::opUserEditAtom(
 
 void Powerpoint::opVBAInfo(
     Header & /* op */,
-    Q_UINT32 bytes,
-    QDataStream &operands)
+    TQ_UINT32 bytes,
+    TQDataStream &operands)
 {
     walk(bytes, operands);
 }
 
-void Powerpoint::skip(Q_UINT32 bytes, QDataStream &operands)
+void Powerpoint::skip(TQ_UINT32 bytes, TQDataStream &operands)
 {
     if ((int)bytes < 0)
     {
@@ -1169,8 +1169,8 @@ void Powerpoint::skip(Q_UINT32 bytes, QDataStream &operands)
     }
     if (bytes)
     {
-        Q_UINT32 i;
-        Q_UINT8 discard;
+        TQ_UINT32 i;
+        TQ_UINT8 discard;
 
         kdDebug(s_area) << "skip: " << bytes << endl;
         for (i = 0; i < bytes; i++)
@@ -1183,10 +1183,10 @@ void Powerpoint::skip(Q_UINT32 bytes, QDataStream &operands)
 //
 // Handle a container record.
 //
-void Powerpoint::walk(Q_UINT32 bytes, QDataStream &operands)
+void Powerpoint::walk(TQ_UINT32 bytes, TQDataStream &operands)
 {
     Header op;
-    Q_UINT32 length = 0;
+    TQ_UINT32 length = 0;
 
     // Stop parsing when there are no more records. Note that we stop as soon
     // as we cannot get a complete header.
@@ -1210,29 +1210,29 @@ void Powerpoint::walk(Q_UINT32 bytes, QDataStream &operands)
     skip(bytes - length, operands);
 }
 
-void Powerpoint::walk(Q_UINT32 mainStreamOffset)
+void Powerpoint::walk(TQ_UINT32 mainStreamOffset)
 {
-    Q_UINT32 length = m_mainStream.length - mainStreamOffset;
-    QByteArray a;
+    TQ_UINT32 length = m_mainStream.length - mainStreamOffset;
+    TQByteArray a;
 
     a.setRawData((const char *)m_mainStream.data + mainStreamOffset, length);
-    QDataStream stream(a, IO_ReadOnly);
-    stream.setByteOrder(QDataStream::LittleEndian);
+    TQDataStream stream(a, IO_ReadOnly);
+    stream.setByteOrder(TQDataStream::LittleEndian);
     walk(length, stream);
     a.resetRawData((const char *)m_mainStream.data + mainStreamOffset, length);
 }
 void Powerpoint::walkDocument()
 {
-    QByteArray a;
-    Q_UINT32 mainStreamOffset = 0;
-    Q_UINT32 bytes = m_mainStream.length - mainStreamOffset;
+    TQByteArray a;
+    TQ_UINT32 mainStreamOffset = 0;
+    TQ_UINT32 bytes = m_mainStream.length - mainStreamOffset;
 
     a.setRawData((const char *)m_mainStream.data + mainStreamOffset, bytes);
-    QDataStream stream(a, IO_ReadOnly);
-    stream.setByteOrder(QDataStream::LittleEndian);
+    TQDataStream stream(a, IO_ReadOnly);
+    stream.setByteOrder(TQDataStream::LittleEndian);
     //--get tho the slide list
     Header op;
-    Q_UINT32 length = 0;
+    TQ_UINT32 length = 0;
 
     // Stop parsing when there are no more records. Note that we stop as soon
     // as we cannot get a complete header.
@@ -1254,19 +1254,19 @@ void Powerpoint::walkDocument()
 
 }
 
-void Powerpoint::walkRecord(Q_UINT32 bytes, const unsigned char *operands)
+void Powerpoint::walkRecord(TQ_UINT32 bytes, const unsigned char *operands)
 {
     // First read what should be the next header using one stream.
 
     kdError(s_area) << "WalkRecord - bytes: " << bytes << endl;
 
-    Q_UINT32 length = sizeof(Header);
-    QByteArray a;
+    TQ_UINT32 length = sizeof(Header);
+    TQByteArray a;
     Header op;
 
     a.setRawData((const char *)operands, bytes);
-    QDataStream stream1(a, IO_ReadOnly);
-    stream1.setByteOrder(QDataStream::LittleEndian);
+    TQDataStream stream1(a, IO_ReadOnly);
+    stream1.setByteOrder(TQDataStream::LittleEndian);
     stream1 >> op.opcode.info >> op.type >> op.length;
     a.resetRawData((const char *)operands, bytes);
 
@@ -1274,20 +1274,20 @@ void Powerpoint::walkRecord(Q_UINT32 bytes, const unsigned char *operands)
 
     length += op.length;
     a.setRawData((const char *)operands, length);
-    QDataStream stream2(a, IO_ReadOnly);
-    stream2.setByteOrder(QDataStream::LittleEndian);
+    TQDataStream stream2(a, IO_ReadOnly);
+    stream2.setByteOrder(TQDataStream::LittleEndian);
     walk(length, stream2);
     a.resetRawData((const char *)operands, length);
 }
 
-void Powerpoint::walkRecord(Q_UINT32 mainStreamOffset)
+void Powerpoint::walkRecord(TQ_UINT32 mainStreamOffset)
 {
     walkRecord(sizeof(Header), m_mainStream.data + mainStreamOffset);
 }
 
-void Powerpoint::walkReference(Q_UINT32 reference)
+void Powerpoint::walkReference(TQ_UINT32 reference)
 {
-    if (m_persistentReferences.end() == m_persistentReferences.find(reference))
+    if (m_persistentReferences.end() == m_persistentReferences.tqfind(reference))
     {
         kdError(s_area) << "cannot find reference: " << reference << endl;
     }
diff --git a/filters/olefilters/powerpoint97/powerpoint.h b/filters/olefilters/powerpoint97/powerpoint.h
index 5c7a9195..54e8d7c7 100644
--- a/filters/olefilters/powerpoint97/powerpoint.h
+++ b/filters/olefilters/powerpoint97/powerpoint.h
@@ -29,24 +29,24 @@ DESCRIPTION
 
 
 #include <myfile.h>
-#include <qdatastream.h>
-#include <qptrlist.h>
-#include <qmap.h>
+#include <tqdatastream.h>
+#include <tqptrlist.h>
+#include <tqmap.h>
 #include <pptSlide.h>
 
-typedef Q_INT32 sint4; // signed 4-byte integral value
-typedef Q_INT16 sint2; // signed 4-byte integral value
-typedef Q_UINT32 uint4; // unsigned 4-byte integral value
-typedef Q_UINT16 uint2; // 2-byte
-typedef Q_INT8 bool1; // 1-byte boolean
-typedef Q_UINT8 ubyte1; // unsigned byte value
+typedef TQ_INT32 sint4; // signed 4-byte integral value
+typedef TQ_INT16 sint2; // signed 4-byte integral value
+typedef TQ_UINT32 uint4; // unsigned 4-byte integral value
+typedef TQ_UINT16 uint2; // 2-byte
+typedef TQ_INT8 bool1; // 1-byte boolean
+typedef TQ_UINT8 ubyte1; // unsigned byte value
 typedef uint2 psrType;
 typedef uint4 psrSize; // each record is preceded by
 // pssTypeType and pssSizeType.
 typedef uint2 psrInstance;
 typedef uint2 psrVersion;
 typedef uint4 psrReference; // Saved object reference
-//typedef QList<PptSlide> PptSlideList;
+//typedef TQList<PptSlide> PptSlideList;
 
 class Powerpoint
 {
@@ -67,20 +67,20 @@ public:
     typedef struct
     {
         unsigned type;
-        QString data;
+        TQString data;
     } SlideText;
 
     typedef struct
     {
         unsigned persistentReference;
-        QPtrList<SlideText> text;
+        TQPtrList<SlideText> text;
     } Slide;
 
 protected:
 
     virtual void gotDrawing(
         unsigned id,
-        QString type,
+        TQString type,
         unsigned length,
         const char *data) = 0;
     virtual void gotSlide(
@@ -100,7 +100,7 @@ private:
     myFile m_pictures;
     unsigned m_documentRef;
     bool m_documentRefFound;
-    QMap<unsigned, unsigned> m_persistentReferences;
+    TQMap<unsigned, unsigned> m_persistentReferences;
     unsigned 	m_editDepth;
     enum
     {
@@ -109,7 +109,7 @@ private:
     } m_pass;
     unsigned m_textType;
     
-    QPtrList<PptSlide>	m_slideList;
+    TQPtrList<PptSlide>	m_slideList;
     PptSlide*		m_pptSlide;
 
 struct PSR_CurrentUserAtom
@@ -144,7 +144,7 @@ struct PSR_SSlideLayoutAtom
     PSR_CurrentUserAtom mCurrentUserAtom;
     PSR_UserEditAtom    mUserEditAtom;
     PSR_UserEditAtom*   mpLastUserEditAtom;
-    Q_UINT32            mEditOffset;
+    TQ_UINT32            mEditOffset;
 
     // Common Header.
 
@@ -152,204 +152,204 @@ struct PSR_SSlideLayoutAtom
     {
         union
         {
-            Q_UINT16 info;
+            TQ_UINT16 info;
             struct
             {
-                Q_UINT16 version: 4;
-                Q_UINT16 instance: 12;
+                TQ_UINT16 version: 4;
+                TQ_UINT16 instance: 12;
             } fields;
         } opcode;
-        Q_UINT16 type;
-        Q_UINT32 length;
+        TQ_UINT16 type;
+        TQ_UINT32 length;
     } Header;
 
     // Opcode handling and painter methods.
 
     void walk(
-        Q_UINT32 bytes,
-        QDataStream &operands);
+        TQ_UINT32 bytes,
+        TQDataStream &operands);
     void walk(
-        Q_UINT32 mainStreamOffset);
+        TQ_UINT32 mainStreamOffset);
     void walkRecord(
-        Q_UINT32 bytes,
+        TQ_UINT32 bytes,
         const unsigned char *operands);
     void walkRecord(
-        Q_UINT32 mainStreamOffset);
+        TQ_UINT32 mainStreamOffset);
     void walkReference(
-        Q_UINT32 reference);
+        TQ_UINT32 reference);
     void skip(
-        Q_UINT32 bytes,
-        QDataStream &operands);
+        TQ_UINT32 bytes,
+        TQDataStream &operands);
     void invokeHandler(
         Header &op,
-        Q_UINT32 bytes,
-        QDataStream &operands);
+        TQ_UINT32 bytes,
+        TQDataStream &operands);
     void walkDocument();
 
-    void opAnimationInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opAnimationInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opArrayElementAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opBaseTextPropAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opBinaryTagData(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opBookmarkCollection(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opBookmarkEntityAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opBookmarkSeedAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opCharFormatAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opClientSignal1(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opClientSignal2(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opColorSchemeAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opCorePict(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opCorePictAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opCString(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opCurrentUserAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opDateTimeMCAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opDefaultRulerAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opDocRoutingSlip(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opDocument(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opDocumentAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opDocViewInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opEmFormatAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opEndDocument(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opEnvironment(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExAviMovie(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExCDAudio(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExCDAudioAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExControl(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExControlAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExEmbed(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExEmbedAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExHyperlink(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExHyperlinkAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExLink(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExLinkAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExLinkAtom_old(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExMCIMovie(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExMediaAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExMIDIAudio(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExObjList(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExObjListAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExObjRefAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExOleObj(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExOleObjAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExOleObjStg(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExPlain(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExPlainAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExPlainLink(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExPlainLinkAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExQuickTime(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExQuickTimeMovie(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExQuickTimeMovieData(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExSubscription(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExSubscriptionSection(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExternalObject(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExVideo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExWAVAudioEmbedded(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExWAVAudioEmbeddedAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opExWAVAudioLink(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opFontCollection(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opFontEmbedData(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opFontEntityAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opFooterMCAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGenericDateMCAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGlineAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGLPointAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGpointAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGratioAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGrColor(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGrColorAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGrectAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGscaling(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGscalingAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGuideAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opGuideList(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opHandout(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opHeaderMCAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opHeadersFooters(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opHeadersFootersAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opInt4ArrayAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opInteractiveInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opInteractiveInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opIRRAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opList(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opListPlaceholder(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opMainMaster(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opMasterText(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opMetaFile(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opMsod(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opNamedShow(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opNamedShows(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opNamedShowSlides(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opNotes(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opNotesAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opOEPlaceholderAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opOEShape(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opOEShapeAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opOutlineTextRefAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opOutlineViewInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opParaFormatAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opPersistPtrFullBlock(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opPersistPtrIncrementalBlock(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opPersistPtrIncrementalBlock2(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opPowerPointStateInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opPPDrawing(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opPPDrawingGroup(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opPrintOptions(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opProgBinaryTag(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opProgStringTag(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opProgTags(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opPSS(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opRecolorEntryAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opRecolorInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opRTFDateTimeMCAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opRulerIndentAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opRunArray(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opRunArrayAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opScheme(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSchemeAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlide(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlideAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlideBase(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlideBaseAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlideList(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlideListWithText(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlideNumberMCAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlidePersist(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlidePersistAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlideViewInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSlideViewInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSorterViewInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSound(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSoundCollAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSoundCollection(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSoundData(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSrKinsoku(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSrKinsokuAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSSDocInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSSSlideLayoutAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSSSlideInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opStyleTextPropAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSubContainerCompleted(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSubContainerException(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opSummary(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTextBookmarkAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTextBytesAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTextCharsAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTextHeaderAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTextRulerAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTextSpecInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTexture(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTxCFStyleAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTxInteractiveInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTxMasterStyleAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTxPFStyleAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTxSIStyleAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opTypeFace(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opUserEditAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opVBAInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opVBAInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opVBASlideInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opVBASlideInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opViewInfo(Header &op, Q_UINT32 bytes, QDataStream &operands);
-    void opViewInfoAtom(Header &op, Q_UINT32 bytes, QDataStream &operands);
+    void opAnimationInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opAnimationInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opArrayElementAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opBaseTextPropAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opBinaryTagData(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opBookmarkCollection(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opBookmarkEntityAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opBookmarkSeedAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opCharFormatAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opClientSignal1(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opClientSignal2(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opColorSchemeAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opCorePict(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opCorePictAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opCString(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opCurrentUserAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opDateTimeMCAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opDefaultRulerAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opDocRoutingSlip(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opDocument(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opDocumentAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opDocViewInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opEmFormatAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opEndDocument(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opEnvironment(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExAviMovie(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExCDAudio(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExCDAudioAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExControl(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExControlAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExEmbed(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExEmbedAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExHyperlink(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExHyperlinkAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExLink(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExLinkAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExLinkAtom_old(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExMCIMovie(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExMediaAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExMIDIAudio(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExObjList(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExObjListAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExObjRefAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExOleObj(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExOleObjAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExOleObjStg(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExPlain(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExPlainAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExPlainLink(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExPlainLinkAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExQuickTime(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExQuickTimeMovie(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExQuickTimeMovieData(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExSubscription(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExSubscriptionSection(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExternalObject(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExVideo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExWAVAudioEmbedded(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExWAVAudioEmbeddedAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opExWAVAudioLink(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opFontCollection(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opFontEmbedData(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opFontEntityAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opFooterMCAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGenericDateMCAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGlineAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGLPointAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGpointAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGratioAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGrColor(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGrColorAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGrectAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGscaling(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGscalingAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGuideAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opGuideList(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opHandout(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opHeaderMCAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opHeadersFooters(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opHeadersFootersAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opInt4ArrayAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opInteractiveInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opInteractiveInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opIRRAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opList(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opListPlaceholder(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opMainMaster(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opMasterText(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opMetaFile(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opMsod(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opNamedShow(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opNamedShows(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opNamedShowSlides(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opNotes(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opNotesAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opOEPlaceholderAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opOEShape(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opOEShapeAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opOutlineTextRefAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opOutlineViewInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opParaFormatAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opPersistPtrFullBlock(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opPersistPtrIncrementalBlock(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opPersistPtrIncrementalBlock2(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opPowerPointStateInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opPPDrawing(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opPPDrawingGroup(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opPrintOptions(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opProgBinaryTag(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opProgStringTag(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opProgTags(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opPSS(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opRecolorEntryAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opRecolorInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opRTFDateTimeMCAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opRulerIndentAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opRunArray(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opRunArrayAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opScheme(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSchemeAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlide(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlideAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlideBase(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlideBaseAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlideList(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlideListWithText(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlideNumberMCAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlidePersist(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlidePersistAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlideViewInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSlideViewInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSorterViewInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSound(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSoundCollAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSoundCollection(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSoundData(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSrKinsoku(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSrKinsokuAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSSDocInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSSSlideLayoutAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSSSlideInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opStyleTextPropAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSubContainerCompleted(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSubContainerException(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opSummary(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTextBookmarkAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTextBytesAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTextCharsAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTextHeaderAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTextRulerAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTextSpecInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTexture(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTxCFStyleAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTxInteractiveInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTxMasterStyleAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTxPFStyleAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTxSIStyleAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opTypeFace(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opUserEditAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opVBAInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opVBAInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opVBASlideInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opVBASlideInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opViewInfo(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
+    void opViewInfoAtom(Header &op, TQ_UINT32 bytes, TQDataStream &operands);
 };
 #endif
diff --git a/filters/olefilters/powerpoint97/powerpointfilter.cc b/filters/olefilters/powerpoint97/powerpointfilter.cc
index e0ea629a..5359dd98 100644
--- a/filters/olefilters/powerpoint97/powerpointfilter.cc
+++ b/filters/olefilters/powerpoint97/powerpointfilter.cc
@@ -32,25 +32,25 @@ PowerPointFilter::PowerPointFilter(
 
     connect(
         m_tree,
-        SIGNAL(signalPart(const QString&, QString &, QString &)),
+        TQT_SIGNAL(signalPart(const TQString&, TQString &, TQString &)),
         this,
-        SIGNAL(signalPart(const QString&, QString &, QString &)));
+        TQT_SIGNAL(signalPart(const TQString&, TQString &, TQString &)));
 
     // Hook up the embedded picture support.
 
     connect(
         m_tree,
-        SIGNAL(signalSavePic(const QString &, QString &, const QString &, unsigned int, const char *)),
+        TQT_SIGNAL(signalSavePic(const TQString &, TQString &, const TQString &, unsigned int, const char *)),
         this,
-        SIGNAL(signalSavePic(const QString &, QString &, const QString &, unsigned int, const char *)));
+        TQT_SIGNAL(signalSavePic(const TQString &, TQString &, const TQString &, unsigned int, const char *)));
 
     // Hook up the embedded part support.
 
     connect(
         m_tree,
-        SIGNAL(signalSavePart(const QString &, QString &, QString &, const QString &, unsigned int, const char *)),
+        TQT_SIGNAL(signalSavePart(const TQString &, TQString &, TQString &, const TQString &, unsigned int, const char *)),
         this,
-        SIGNAL(signalSavePart(const QString &, QString &, QString &, const QString &, unsigned int, const char *)));
+        TQT_SIGNAL(signalSavePart(const TQString &, TQString &, TQString &, const TQString &, unsigned int, const char *)));
 }
 
 PowerPointFilter::~PowerPointFilter()
@@ -63,9 +63,9 @@ bool PowerPointFilter::filter()
     return m_tree->convert();
 }
 
-const QDomDocument * const PowerPointFilter::part()
+const TQDomDocument * const PowerPointFilter::part()
 {
-    m_part = QDomDocument("DOC");
+    m_part = TQDomDocument("DOC");
     m_part.setContent(m_tree->getXml());
     return &m_part;
 }
diff --git a/filters/olefilters/powerpoint97/powerpointfilter.h b/filters/olefilters/powerpoint97/powerpointfilter.h
index 173d1ebb..b38706dc 100644
--- a/filters/olefilters/powerpoint97/powerpointfilter.h
+++ b/filters/olefilters/powerpoint97/powerpointfilter.h
@@ -27,6 +27,7 @@ class PowerPointFilter:
     public FilterBase
 {
     Q_OBJECT
+  TQ_OBJECT
 
 public:
     PowerPointFilter(
@@ -35,7 +36,7 @@ public:
         const myFile &pictures);
     virtual ~PowerPointFilter();
     virtual bool filter();
-    virtual const QDomDocument * const part();
+    virtual const TQDomDocument * const part();
 
 private:
     PowerPointFilter(const PowerPointFilter &);
diff --git a/filters/olefilters/powerpoint97/pptSlide.cpp b/filters/olefilters/powerpoint97/pptSlide.cpp
index b86418c9..e1b02296 100644
--- a/filters/olefilters/powerpoint97/pptSlide.cpp
+++ b/filters/olefilters/powerpoint97/pptSlide.cpp
@@ -36,7 +36,7 @@ PptSlide::PptSlide()
 //{
 //}
 
-QStringList PptSlide::getPlaceholderText(void)
+TQStringList PptSlide::getPlaceholderText(void)
 {
 	return m_currentPholder->paragraphs;
 }
@@ -46,33 +46,33 @@ QStringList PptSlide::getPlaceholderText(void)
 //	return m_currentPholder->styleRun;
 //}
 
-Q_UINT16 PptSlide::getPlaceholderType(void)
+TQ_UINT16 PptSlide::getPlaceholderType(void)
 {
 	return m_currentPholder->type;
 }
 
-Q_UINT16 PptSlide::gotoPlaceholder(Q_UINT16 pholderNumber)
+TQ_UINT16 PptSlide::gotoPlaceholder(TQ_UINT16 pholderNumber)
 {
 	m_currentPholder = m_placeholderList.at(pholderNumber);
         return 0;
 }
 
-Q_INT32 PptSlide::getPsrReference(void)
+TQ_INT32 PptSlide::getPsrReference(void)
 {
 	return m_psrReference;
 }
 
-void PptSlide::setPsrReference(Q_INT32 psr)
+void PptSlide::setPsrReference(TQ_INT32 psr)
 {
 	m_psrReference = psr;
 }
 
-Q_UINT16 PptSlide::getNumberOfPholders()
+TQ_UINT16 PptSlide::getNumberOfPholders()
 {
 	return m_numberOfPholders;
 }
 
-void PptSlide::addText(QString text, Q_UINT16 type)
+void PptSlide::addText(TQString text, TQ_UINT16 type)
 {
 	unsigned j;
 	m_currentPholder = new placeholder;
@@ -97,8 +97,8 @@ void PptSlide::addText(QString text, Q_UINT16 type)
 	case OTHER_TEXT:
 	case CENTER_BODY_TEXT:
 	case HALF_BODY_TEXT:
-	case QUARTER_BODY_TEXT:
-	        QStringList data(QStringList::split(QChar('\r'), text, true));
+	case TQUARTER_BODY_TEXT:
+	        TQStringList data(TQStringList::split(TQChar('\r'), text, true));
 		for (j = 0; j < data.count(); j++)
 		{
 			m_currentPholder->paragraphs.append(data[j]);
diff --git a/filters/olefilters/powerpoint97/pptSlide.h b/filters/olefilters/powerpoint97/pptSlide.h
index 16d53f8b..026e2ef1 100644
--- a/filters/olefilters/powerpoint97/pptSlide.h
+++ b/filters/olefilters/powerpoint97/pptSlide.h
@@ -25,20 +25,20 @@ DESCRIPTION
 //#define PPTSLIDE_H
 
 #include <kdebug.h>
-#include <qstring.h>
-#include <qstringlist.h>
-#include <qptrlist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
+#include <tqptrlist.h>
 
 //--text types
 #define TITLE_TEXT 			0	//title
 #define BODY_TEXT 			1	//body
 #define NOTES_TEXT 		2	//notes
 #define NOTUSED_TEXT 		3	//not used
-#define OTHER_TEXT 		4	//other(test in shape)
+#define OTHER_TEXT 		4	//other(test in tqshape)
 #define CENTER_BODY_TEXT 	5	//center body(subtitle in title slide)
 #define CENTER_TITLE_TEXT 	6	//center title(title in title slide)
 #define HALF_BODY_TEXT 	7	//half body(body in two-column slide)
-#define QUARTER_BODY_TEXT 	8	//quarter body(body in four-body slide)
+#define TQUARTER_BODY_TEXT 	8	//quarter body(body in four-body slide)
 //--
 
 //--char style types
@@ -55,37 +55,37 @@ class PptSlide
 public:
 	typedef struct
 	{
-		Q_UINT16 		style;				//the style of the text run
-		Q_UINT16 		length;			//length of the style run
+		TQ_UINT16 		style;				//the style of the text run
+		TQ_UINT16 		length;			//length of the style run
 	}styleRunType;
 	
-	typedef QPtrList<styleRunType>  styleRun;
+	typedef TQPtrList<styleRunType>  styleRun;
 	
 				PptSlide();
- 	QStringList 	getPlaceholderText(void);					//gets the list of paragraphs from the placeholder
+ 	TQStringList 	getPlaceholderText(void);					//gets the list of paragraphs from the placeholder
 	//styleRun 		getPlaceholderStyleRun(void);				//gets the list of placeholder style runs
-	Q_UINT16 		getPlaceholderType(void);					//gets the type of the placeholder
-	Q_UINT16 		gotoPlaceholder(Q_UINT16 pholderNumber);		//goto the n'th placeholder
-	Q_UINT16 		getNumberOfPholders();					//gets the number of placeholders on slide
+	TQ_UINT16 		getPlaceholderType(void);					//gets the type of the placeholder
+	TQ_UINT16 		gotoPlaceholder(TQ_UINT16 pholderNumber);		//goto the n'th placeholder
+	TQ_UINT16 		getNumberOfPholders();					//gets the number of placeholders on slide
 	
-	Q_INT32	 	getPsrReference(void);
-	void 			setPsrReference(Q_INT32 psr);
+	TQ_INT32	 	getPsrReference(void);
+	void 			setPsrReference(TQ_INT32 psr);
 	
-	void 			addText(QString text, Q_UINT16 type);				//adds text of the given type
-	void 			addToStyleRun(Q_UINT16 style, Q_UINT16 length);	//adds to the current style run
+	void 			addText(TQString text, TQ_UINT16 type);				//adds text of the given type
+	void 			addToStyleRun(TQ_UINT16 style, TQ_UINT16 length);	//adds to the current style run
 
 private:
 	typedef struct
 	{
-		QStringList 		paragraphs;		//text of the placeholder
-		Q_UINT16 			type;				//what is the text type
+		TQStringList 		paragraphs;		//text of the placeholder
+		TQ_UINT16 			type;				//what is the text type
 		styleRun			style;				//char style info
 	}placeholder;
 
-	Q_INT16 			m_slideLayout;		//type of slide
-	Q_INT16 			m_numberOfPholders;	//number of placeholder on the slide
-	Q_INT32			m_psrReference;		//logical reference
-     	QPtrList<placeholder>	m_placeholderList;	//list of all the placeholders on the slide
+	TQ_INT16 			m_slideLayout;		//type of slide
+	TQ_INT16 			m_numberOfPholders;	//number of placeholder on the slide
+	TQ_INT32			m_psrReference;		//logical reference
+     	TQPtrList<placeholder>	m_placeholderList;	//list of all the placeholders on the slide
      	placeholder*		m_currentPholder;	//pointer to current placeholder
 
 };
diff --git a/filters/olefilters/powerpoint97/pptdoc.cc b/filters/olefilters/powerpoint97/pptdoc.cc
index 0e40293f..07ac8725 100644
--- a/filters/olefilters/powerpoint97/pptdoc.cc
+++ b/filters/olefilters/powerpoint97/pptdoc.cc
@@ -24,7 +24,7 @@ DESCRIPTION
 
 #include <kdebug.h>
 #include <pptdoc.h>
-#include <qptrlist.h>
+#include <tqptrlist.h>
 
 const int PptDoc::s_area = 30512;
 
@@ -52,7 +52,7 @@ void PptDoc::gotSlide(
     for (i = 0; i < slide.text.count(); i++)
     {
         SlideText *text = slide.text.at(i);
-        QStringList data(QStringList::split(QChar('\r'), text->data, true));
+        TQStringList data(TQStringList::split(TQChar('\r'), text->data, true));
         unsigned j;
 
         switch (text->type)
@@ -68,7 +68,7 @@ void PptDoc::gotSlide(
 	case OTHER_TEXT:
 	case CENTER_BODY_TEXT:
 	case HALF_BODY_TEXT:
-	case QUARTER_BODY_TEXT:
+	case TQUARTER_BODY_TEXT:
 		for (j = 0; j < data.count(); j++)
 		{
 			ourSlide.body.append(data[j]);
diff --git a/filters/olefilters/powerpoint97/pptdoc.h b/filters/olefilters/powerpoint97/pptdoc.h
index f7008ad9..5619d6e4 100644
--- a/filters/olefilters/powerpoint97/pptdoc.h
+++ b/filters/olefilters/powerpoint97/pptdoc.h
@@ -28,8 +28,8 @@ DESCRIPTION
 #include <kdebug.h>
 #include <myfile.h>
 #include <powerpoint.h>
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 
 class myFile;
 
@@ -48,7 +48,7 @@ protected:
 
     // Metadata.
 
-    QString getAuthor(void) const;
+    TQString getAuthor(void) const;
 
     // Call the parse() function to process the document. The callbacks return
     // the text along with any relevant attributes.
@@ -57,7 +57,7 @@ protected:
 
     virtual void gotDrawing(
         unsigned id,
-        QString type,
+        TQString type,
         unsigned length,
         const char *data) = 0;
     virtual void gotSlide(PptSlide &slide) = 0;
diff --git a/filters/olefilters/powerpoint97/pptxml.cc b/filters/olefilters/powerpoint97/pptxml.cc
index 1202edcc..7c6a45fe 100644
--- a/filters/olefilters/powerpoint97/pptxml.cc
+++ b/filters/olefilters/powerpoint97/pptxml.cc
@@ -22,7 +22,7 @@ DESCRIPTION
 
 #include <pptdoc.h>
 #include <pptxml.h>
-#include <qobject.h>
+#include <tqobject.h>
 #include <KoGlobal.h>
 
 const int PptXml::s_area = 30512;
@@ -57,27 +57,27 @@ bool PptXml::convert()
     return m_success;
 }
 
-void PptXml::encode(QString &text)
+void PptXml::encode(TQString &text)
 {
   // When encoding the stored form of text to its run-time form,
   // be sure to do the conversion for "&amp;" to "&" first to avoid
   // accidentally converting user text into one of the other escape
   // sequences.
 
-  text.replace('&', "&amp;");
-  text.replace('<', "&lt;");
-  text.replace('>', "&gt;"); // Needed to avoid ]]>
+  text.tqreplace('&', "&amp;");
+  text.tqreplace('<', "&lt;");
+  text.tqreplace('>', "&gt;"); // Needed to avoid ]]>
 
   // Strictly, there is no need to encode " or ', but we do so to allow
   // them to co-exist!
 
-  text.replace('"', "&quot;");
-  text.replace('\'', "&apos;");
+  text.tqreplace('"', "&quot;");
+  text.tqreplace('\'', "&apos;");
 }
 
-const QString PptXml::getXml() const
+const TQString PptXml::getXml() const
 {
-    QString body = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><!DOCTYPE DOC>\n"
+    TQString body = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><!DOCTYPE DOC>\n"
         "<DOC mime=\"application/x-kpresenter\" email=\"[email protected]\" syntaxVersion=\"2\" author=\"Reginald Stadlbauer\" editor=\"Powerpoint import filter\">\n"
         " <PAPER ptWidth=\"680\" unit=\"0\" format=\"5\" orientation=\"0\" ptHeight=\"510\">\n"
         "  <PAPERBORDERS ptRight=\"0\" ptBottom=\"0\" ptLeft=\"0\" ptTop=\"0\"/>\n"
@@ -129,24 +129,24 @@ const QString PptXml::getXml() const
 
 void PptXml::gotDrawing(
     unsigned id,
-    QString type,
+    TQString type,
     unsigned length,
     const char *data)
 {
-    QString ourKey;
-    QString uid;
-    QString mimeType;
-    QString filterArgs;
+    TQString ourKey;
+    TQString uid;
+    TQString mimeType;
+    TQString filterArgs;
 
     // Send the picture to the outside world and get back the UID.
 
-    ourKey = "vectorGraphic" + QString::number(id) + "." + type;
+    ourKey = "vectorGraphic" + TQString::number(id) + "." + type;
     if (type == "msod")
     {
-        filterArgs = "shape-id=";
-        filterArgs += QString::number(id);
+        filterArgs = "tqshape-id=";
+        filterArgs += TQString::number(id);
         filterArgs += ";delay-stream=";
-        filterArgs += QString::number(0);
+        filterArgs += TQString::number(0);
     }
     emit signalSavePart(
             ourKey,
@@ -184,10 +184,10 @@ if (mimeType != "application/x-kontour")
 void PptXml::gotSlide(PptSlide &slide)
 {
 	static const unsigned pageHeight = 510;
-	Q_UINT16 numbOfPholders = 0;
+	TQ_UINT16 numbOfPholders = 0;
     	m_pages += "  <PAGE/>\n";
 	numbOfPholders = slide.getNumberOfPholders();
-	for(Q_UINT16 i = 0; i < numbOfPholders; i++)
+	for(TQ_UINT16 i = 0; i < numbOfPholders; i++)
 	{
 		slide.gotoPlaceholder(i);
 		setPlaceholder(slide);
@@ -197,51 +197,51 @@ void PptXml::gotSlide(PptSlide &slide)
 
 void PptXml::setPlaceholder(PptSlide &slide)
 {
- 	QString xml_friendly;
+ 	TQString xml_friendly;
  	unsigned i = 0;
 	bool 		bulletedList = false; 	//is this a bulleted list?
-	Q_UINT16 	type;				//type of text
-	QString 	x;				//x of placeholder
-	QString 	align;				//align of text
-	QString 	height ;			//height of placeholder
-	QString 	width ;			//width of placeholder
-	QString 	pointSize;			//font size
+	TQ_UINT16 	type;				//type of text
+	TQString 	x;				//x of placeholder
+	TQString 	align;				//align of text
+	TQString 	height ;			//height of placeholder
+	TQString 	width ;			//width of placeholder
+	TQString 	pointSize;			//font size
 
  	xml_friendly = *slide.getPlaceholderText().at(i);
   	encode(xml_friendly);
 
 	type = slide.getPlaceholderType();
-	Q_UINT16 y = 0;
+	TQ_UINT16 y = 0;
 
 	switch (type)
 	{
 	case TITLE_TEXT:
 		y = 30;
-		height = QString::number(55);
-		x = QString::number(30);
-		width = QString::number(610);
-		align = QString::number(ALIGN_CENTER);
-		pointSize = QString::number(44);
+		height = TQString::number(55);
+		x = TQString::number(30);
+		width = TQString::number(610);
+		align = TQString::number(ALIGN_CENTER);
+		pointSize = TQString::number(44);
 		bulletedList = false;
 		m_titles += "  <Title title=\"" + xml_friendly + "\" />\n";
 		break;
 	case CENTER_TITLE_TEXT:
 		y = 130;
-		x = QString::number(45);
-		height = QString::number(55);
-		width = QString::number(610);
-		align = QString::number(ALIGN_CENTER);
-		pointSize = QString::number(44);
+		x = TQString::number(45);
+		height = TQString::number(55);
+		width = TQString::number(610);
+		align = TQString::number(ALIGN_CENTER);
+		pointSize = TQString::number(44);
 		bulletedList = false;
 		m_titles += "  <Title title=\"" + xml_friendly + "\" />\n";
 		break;
 	case CENTER_BODY_TEXT:
 		y = 200;
-		x = QString::number(35);
-		height = QString::number(37);
-		width = QString::number(610);
-		align = QString::number(ALIGN_CENTER);
-		pointSize = QString::number(32);
+		x = TQString::number(35);
+		height = TQString::number(37);
+		width = TQString::number(610);
+		align = TQString::number(ALIGN_CENTER);
+		pointSize = TQString::number(32);
 		bulletedList = false;
 		break;
 	case NOTES_TEXT:
@@ -249,32 +249,32 @@ void PptXml::setPlaceholder(PptSlide &slide)
 		break;
 	case BODY_TEXT:
 		y = 130;
-		x = QString::number(35);
-		height = QString::number(268);
-		width = QString::number(610);
-		align = QString::number(ALIGN_LEFT);
-		pointSize = QString::number(28);
+		x = TQString::number(35);
+		height = TQString::number(268);
+		width = TQString::number(610);
+		align = TQString::number(ALIGN_LEFT);
+		pointSize = TQString::number(28);
 		bulletedList = true;
 		break;
 	case OTHER_TEXT:
 	case HALF_BODY_TEXT:
-	case QUARTER_BODY_TEXT:
+	case TQUARTER_BODY_TEXT:
 		y = 130;
 		if(m_half)
 		{
-			x = QString::number(335);
-			width = QString::number(300);
+			x = TQString::number(335);
+			width = TQString::number(300);
 			m_half = false;
 		}
 		else
 		{
-			x = QString::number(30);
-			width = QString::number(300);
+			x = TQString::number(30);
+			width = TQString::number(300);
 			m_half = true;
 		}
-		height = QString::number(268);
-		align = QString::number(ALIGN_LEFT);
-		pointSize = QString::number(28);
+		height = TQString::number(268);
+		align = TQString::number(ALIGN_LEFT);
+		pointSize = TQString::number(28);
 		bulletedList = true;
 		break;
 	default:
@@ -283,7 +283,7 @@ void PptXml::setPlaceholder(PptSlide &slide)
 	}
 
     	m_text += "<OBJECT type=\"4\">\n"
-            	" <ORIG x=\""+x+"\" y=\""+QString::number(y + m_y)+"\"/>\n"
+            	" <ORIG x=\""+x+"\" y=\""+TQString::number(y + m_y)+"\"/>\n"
             	" <SIZE width=\""+width+"\" height=\""+ height +"\"/>\n"
             	" <PEN width=\"1\" style=\"0\" color=\"#000000\"/>\n"
             	" <TEXTOBJ>\n"
diff --git a/filters/olefilters/powerpoint97/pptxml.h b/filters/olefilters/powerpoint97/pptxml.h
index b57338cb..f3ffbdb1 100644
--- a/filters/olefilters/powerpoint97/pptxml.h
+++ b/filters/olefilters/powerpoint97/pptxml.h
@@ -24,8 +24,8 @@ DESCRIPTION
 #define PPTXML_H
 
 #include <pptdoc.h>
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 
 #define ALIGN_LEFT 		1
 #define ALIGN_RIGHT 	2
@@ -33,14 +33,15 @@ DESCRIPTION
 #define ALIGN_JUSTIFY 	8
 
 class myFile;
-class QDomDocument;
+class TQDomDocument;
 
 class PptXml:
-    public QObject,
+    public TQObject,
     private PptDoc
 {
 
     Q_OBJECT
+  TQ_OBJECT
 
 public:
     PptXml(
@@ -51,29 +52,29 @@ public:
 
     bool convert();
 
-    const QString getXml() const;
+    const TQString getXml() const;
 
 signals:
     // See olefilter.h for information
     void signalSavePic(
-        const QString &nameIN,
-        QString &storageId,
-        const QString &extension,
+        const TQString &nameIN,
+        TQString &storageId,
+        const TQString &extension,
         unsigned int length,
         const char *data);
 
     void signalSavePart(
-        const QString &nameIN,
-        QString &storageId,
-        QString &mimeType,
-        const QString &extension,
+        const TQString &nameIN,
+        TQString &storageId,
+        TQString &mimeType,
+        const TQString &extension,
         unsigned int length,
         const char *data);
 
     void signalPart(
-        const QString& nameIN,
-        QString &storageId,
-        QString &mimeType);
+        const TQString& nameIN,
+        TQString &storageId,
+        TQString &mimeType);
 
 private:
     PptXml(const PptXml &);
@@ -89,18 +90,18 @@ private:
     bool m_success;
     bool m_half;
     unsigned m_y;
-    QString m_embedded;
-    QString m_pages;
-    QString m_titles;
-    QString m_notes;
-    QString m_text;
-    void encode(QString &text);
+    TQString m_embedded;
+    TQString m_pages;
+    TQString m_titles;
+    TQString m_notes;
+    TQString m_text;
+    void encode(TQString &text);
 
     // Override the base class functions.
 
     void gotDrawing(
         unsigned id,
-        QString type,
+        TQString type,
         unsigned length,
         const char *data);
     void gotSlide(PptSlide &slide);