Initial TQt conversion

Signed-off-by: Slávek Banko <slavek.banko@axis.cz>

6 files changed, 2627 insertions, 2627 deletions

diff --git a/domino/data.h b/domino/data.h
index 5ac0f48..613eb45 100644
--- a/domino/data.h
+++ b/domino/data.h
@@ -18,35 +18,35 @@
 
 #ifndef _QEMBED_1804289383
 #define _QEMBED_1804289383
-#include <qimage.h>
-#include <qdict.h>
-static const QRgb arrow_down_small_data[] = {
+#include <tqimage.h>
+#include <tqdict.h>
+static const TQRgb arrow_down_small_data[] = {
     0x2d000000,0x96000000,0x96000000,0x96000000,0x2e000000,0x1000000,0x79000000,0x99000000,0x7a000000,0x1000000,0x0,0x29000000,0x99000000,0x2b000000,
     0x0,0x0,0x0,0x4f000000,0x0,0x0
 };
 
 /* Generated by qembed */
-static const QRgb btn17H_data[] = {
+static const TQRgb btn17H_data[] = {
     0x0,0x0,0x0,0x0,0xc6000000,0xc6000000,0xc6000000,0xc6000000,0x23000000,0x23000000,0x23000000,0x23000000,0x23000000,0x23000000,
     0x23000000,0x23000000,0xc6000000,0xc6000000,0xc6000000,0xc6000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb btn17HRaisedShadow_data[] = {
+static const TQRgb btn17HRaisedShadow_data[] = {
     0x1e000000,0x1e000000,0x1e000000,0x1e000000,0x15000000,0x15000000,0x15000000,0x15000000,0x1effffff,0x1effffff,0x1effffff,0x1effffff,0x18ffffff,0x18ffffff,
     0x18ffffff,0x18ffffff,0x2000000,0x2000000,0x2000000,0x2000000,0x2d000000,0x2d000000,0x2d000000,0x2d000000,0x11000000,0x11000000,0x11000000,0x11000000
 };
 
-static const QRgb btn17HRaisedShadowPressed_data[] = {
+static const TQRgb btn17HRaisedShadowPressed_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x18ffffff,0x18ffffff,0x18ffffff,0x18ffffff,0x18ffffff,0x18ffffff,
     0x18ffffff,0x18ffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb btn17HSunkenShadow_data[] = {
+static const TQRgb btn17HSunkenShadow_data[] = {
     0x1c000000,0x1c000000,0x1c000000,0x1c000000,0x15000000,0x15000000,0x15000000,0x15000000,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x4effffff,0x4effffff,0x4effffff,0x4effffff,0x1effffff,0x1effffff,0x1effffff,0x1effffff
 };
 
-static const QRgb btn17_data[] = {
+static const TQRgb btn17_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x2000000,0x2b000000,0x79000000,0xb3000000,0xb3000000,0x79000000,0x29000000,0x2000000,0x0,0x0,0x0,0x2000000,0x46000000,0xb9000000,
     0x76000000,0x33000000,0x33000000,0x77000000,0xb9000000,0x46000000,0x2000000,0x0,0x0,0x20000000,0xb5000000,0x49000000,0x4000000,0x1000000,
@@ -61,7 +61,7 @@ static const QRgb btn17_data[] = {
     0x0,0x0
 };
 
-static const QRgb btn17RaisedShadow3_data[] = {
+static const TQRgb btn17RaisedShadow3_data[] = {
     0x0,0x0,0x0,0x2000000,0x5000000,0xb000000,0xb000000,0x5000000,0x2000000,0x0,0x0,0x0,0x0,0x0,
     0x3000000,0xd000000,0x15000000,0x10000000,0x10000000,0x15000000,0xd000000,0x3000000,0x0,0x0,0x0,0x3000000,0xe000000,0xf000000,
     0x26f8f8f8,0x1dffffff,0x1effffff,0x26f8f8f8,0xf000000,0xe000000,0x3000000,0x0,0x0,0x8000000,0xe000000,0x1dffffff,0x17ffffff,0x8ffffff,
@@ -76,7 +76,7 @@ static const QRgb btn17RaisedShadow3_data[] = {
     0x0,0x0
 };
 
-static const QRgb btn17RaisedShadowPressed_data[] = {
+static const TQRgb btn17RaisedShadowPressed_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x25ffffff,0x1dffffff,0x1effffff,0x25ffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1dffffff,0x17ffffff,0x8ffffff,
@@ -91,7 +91,7 @@ static const QRgb btn17RaisedShadowPressed_data[] = {
     0x0,0x0
 };
 
-static const QRgb btn17SunkenShadow_data[] = {
+static const TQRgb btn17SunkenShadow_data[] = {
     0x0,0x0,0x0,0x4000000,0xb000000,0x15000000,0x15000000,0xb000000,0x4000000,0x0,0x0,0x0,0x0,0x0,
     0x6000000,0x16000000,0x25000000,0x1c000000,0x1c000000,0x25000000,0x16000000,0x6000000,0x0,0x0,0x1ffffff,0x4000000,0x16000000,0x1b000000,
     0x3000000,0x0,0x0,0x3000000,0x1b000000,0x16000000,0x4000000,0x1ffffff,0x6d4d4d4,0xb000000,0x18000000,0x0,0x0,0x0,
@@ -106,32 +106,32 @@ static const QRgb btn17SunkenShadow_data[] = {
     0x1ffffff,0x0
 };
 
-static const QRgb btn17V_data[] = {
+static const TQRgb btn17V_data[] = {
     0x0,0xc6000000,0x23000000,0x23000000,0xc6000000,0x0,0x0,0xc6000000,0x23000000,0x23000000,0xc6000000,0x0,0x0,0xc6000000,
     0x23000000,0x23000000,0xc6000000,0x0,0x0,0xc6000000,0x23000000,0x23000000,0xc6000000,0x0
 };
 
-static const QRgb btn17VRaisedShadow_data[] = {
+static const TQRgb btn17VRaisedShadow_data[] = {
     0x16000000,0x0,0x18ffffff,0x18ffffff,0x0,0x16000000,0x16000000,0x0,0x18ffffff,0x18ffffff,0x0,0x16000000,0x16000000,0x0,
     0x18ffffff,0x18ffffff,0x0,0x16000000,0x16000000,0x0,0x18ffffff,0x18ffffff,0x0,0x16000000
 };
 
-static const QRgb btn17VRaisedShadowPressed_data[] = {
+static const TQRgb btn17VRaisedShadowPressed_data[] = {
     0x0,0x0,0x18ffffff,0x18ffffff,0x0,0x0,0x0,0x0,0x18ffffff,0x18ffffff,0x0,0x0,0x0,0x0,
     0x18ffffff,0x18ffffff,0x0,0x0,0x0,0x0,0x18ffffff,0x18ffffff,0x0,0x0
 };
 
-static const QRgb btn17VSunkenShadow_data[] = {
+static const TQRgb btn17VSunkenShadow_data[] = {
     0x22d9d9d9,0x0,0x0,0x0,0x0,0x22d9d9d9,0x22d9d9d9,0x0,0x0,0x0,0x0,0x22d9d9d9,0x22d9d9d9,0x0,
     0x0,0x0,0x0,0x22d9d9d9,0x22d9d9d9,0x0,0x0,0x0,0x0,0x22d9d9d9
 };
 
-static const QRgb btnPressedShadowHLines_data[] = {
+static const TQRgb btnPressedShadowHLines_data[] = {
     0x81000000,0x81000000,0x81000000,0x81000000,0x4a000000,0x4a000000,0x4a000000,0x4a000000,0x1f000000,0x1f000000,0x1f000000,0x1f000000,0x8000000,0x8000000,
     0x8000000,0x8000000,0x1e000000,0x1e000000,0x1e000000,0x1e000000
 };
 
-static const QRgb btnPressedShadowRectangular_data[] = {
+static const TQRgb btnPressedShadowRectangular_data[] = {
     0x9c000000,0x8c000000,0x84000000,0x81000000,0x81000000,0x81000000,0x81000000,0x84000000,0x8c000000,0x9c000000,0x7a000000,0x5e000000,0x50000000,0x4b000000,
     0x4a000000,0x4a000000,0x4b000000,0x4f000000,0x5e000000,0x7a000000,0x5e000000,0x3a000000,0x26000000,0x20000000,0x1f000000,0x1f000000,0x20000000,0x26000000,
     0x39000000,0x5e000000,0x50000000,0x26000000,0x11000000,0x0,0x0,0x0,0x0,0x11000000,0x26000000,0x50000000,0x4b000000,0x20000000,
@@ -141,7 +141,7 @@ static const QRgb btnPressedShadowRectangular_data[] = {
     0x1f000000,0x26000000,0x39000000,0x5e000000,0x0,0x0
 };
 
-static const QRgb btnPressedShadowRound_data[] = {
+static const TQRgb btnPressedShadowRound_data[] = {
     0x0,0x0,0x53000000,0x72000000,0x82000000,0x82000000,0x72000000,0x53000000,0x0,0x0,0x0,0x68000000,0x79000000,0x62000000,
     0x54000000,0x54000000,0x62000000,0x78000000,0x68000000,0x0,0x33000000,0x6e000000,0x4d000000,0x35000000,0x28000000,0x27000000,0x35000000,0x4d000000,
     0x6e000000,0x33000000,0x5a000000,0x4d000000,0x2b000000,0x17000000,0x7000000,0x7000000,0x17000000,0x2b000000,0x4d000000,0x5a000000,0x55000000,0x2e000000,
@@ -151,12 +151,12 @@ static const QRgb btnPressedShadowRound_data[] = {
     0x27000000,0x1b000000,0x0,0x0,0x0,0x0
 };
 
-static const QRgb btnPressedShadowVLines_data[] = {
+static const TQRgb btnPressedShadowVLines_data[] = {
     0x4a000000,0x1f000000,0x9000000,0x8000000,0x1e000000,0x4a000000,0x4a000000,0x1f000000,0x9000000,0x8000000,0x1e000000,0x4a000000,0x4a000000,0x1f000000,
     0x9000000,0x8000000,0x1e000000,0x4a000000,0x4a000000,0x1f000000,0x9000000,0x8000000,0x1e000000,0x4a000000
 };
 
-static const QRgb checkbox2inside_data[] = {
+static const TQRgb checkbox2inside_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
@@ -184,7 +184,7 @@ static const QRgb checkbox2inside_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb checkbox2pressed_data[] = {
+static const TQRgb checkbox2pressed_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
@@ -212,7 +212,7 @@ static const QRgb checkbox2pressed_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb checkbox2rect_data[] = {
+static const TQRgb checkbox2rect_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1a000000,0x6a000000,0xba000000,0xc8000000,
@@ -240,7 +240,7 @@ static const QRgb checkbox2rect_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb checkbox2shadow_data[] = {
+static const TQRgb checkbox2shadow_data[] = {
     0x0,0x0,0x0,0x2000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,0x4000000,
     0x2000000,0x0,0x0,0x0,0x0,0x0,0x4000000,0xf222222,0x17212121,0x191e1e1e,0x191e1e1e,0x1a272727,0x1a272727,0x1a272727,
     0x1a272727,0x1a272727,0x191e1e1e,0x17212121,0xf222222,0x4000000,0x0,0x0,0x0,0x3555555,0x13505050,0x106f6f6f,0xfefefe,0xffffff,
@@ -268,7 +268,7 @@ static const QRgb checkbox2shadow_data[] = {
     0x3ffffff,0x3ffffff,0x2ffffff,0xffffff,0x0,0x0
 };
 
-static const QRgb checkListExclusiveIndicator_data[] = {
+static const TQRgb checkListExclusiveIndicator_data[] = {
     0x0,0x0,0x3000000,0x28000000,0x76000000,0x9c000000,0xa3000000,0x9c000000,0x76000000,0x28000000,0x3000000,0x0,0x0,0x0,
     0x4000000,0x61000000,0xad000000,0x71000000,0x42000000,0x31000000,0x42000000,0x71000000,0xad000000,0x61000000,0x4000000,0x0,0x3000000,0x65000000,
     0xaf000000,0x20000000,0x4000000,0x1000000,0x1000000,0x1000000,0x4000000,0x20000000,0xaf000000,0x65000000,0x3000000,0x29000000,0xb1000000,0x21000000,
@@ -284,7 +284,7 @@ static const QRgb checkListExclusiveIndicator_data[] = {
     0x0
 };
 
-static const QRgb checkmark_data[] = {
+static const TQRgb checkmark_data[] = {
     0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,
     0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,
     0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,
@@ -307,7 +307,7 @@ static const QRgb checkmark_data[] = {
     0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff
 };
 
-static const QRgb dockBack_data[] = {
+static const TQRgb dockBack_data[] = {
     0x0,0x0,0x1ffffff,0x360c0c0c,0x65030303,0x79010101,0x79010101,0x65030303,0x360c0c0c,0x1ffffff,0x0,0x0,0x0,0x1ffffff,
     0x4d070707,0x6f000000,0x60000000,0x59000000,0x59000000,0x60000000,0x6f000000,0x4d070707,0x1bfbfbf,0x0,0x1ffffff,0x36141414,0x68000000,0x55000000,
     0x4f000000,0x3d5a5a5a,0x3c5c5c5c,0x4f000000,0x55000000,0x68000000,0x36141414,0x1ffffff,0x4ffffff,0x5a0b0b0b,0x55000000,0x4d000000,0x4c000000,0x3c606060,
@@ -331,7 +331,7 @@ static const QRgb dockBack_data[] = {
     0x9ffffff,0xbffffff,0xbffffff,0x9ffffff,0x4ffffff,0x1ffffff,0x0,0x0
 };
 
-static const QRgb dockClose_data[] = {
+static const TQRgb dockClose_data[] = {
     0x0,0x0,0x1ffffff,0x360c0c0c,0x65030303,0x79010101,0x79010101,0x65030303,0x360c0c0c,0x1ffffff,0x0,0x0,0x0,0x1ffffff,
     0x4d070707,0x6f000000,0x60000000,0x59000000,0x59000000,0x60000000,0x6f000000,0x4d070707,0x1bfbfbf,0x0,0x1ffffff,0x36141414,0x68000000,0x3c7a7a7a,
     0x3f131313,0x4d000000,0x4d000000,0x3f131313,0x3e8a8a8a,0x68000000,0x36141414,0x1ffffff,0x4ffffff,0x5a0b0b0b,0x55000000,0x434a4a4a,0x23f4f4f4,0x32141414,
@@ -355,7 +355,7 @@ static const QRgb dockClose_data[] = {
     0x9ffffff,0xbffffff,0xbffffff,0x9ffffff,0x4ffffff,0x1ffffff,0x0,0x0
 };
 
-static const QRgb dockStay_data[] = {
+static const TQRgb dockStay_data[] = {
     0x0,0x0,0x1ffffff,0x360c0c0c,0x65030303,0x79010101,0x79010101,0x65030303,0x360c0c0c,0x1ffffff,0x0,0x0,0x0,0x1ffffff,
     0x4d070707,0x6f000000,0x60000000,0x59000000,0x59000000,0x60000000,0x6f000000,0x4d070707,0x1bfbfbf,0x0,0x1ffffff,0x36141414,0x68000000,0x403b3b3b,
     0x3fa2a2a2,0x44b3b3b3,0x44b2b2b2,0x3fa2a2a2,0x403b3b3b,0x68000000,0x36141414,0x1ffffff,0x4ffffff,0x5a0b0b0b,0x55000000,0x277b7b7b,0x3d000000,0x4c000000,
@@ -379,7 +379,7 @@ static const QRgb dockStay_data[] = {
     0x9ffffff,0xbffffff,0xbffffff,0x9ffffff,0x4ffffff,0x1ffffff,0x0,0x0
 };
 
-static const QRgb dockToDesktop2_data[] = {
+static const TQRgb dockToDesktop2_data[] = {
     0x0,0x0,0x1ffffff,0x360c0c0c,0x64030303,0x79010101,0x79010101,0x64030303,0x360c0c0c,0x1ffffff,0x0,0x0,0x0,0x1ffffff,
     0x4d070707,0x6f000000,0x60000000,0x59000000,0x59000000,0x60000000,0x6f000000,0x4d070707,0x1bfbfbf,0x0,0x1ffffff,0x36151515,0x68000000,0x55000000,
     0x4f000000,0x32707070,0x2d8d8d8d,0x30868686,0x3b5c5c5c,0x68000000,0x36151515,0x1ffffff,0x4ffffff,0x5a0c0c0c,0x55000000,0x4d000000,0x4c000000,0x2a8b8b8b,
@@ -403,13 +403,13 @@ static const QRgb dockToDesktop2_data[] = {
     0x9ffffff,0xbffffff,0xbffffff,0x9ffffff,0x4ffffff,0x1ffffff,0x0,0x0
 };
 
-static const QRgb focusRectEdges_data[] = {
+static const TQRgb focusRectEdges_data[] = {
     0x0,0x3b000000,0xbb000000,0xbb000000,0x3b000000,0x0,0x33000000,0xc1000000,0x20000000,0x20000000,0xc1000000,0x33000000,0xbb000000,0x17000000,
     0x0,0x0,0x17000000,0xbb000000,0xbb000000,0x17000000,0x0,0x0,0x17000000,0xbb000000,0x33000000,0xc1000000,0x20000000,0x20000000,
     0xc1000000,0x33000000,0x0,0x3b000000,0xbb000000,0xbb000000,0x3b000000,0x0
 };
 
-static const QRgb groupBoxMask_small_data[] = {
+static const TQRgb groupBoxMask_small_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x1bff0000,0x88ff0000,0xd1ff0000,0xffff0000,0xffff0000,0xd1ff0000,0x88ff0000,0x1bff0000,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x64ff0000,0xf6ff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,
@@ -431,7 +431,7 @@ static const QRgb groupBoxMask_small_data[] = {
     0x0,0x0,0x0,0x0
 };
 
-static const QRgb groupBox_small_data[] = {
+static const TQRgb groupBox_small_data[] = {
     0xffffff,0xffffff,0xffffff,0xffffff,0x3ffffff,0xbffffff,0x13ffffff,0x17ffffff,0x17ffffff,0x13ffffff,0xbffffff,0x3ffffff,0xffffff,0xffffff,
     0xffffff,0xffffff,0xffffff,0xffffff,0x1ffffff,0xbffffff,0x27b8b8b8,0x464d4d4d,0x4e212121,0x48000000,0x48000000,0x4e212121,0x464d4d4d,0x27b8b8b8,
     0xbffffff,0x1ffffff,0xffffff,0xffffff,0xffffff,0x1ffffff,0xfffffff,0x40707070,0x44080808,0x37000000,0x29000000,0x21000000,0x20000000,0x28000000,
@@ -453,7 +453,7 @@ static const QRgb groupBox_small_data[] = {
     0x3ffffff,0xffffff,0xffffff,0xffffff
 };
 
-static const QRgb lineedit4edges_data[] = {
+static const TQRgb lineedit4edges_data[] = {
     0x0,0x1e121212,0x56141414,0x7a181818,0x7a181818,0x56141414,0x1e121212,0x0,0x1e000000,0x6c171717,0x51151515,0x3a131313,0x3a131313,0x51151515,
     0x6c171717,0x1e000000,0x4a000000,0x3f000000,0x1b111111,0xb111111,0xb111111,0x1b111111,0x3f000000,0x4a000000,0x4e000000,0x1d000000,0x5101010,0x20a0a0a,
     0x20a0a0a,0x5101010,0x1c000000,0x4e000000,0x4f000000,0xc000000,0x0,0x0,0x0,0x0,0xa000000,0x4f000000,0x36000000,0x14000000,
@@ -461,7 +461,7 @@ static const QRgb lineedit4edges_data[] = {
     0x0,0x11000000,0x1d000000,0x1f000000,0x1f000000,0x1d000000,0x11000000,0x0
 };
 
-static const QRgb lineedit4inside_data[] = {
+static const TQRgb lineedit4inside_data[] = {
     0x0,0x0,0x59ffffff,0xbfffffff,0xbfffffff,0x59ffffff,0x0,0x0,0x0,0x8cffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,
     0x8cffffff,0x0,0x59ffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x59ffffff,0xbfffffff,0xffffffff,0xffffffff,0xffffffff,
     0xffffffff,0xffffffff,0xffffffff,0xbfffffff,0xbfffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xbfffffff,0x59ffffff,0xffffffff,
@@ -469,25 +469,25 @@ static const QRgb lineedit4inside_data[] = {
     0x0,0x0,0x59ffffff,0xbfffffff,0xbfffffff,0x59ffffff,0x0,0x0
 };
 
-static const QRgb lineEditBtnEdges_d_data[] = {
+static const TQRgb lineEditBtnEdges_d_data[] = {
     0x0,0x66ededed,0xbeededed,0xbeededed,0x66ededed,0x0,0x66ededed,0xf1ededed,0xffededed,0xffededed,0xf1ededed,0x66ededed,0xbeededed,0xffededed,
     0xffededed,0xffededed,0xffededed,0xbeededed,0xbeededed,0xffededed,0xffededed,0xffededed,0xffededed,0xbeededed,0x66ededed,0xf1ededed,0xffededed,0xffededed,
     0xf1ededed,0x66ededed,0x0,0x66ededed,0xbeededed,0xbeededed,0x66ededed,0x0
 };
 
-static const QRgb lineEditBtnEdges_data[] = {
+static const TQRgb lineEditBtnEdges_data[] = {
     0x0,0x2fededed,0xafededed,0xafededed,0x2fededed,0x0,0x2fededed,0xefededed,0xffededed,0xffededed,0xefededed,0x2fededed,0xafededed,0xffededed,
     0xffededed,0xffededed,0xffededed,0xafededed,0xafededed,0xffededed,0xffededed,0xffededed,0xffededed,0xafededed,0x2fededed,0xefededed,0xffededed,0xffededed,
     0xefededed,0x2fededed,0x0,0x2fededed,0xafededed,0xafededed,0x2fededed,0x0
 };
 
-static const QRgb lineEditBtnShadow_data[] = {
+static const TQRgb lineEditBtnShadow_data[] = {
     0x0,0x1d000000,0x25000000,0x25000000,0x1d000000,0x0,0x1d000000,0x2b000000,0x1e000000,0x1e000000,0x2b000000,0x1d000000,0x18000000,0x16000000,
     0xc000000,0xc000000,0x16000000,0x18000000,0x13000000,0xa000000,0x2000000,0x2000000,0xa000000,0x13000000,0x1a000000,0xf000000,0x6000000,0x6000000,
     0xf000000,0x1a000000,0x0,0x19000000,0xb000000,0xb000000,0x19000000,0x0
 };
 
-static const QRgb lveTriangular_data[] = {
+static const TQRgb lveTriangular_data[] = {
     0x4c000000,0xb000000,0x0,0x0,0x0,0x0,0x0,0x7c000000,0x77000000,0x31000000,0x0,0x0,0x0,0x0,
     0x7c000000,0x7f000000,0x7f000000,0x60000000,0xd000000,0x0,0x0,0x7c000000,0x7f000000,0x7f000000,0x7f000000,0x7d000000,0x41000000,0x1000000,
     0x7c000000,0x7f000000,0x7f000000,0x7f000000,0x7f000000,0x7f000000,0x49000000,0x7c000000,0x7f000000,0x7f000000,0x7f000000,0x7d000000,0x41000000,0x1000000,
@@ -495,13 +495,13 @@ static const QRgb lveTriangular_data[] = {
     0x4c000000,0xb000000,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb menuItem_data[] = {
+static const TQRgb menuItem_data[] = {
     0x0,0x42000000,0xb3000000,0xc5000000,0x5c000000,0x3000000,0x36000000,0xff000000,0xff000000,0xff000000,0xff000000,0x62000000,0xa0000000,0xff000000,
     0xff000000,0xff000000,0xff000000,0xcc000000,0x92000000,0xff000000,0xff000000,0xff000000,0xff000000,0xbe000000,0x28000000,0xff000000,0xff000000,0xff000000,
     0xff000000,0x52000000,0x0,0x24000000,0x92000000,0xa4000000,0x3b000000,0x0
 };
 
-static const QRgb popup5_data[] = {
+static const TQRgb popup5_data[] = {
     0x0,0x0,0x3a575757,0xaf575757,0xfa575757,0xfa575757,0xaf575757,0x3a575757,0x0,0x0,0x0,0x5a575757,0xec575757,0x53575757,
     0x4575757,0x4575757,0x53575757,0xec575757,0x5a575757,0x0,0x22575757,0xeb575757,0x1c575757,0x0,0x0,0x0,0x0,0x1c575757,
     0xeb575757,0x22575757,0x9c575757,0x74575757,0x0,0x0,0x0,0x0,0x0,0x0,0x74575757,0x9c575757,0xd1575757,0x2c575757,
@@ -512,12 +512,12 @@ static const QRgb popup5_data[] = {
     0x0,0x0
 };
 
-static const QRgb progressShadow2_data[] = {
+static const TQRgb progressShadow2_data[] = {
     0xc6000000,0xb2000000,0xb2000000,0xc6000000,0x8d000000,0x65000000,0x65000000,0x8d000000,0x65000000,0x2f000000,0x2f000000,0x65000000,0x65000000,0x2e000000,
     0x2e000000,0x64000000
 };
 
-static const QRgb progressTile_data[] = {
+static const TQRgb progressTile_data[] = {
     0x6000000,0xa000000,0x10000000,0x16000000,0x1b000000,0x20000000,0x23000000,0x25000000,0x27000000,0x27000000,0x27000000,0x23000000,0x1f000000,0x19000000,
     0x12000000,0xc000000,0x7000000,0x3000000,0x2000000,0x3000000,0x3000000,0x6000000,0xa000000,0x10000000,0x16000000,0x1b000000,0x20000000,0x23000000,
     0x25000000,0x27000000,0x27000000,0x27000000,0x23000000,0x1f000000,0x19000000,0x12000000,0xc000000,0x7000000,0x3000000,0x2000000,0x2000000,0x3000000,
@@ -549,7 +549,7 @@ static const QRgb progressTile_data[] = {
     0x19000000,0x12000000,0xc000000,0x7000000,0x3000000,0x2000000,0x3000000,0x6000000
 };
 
-static const QRgb radio3circle_data[] = {
+static const TQRgb radio3circle_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x8000000,0xd000000,0xd000000,0xd000000,0x8000000,
     0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x9000000,0x38000000,0xa4000000,0xb9000000,
@@ -573,7 +573,7 @@ static const QRgb radio3circle_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb radio3inside_data[] = {
+static const TQRgb radio3inside_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff,0xffffff,0xffffff,0xffffff,0x8ffffff,0x26ffffff,
@@ -597,7 +597,7 @@ static const QRgb radio3inside_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb radio3pressed_data[] = {
+static const TQRgb radio3pressed_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
@@ -621,7 +621,7 @@ static const QRgb radio3pressed_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb radio3shadow_data[] = {
+static const TQRgb radio3shadow_data[] = {
     0x0,0x0,0x0,0x0,0x1000000,0x3000000,0x7000000,0xa000000,0xc000000,0xa000000,0x7000000,0x3000000,0x1000000,0x0,
     0x0,0x0,0x0,0xffffff,0xffffff,0xffffff,0x2000000,0x8000000,0x10000000,0x1b090909,0x24151515,0x26141414,0x24151515,0x1b090909,
     0x11000000,0x8000000,0x2000000,0xffffff,0xffffff,0xffffff,0xffffff,0xffffff,0x2000000,0xa000000,0x1b1c1c1c,0x2e2c2c2c,0xdffffff,0xbffffff,
@@ -645,17 +645,17 @@ static const QRgb radio3shadow_data[] = {
     0x21ffffff,0x1dffffff,0x14ffffff,0xaffffff,0x3ffffff,0xffffff,0xffffff,0xffffff,0xffffff
 };
 
-static const QRgb rb_dot2_data[] = {
+static const TQRgb rb_dot2_data[] = {
     0x221d1d1d,0x9f060606,0xcc010101,0x9f060606,0x221d1d1d,0xa2121212,0xd2010101,0xd2000000,0xd2010101,0xa2121212,0xd11f1f1f,0xd3060606,0xd2000000,0xd3060606,
     0xd11f1f1f,0xac393939,0xd71e1e1e,0xd5121212,0xd71e1e1e,0xac393939,0x27404040,0xaf424242,0xd8434343,0xaf424242,0x27404040
 };
 
-static const QRgb rb_dot2_shadow_data[] = {
+static const TQRgb rb_dot2_shadow_data[] = {
     0x4fefefe,0x4ffffff,0x1ffffff,0x4ffffff,0x4fcfcfc,0xcfafafa,0x1ffffff,0x0,0x1ffffff,0xcfafafa,0x1afcfcfc,0x5ffffff,0x1bfbfbf,0x5ffffff,
     0x1afcfcfc,0x27fdfdfd,0x1afcfcfc,0x10fafafa,0x1afcfcfc,0x27fdfdfd,0xafdfdfd,0x2efdfdfd,0x3afdfdfd,0x2efdfdfd,0xafdfdfd
 };
 
-static const QRgb scroll2BtnHContour2_data[] = {
+static const TQRgb scroll2BtnHContour2_data[] = {
     0xff000000,0xff000000,0xff000000,0xff000000,0xd5000000,0x78000000,0x40000000,0x11000000,0x0,0x0,0x11000000,0x40000000,0x78000000,0xd5000000,
     0xff000000,0xff000000,0xff000000,0xff000000,0x23000000,0x23000000,0x331b1b1b,0x30000000,0x95000000,0x2c000000,0x1000000,0x0,0x0,0x0,
     0x0,0x1000000,0x2c000000,0x95000000,0x30000000,0x331b1b1b,0x23000000,0x23000000,0x0,0xe000000,0x36000000,0xaa000000,0x2f000000,0x0,
@@ -678,7 +678,7 @@ static const QRgb scroll2BtnHContour2_data[] = {
     0xff000000,0xff000000,0xff000000,0xff000000
 };
 
-static const QRgb scroll2BtnHMask_data[] = {
+static const TQRgb scroll2BtnHMask_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xb4ff0000,0x25ff0000,0x0,0x0,0x0,0x0,
     0x0,0x0,0x25ff0000,0xb4ff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0x8dff0000,0x1ff0000,0x0,
@@ -701,7 +701,7 @@ static const QRgb scroll2BtnHMask_data[] = {
     0x0,0x0,0x0,0x0
 };
 
-static const QRgb scroll2BtnHShadow2_data[] = {
+static const TQRgb scroll2BtnHShadow2_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x13000000,0x12000000,0x7000000,0x7000000,0x12000000,0x13000000,0x0,0x0,
     0x0,0x0,0x0,0x0,0x17ffffff,0x17ffffff,0x12ffffff,0x19ffffff,0x16171717,0x24000000,0x17000000,0x7000000,0x2000000,0x2000000,
     0x7000000,0x17000000,0x24000000,0x16171717,0x19ffffff,0x12ffffff,0x17ffffff,0x17ffffff,0x0,0xcffffff,0x19ffffff,0x170b0b0b,0x21000000,0x11000000,
@@ -724,7 +724,7 @@ static const QRgb scroll2BtnHShadow2_data[] = {
     0x0,0x0,0x0,0x0
 };
 
-static const QRgb scroll2BtnVContour2_data[] = {
+static const TQRgb scroll2BtnVContour2_data[] = {
     0xff000000,0x23000000,0x0,0x2000000,0x11000000,0x1d000000,0x23000000,0x28000000,0x23000000,0x1d000000,0x11000000,0x2000000,0x0,0x23000000,
     0xff000000,0xff000000,0x23000000,0xe000000,0x25000000,0x55000000,0x8e000000,0xaf000000,0xb0000000,0xaf000000,0x8e000000,0x55000000,0x25000000,0xe000000,
     0x23000000,0xff000000,0xff000000,0x331b1b1b,0x36000000,0xa1000000,0x7c000000,0x28000000,0x1000000,0x0,0x1000000,0x28000000,0x7c000000,0xa1000000,
@@ -747,7 +747,7 @@ static const QRgb scroll2BtnVContour2_data[] = {
     0x2000000,0x0,0x23000000,0xff000000
 };
 
-static const QRgb scroll2BtnVMask_data[] = {
+static const TQRgb scroll2BtnVMask_data[] = {
     0x0,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,
     0x0,0x0,0xffff0000,0xffff0000,0xffff0000,0xfcff0000,0xbfff0000,0x88ff0000,0x76ff0000,0x88ff0000,0xbfff0000,0xfcff0000,0xffff0000,0xffff0000,
     0xffff0000,0x0,0x0,0xffff0000,0xffff0000,0xb4ff0000,0x24ff0000,0x0,0x0,0x0,0x0,0x0,0x24ff0000,0xb4ff0000,
@@ -770,7 +770,7 @@ static const QRgb scroll2BtnVMask_data[] = {
     0xffff0000,0xffff0000,0xffff0000,0x0
 };
 
-static const QRgb scroll2BtnVShadow2_data[] = {
+static const TQRgb scroll2BtnVShadow2_data[] = {
     0x0,0x17ffffff,0x0,0x5ffffff,0xeffffff,0x17ffffff,0x1bffffff,0x1cffffff,0x1bffffff,0x17ffffff,0xeffffff,0x5ffffff,0x0,0x17ffffff,
     0x0,0x0,0x17ffffff,0xcffffff,0x1bffffff,0x18ffffff,0x186a6a6a,0x1a000000,0x1e000000,0x1a000000,0x19666666,0x18ffffff,0x1bffffff,0xcffffff,
     0x17ffffff,0x0,0x0,0x12ffffff,0x19ffffff,0x112d2d2d,0x24000000,0x20000000,0x19000000,0x17000000,0x19000000,0x20000000,0x24000000,0x122a2a2a,
@@ -793,7 +793,7 @@ static const QRgb scroll2BtnVShadow2_data[] = {
     0x5ffffff,0x0,0x17ffffff,0x0
 };
 
-static const QRgb scroll2SliderHContour_data[] = {
+static const TQRgb scroll2SliderHContour_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x64000000,0x8f000000,0x8f000000,0x64000000,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x18000000,0x9b000000,0x7c000000,0x3e000000,0x3e000000,0x7c000000,0x9b000000,0x18000000,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1c000000,0xb2000000,0x44000000,0x1c000000,0xa000000,0xa000000,0x1c000000,
@@ -814,7 +814,7 @@ static const QRgb scroll2SliderHContour_data[] = {
     0x0,0x0
 };
 
-static const QRgb scroll2SliderHDockedContour_data[] = {
+static const TQRgb scroll2SliderHDockedContour_data[] = {
     0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,0xff000000,
     0xff000000,0xff000000,0x23000000,0x23000000,0x23000000,0x2b000000,0x44121212,0x9c000000,0x7c000000,0x3e000000,0x3e000000,0x7c000000,0x9c000000,0x44121212,
     0x2b000000,0x23000000,0x23000000,0x23000000,0x0,0x0,0xe000000,0x2f000000,0xb2000000,0x71000000,0x1c000000,0xa000000,0xa000000,0x1c000000,
@@ -835,7 +835,7 @@ static const QRgb scroll2SliderHDockedContour_data[] = {
     0xff000000,0xff000000
 };
 
-static const QRgb scroll2SliderHDockedShadow_data[] = {
+static const TQRgb scroll2SliderHDockedShadow_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x17ffffff,0x17ffffff,0x17ffffff,0x17ffffff,0x11ffffff,0x16ffffff,0xbffffff,0x13ffffff,0x13ffffff,0xbffffff,0x16ffffff,0x11ffffff,
     0x17ffffff,0x17ffffff,0x17ffffff,0x17ffffff,0x0,0x0,0xaffffff,0x19ffffff,0x18ffffff,0x17ffffff,0x15ffffff,0x7ffffff,0x7ffffff,0x15ffffff,
@@ -856,7 +856,7 @@ static const QRgb scroll2SliderHDockedShadow_data[] = {
     0x0,0x0
 };
 
-static const QRgb scroll2SliderHMask_data[] = {
+static const TQRgb scroll2SliderHMask_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4bff0000,0xdaff0000,0xffff0000,0xffff0000,0xdaff0000,0x4bff0000,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x72ff0000,0xfeff0000,0xffff0000,0xffff0000,0xffff0000,0xffff0000,
@@ -877,7 +877,7 @@ static const QRgb scroll2SliderHMask_data[] = {
     0x0,0x0
 };
 
-static const QRgb scroll2SliderHShadow2_data[] = {
+static const TQRgb scroll2SliderHShadow2_data[] = {
     0x0,0x0,0x0,0x3000000,0xa000000,0x15000000,0x1f000000,0x17000000,0x17000000,0x1f000000,0x15000000,0xa000000,0x3000000,0x0,
     0x0,0x0,0x0,0x0,0x3000000,0xb000000,0x1a000000,0x1a000000,0xce9e9e9,0x13ffffff,0x13ffffff,0xce9e9e9,0x1a000000,0x1a000000,
     0xb000000,0x3000000,0x0,0x0,0x0,0x2000000,0xa000000,0x1a000000,0x1b000000,0x10ffffff,0x15ffffff,0x7ffffff,0x7ffffff,0x15ffffff,
@@ -898,7 +898,7 @@ static const QRgb scroll2SliderHShadow2_data[] = {
     0x0,0x0
 };
 
-static const QRgb scroll2SliderVContour_data[] = {
+static const TQRgb scroll2SliderVContour_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x2000000,0x4a000000,0x98000000,0xb8000000,0xb9000000,0xb8000000,0x91000000,0x56000000,0x2000000,
@@ -919,7 +919,7 @@ static const QRgb scroll2SliderVContour_data[] = {
     0x0,0x0
 };
 
-static const QRgb scroll2SliderVDockedContour_data[] = {
+static const TQRgb scroll2SliderVDockedContour_data[] = {
     0xff000000,0x23000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x23000000,
     0xff000000,0xff000000,0x23000000,0x0,0x2000000,0x11000000,0x1d000000,0x23000000,0x23000000,0x23000000,0x1d000000,0x11000000,0x2000000,0x0,
     0x23000000,0xff000000,0xff000000,0x23000000,0xe000000,0x25000000,0x63000000,0x94000000,0xb8000000,0xb9000000,0xb8000000,0x94000000,0x63000000,0x25000000,
@@ -940,7 +940,7 @@ static const QRgb scroll2SliderVDockedContour_data[] = {
     0x23000000,0xff000000
 };
 
-static const QRgb scroll2SliderVDockedShadow_data[] = {
+static const TQRgb scroll2SliderVDockedShadow_data[] = {
     0x0,0x17ffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x17ffffff,
     0x0,0x0,0x17ffffff,0x0,0x5ffffff,0xdffffff,0x16ffffff,0x1effffff,0x1effffff,0x1effffff,0x16ffffff,0xdffffff,0x5ffffff,0x0,
     0x17ffffff,0x0,0x0,0x17ffffff,0xaffffff,0x19ffffff,0x1effffff,0x9ffffff,0x0,0x0,0x0,0x9ffffff,0x1effffff,0x19ffffff,
@@ -961,7 +961,7 @@ static const QRgb scroll2SliderVDockedShadow_data[] = {
     0x17ffffff,0x0
 };
 
-static const QRgb scroll2SliderVMask_data[] = {
+static const TQRgb scroll2SliderVMask_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0x0,0x0,0x3ff0000,0x40ff0000,0x77ff0000,0x89ff0000,0x77ff0000,0x40ff0000,0x3ff0000,0x0,
@@ -982,7 +982,7 @@ static const QRgb scroll2SliderVMask_data[] = {
     0x0,0x0
 };
 
-static const QRgb scroll2SliderVShadow2_data[] = {
+static const TQRgb scroll2SliderVShadow2_data[] = {
     0x0,0x0,0x0,0x1000000,0x2000000,0x4000000,0x5000000,0x6000000,0x5000000,0x4000000,0x2000000,0x1000000,0x0,0x0,
     0x0,0x0,0x0,0x2000000,0x6000000,0xc000000,0x12000000,0x16000000,0x16000000,0x16000000,0x12000000,0xc000000,0x6000000,0x2000000,
     0x0,0x0,0x0,0x3000000,0xa000000,0x16000000,0x20000000,0x15000000,0x16000000,0x16000000,0x16000000,0x15000000,0x20000000,0x16000000,
@@ -1003,7 +1003,7 @@ static const QRgb scroll2SliderVShadow2_data[] = {
     0x0,0x0
 };
 
-static const QRgb scrollBarArrows_data[] = {
+static const TQRgb scrollBarArrows_data[] = {
     0x0,0x0,0x0,0x23000000,0xa2000000,0xa2000000,0x23000000,0x0,0x0,0x0,0x0,0x0,0x4000000,0x77000000,
     0x4000000,0x0,0x0,0xa2000000,0xe5000000,0xeb000000,0xef000000,0xeb000000,0xe5000000,0xa2000000,0x0,0x0,0x42000000,0xbb000000,
     0xe5000000,0xe5000000,0xbb000000,0x42000000,0x0,0x0,0x0,0x0,0x7b000000,0xf5000000,0x7b000000,0x0,0x0,0x2a000000,
@@ -1018,29 +1018,29 @@ static const QRgb scrollBarArrows_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb sizeGrip_data[] = {
+static const TQRgb sizeGrip_data[] = {
     0x33bebebe,0x78bbbbbb,0x6bababab,0x278f8f8f,0x5e9d9d9d,0x6e9b9b9b,0x678a8a8a,0x4e6b6b6b,0x4b6c6c6c,0x576c6c6c,0x53595959,0x41363636,0x19282828,0x3a1e1e1e,
     0x390d0d0d,0x18000000
 };
 
-static const QRgb sliderGrooveHBody_data[] = {
+static const TQRgb sliderGrooveHBody_data[] = {
     0xb000000,0xb000000,0xb000000,0xb000000,0x9b353535,0x9b353535,0x9b353535,0x9b353535,0x92434343,0x92434343,0x92434343,0x92434343,0x8c535353,0x8c535353,
     0x8c535353,0x8c535353,0x86656565,0x86656565,0x86656565,0x86656565,0x2bfefefe,0x2bfefefe,0x2bfefefe,0x2bfefefe,0x9ffffff,0x9ffffff,0x9ffffff,0x9ffffff
 };
 
-static const QRgb sliderGroove_h_data[] = {
+static const TQRgb sliderGroove_h_data[] = {
     0x1000000,0x5000000,0x9000000,0x9000000,0x5000000,0x1000000,0x2000000,0x41353535,0x89353535,0x89353535,0x41353535,0x2000000,0x5999999,0x83444444,
     0x92434343,0x92434343,0x83444444,0x5999999,0x8dfdfdf,0x7f575757,0x8c535353,0x8c535353,0x7f575757,0x8dfdfdf,0x7ffffff,0x488e8e8e,0x7c6c6c6c,0x7c6c6c6c,
     0x488e8e8e,0x7ffffff,0x3ffffff,0x14fcfcfc,0x25ffffff,0x25ffffff,0x14fcfcfc,0x3ffffff,0x0,0x3ffffff,0x7ffffff,0x7ffffff,0x3ffffff,0x0
 };
 
-static const QRgb sliderGroove_v_data[] = {
+static const TQRgb sliderGroove_v_data[] = {
     0x1000000,0x2000000,0x5999999,0x8dfdfdf,0x7ffffff,0x3ffffff,0x0,0x5000000,0x41353535,0x83444444,0x7f575757,0x488e8e8e,0x14fcfcfc,0x3ffffff,
     0x9000000,0x89353535,0x92434343,0x8c535353,0x7c6c6c6c,0x25ffffff,0x7ffffff,0x9000000,0x89353535,0x92434343,0x8c535353,0x7c6c6c6c,0x25ffffff,0x7ffffff,
     0x5000000,0x41353535,0x83444444,0x7f575757,0x488e8e8e,0x14fcfcfc,0x3ffffff,0x1000000,0x2000000,0x5999999,0x8dfdfdf,0x7ffffff,0x3ffffff,0x0
 };
 
-static const QRgb sliderHandle2inside2_data[] = {
+static const TQRgb sliderHandle2inside2_data[] = {
     0x0,0x0,0x0,0x0,0x0,0xfffffff,0x39ffffff,0x51ffffff,0x39ffffff,0xfffffff,0x0,0x0,0x0,0x0,
     0x0,0x0,0xffffff,0xffffff,0x4ffffff,0x71ffffff,0xf4ffffff,0xffffffff,0xffffffff,0xffffffff,0xf3ffffff,0x6fffffff,0x3ffffff,0xffffff,
     0x0,0x0,0x0,0xffffff,0x4ffffff,0xabffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0xabffffff,
@@ -1060,7 +1060,7 @@ static const QRgb sliderHandle2inside2_data[] = {
     0x0
 };
 
-static const QRgb sliderHandle2circle_data[] = {
+static const TQRgb sliderHandle2circle_data[] = {
 	0x0,0x0,0x0,0x0,0x1e8b8b8b,0x815e5e5e,0x95595959,0x995d5d5d,0x95595959,0x815e5e5e,0x1e8b8b8b,0x0,0x0,0x0,
 	0x0,0x0,0x0,0x0,0x6c5e5e5e,0x92585858,0x336e6e6e,0x0,0x0,0x0,0x336e6e6e,0x92585858,0x6c5e5e5e,0x0,
 	0x0,0x0,0x0,0x0,0x6f595959,0x75595959,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x75595959,
@@ -1080,7 +1080,7 @@ static const QRgb sliderHandle2circle_data[] = {
 	0x0
 };
 
-static const QRgb sliderHandle2shadow_data[] = {
+static const TQRgb sliderHandle2shadow_data[] = {
     0x0,0x0,0x1000000,0x3000000,0x5000000,0x4000000,0x2000000,0x5d5d5d,0x2000000,0x4000000,0x5000000,0x3000000,0x1000000,0x0,
     0x0,0x0,0x1000000,0x4000000,0x5000000,0xefefefe,0x32fefefe,0x45fefefe,0x4cfefefe,0x45fefefe,0x32fefefe,0xefefefe,0x5000000,0x4000000,
     0x1000000,0x0,0x1000000,0x4000000,0x6000000,0x17fefefe,0x3bfefefe,0x35fefefe,0x30fefefe,0x2efefefe,0x30fefefe,0x35fefefe,0x3bfefefe,0x17fefefe,
@@ -1100,7 +1100,7 @@ static const QRgb sliderHandle2shadow_data[] = {
     0x0
 };
 
-static const QRgb spinBoxArrows_data[] = {
+static const TQRgb spinBoxArrows_data[] = {
     0x0,0x0,0x0,0xd000000,0x0,0x0,0x0,0x0,0x0,0x24000000,0xa5000000,0x24000000,0x0,0x0,
     0x0,0x19000000,0xb5000000,0xff000000,0xb5000000,0x19000000,0x0,0x18000000,0x99000000,0xff000000,0xff000000,0xff000000,0x99000000,0x12000000,
     0x79000000,0xca000000,0xcc000000,0xd7000000,0xcc000000,0xca000000,0x78000000,0x79000000,0xca000000,0xcc000000,0xd7000000,0xcc000000,0xca000000,0x78000000,
@@ -1108,16 +1108,16 @@ static const QRgb spinBoxArrows_data[] = {
     0x0,0x0,0x24000000,0xa5000000,0x24000000,0x0,0x0,0x0,0x0,0x0,0xd000000,0x0,0x0,0x0
 };
 
-static const QRgb tabHLines_data[] = {
+static const TQRgb tabHLines_data[] = {
     0x4effffff,0x4effffff,0x4effffff,0x4effffff,0x1effffff,0x1effffff,0x1effffff,0x1effffff,0x19f9f9f9,0x19f9f9f9,0x19f9f9f9,0x19f9f9f9
 };
 
-static const QRgb tabInsideWhiteLines_data[] = {
+static const TQRgb tabInsideWhiteLines_data[] = {
     0x19ffffff,0x19ffffff,0x19ffffff,0x19ffffff,0x19ffffff,0x0,0x0,0x0,0x19ffffff,0x0,0x0,0x0,0x19ffffff,0x0,
     0x0,0x0
 };
 
-static const QRgb tabInsideWhite_data[] = {
+static const TQRgb tabInsideWhite_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
     0x0,0x0,0x0,0x0,0xaffffff,0x13ffffff,0x18ffffff,0x18ffffff,0x13ffffff,0xaffffff,0x0,0x0,0x0,0x0,
     0x0,0x0,0x3ffffff,0x17ffffff,0x14ffffff,0x9ffffff,0x3ffffff,0x3ffffff,0x9ffffff,0x14ffffff,0x17ffffff,0x3ffffff,0x0,0x0,
@@ -1134,11 +1134,11 @@ static const QRgb tabInsideWhite_data[] = {
     0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0
 };
 
-static const QRgb tabVlines_data[] = {
+static const TQRgb tabVlines_data[] = {
     0x1effffff,0x1effffff,0x1effffff,0x1effffff
 };
 
-static const QRgb tabWidget_data[] = {
+static const TQRgb tabWidget_data[] = {
     0x0,0x0,0x0,0x0,0x3000000,0xb000000,0x13000000,0x17000000,0x17000000,0x13000000,0xb000000,0x3000000,0x0,0x0,
     0x0,0x0,0x0,0x0,0x1000000,0xb000000,0x27474747,0x46b2b2b2,0x4ededede,0x48ffffff,0x48ffffff,0x4ededede,0x46b2b2b2,0x27474747,
     0xb000000,0x1000000,0x0,0x0,0x0,0x1000000,0xf000000,0x408f8f8f,0x44f7f7f7,0x37ffffff,0x29ffffff,0x21ffffff,0x20ffffff,0x28ffffff,
@@ -1160,7 +1160,7 @@ static const QRgb tabWidget_data[] = {
     0x3000000,0x0,0x0,0x0
 };
 
-static const QRgb tooltipframe2_data[] = {
+static const TQRgb tooltipframe2_data[] = {
     0x0,0x0,0x0,0xa575757,0x50575757,0x98575757,0xcc575757,0xcc575757,0x98575757,0x50575757,0xa575757,0x0,0x0,0x0,
     0x0,0x0,0x27575757,0xd3575757,0x99575757,0x56575757,0x1c575757,0x1c575757,0x56575757,0x99575757,0xd3575757,0x27575757,0x0,0x0,
     0x0,0x2d575757,0xe9575757,0x47575757,0x0,0x0,0x0,0x0,0x0,0x0,0x47575757,0xe9575757,0x2d575757,0x0,
@@ -1177,7 +1177,7 @@ static const QRgb tooltipframe2_data[] = {
     0x0,0x0,0x0,0xf575757,0x5d575757,0xa5575757,0xd9575757,0xd9575757,0xa5575757,0x5d575757,0xf575757,0x0,0x0,0x0
 };
 
-static const QRgb toolBtnFrameThin_data[] = {
+static const TQRgb toolBtnFrameThin_data[] = {
 	0x0,0x12000000,0x4e000000,0x9d000000,0x9d000000,0x4e000000,0x12000000,0x0,0xd000000,0x81000000,0x6d000000,0x19000000,0x19000000,0x6d000000,
 	0x81000000,0xd000000,0x4a000000,0x66000000,0x0,0x0,0x0,0x0,0x66000000,0x4a000000,0x9c000000,0x19000000,0x0,0x0,
 	0x0,0x0,0x19000000,0x9c000000,0x9c000000,0x19000000,0x0,0x0,0x0,0x0,0x19000000,0x9c000000,0x4a000000,0x66000000,
@@ -1190,7 +1190,7 @@ static struct EmbedImage {
 	int width, height, depth;
 	const unsigned char *data;
 	int numColors;
-	const QRgb *colorTable;
+	const TQRgb *colorTable;
 	bool alpha;
 	const char *name;
 	} embed_image_vec[] = {
@@ -1275,20 +1275,20 @@ static struct EmbedImage {
 		{ 0, 0, 0, 0, 0, 0, 0, 0 }
 };
 
-static const QImage& qembed_findImage( const QString& name )
+static const TQImage& qembed_findImage( const TQString& name )
 {
-    static QDict<QImage> dict;
-    QImage* img = dict.find( name );
+    static TQDict<TQImage> dict;
+    TQImage* img = dict.find( name );
     if ( !img ) {
 	for ( int i = 0; embed_image_vec[i].data; i++ ) {
 	    if ( strcmp(embed_image_vec[i].name, name.latin1()) == 0 ) {
-		img = new QImage((uchar*)embed_image_vec[i].data,
+		img = new TQImage((uchar*)embed_image_vec[i].data,
 			    embed_image_vec[i].width,
 			    embed_image_vec[i].height,
 			    embed_image_vec[i].depth,
-			    (QRgb*)embed_image_vec[i].colorTable,
+			    (TQRgb*)embed_image_vec[i].colorTable,
 			    embed_image_vec[i].numColors,
-			    QImage::BigEndian );
+			    TQImage::BigEndian );
 		if ( embed_image_vec[i].alpha )
 		    img->setAlphaBuffer( TRUE );
 		dict.insert( name, img );
@@ -1296,7 +1296,7 @@ static const QImage& qembed_findImage( const QString& name )
 	    }
 	}
 	if ( !img ) {
-	    static QImage dummy;
+	    static TQImage dummy;
 	    return dummy;
 	}
     }
diff --git a/domino/domino.cpp b/domino/domino.cpp
index 09645d1..fa78200 100644
--- a/domino/domino.cpp
+++ b/domino/domino.cpp
@@ -40,44 +40,44 @@
 
 
 #include <kglobalsettings.h>
-#include <qpainter.h>
-#include <qtabbar.h>
-#include <qprogressbar.h>
-#include <qcheckbox.h>
-#include <qlineedit.h>
-#include <qlistbox.h>
-#include <qstyleplugin.h>
-#include <qpushbutton.h>
-#include <qtoolbutton.h>
+#include <tqpainter.h>
+#include <tqtabbar.h>
+#include <tqprogressbar.h>
+#include <tqcheckbox.h>
+#include <tqlineedit.h>
+#include <tqlistbox.h>
+#include <tqstyleplugin.h>
+#include <tqpushbutton.h>
+#include <tqtoolbutton.h>
 #include <kpopupmenu.h>
-#include <qradiobutton.h>
-#include <qslider.h>
-#include <qsettings.h>
+#include <tqradiobutton.h>
+#include <tqslider.h>
+#include <tqsettings.h>
 #include <kpixmap.h>
-#include <qgroupbox.h>
-#include <qmenudata.h>
-#include <qdockarea.h>
-#include <qobjectlist.h>
-#include <qheader.h>
+#include <tqgroupbox.h>
+#include <tqmenudata.h>
+#include <tqdockarea.h>
+#include <tqobjectlist.h>
+#include <tqheader.h>
 #include <klistview.h>
-#include <qstatusbar.h>
-#include <qcombobox.h>
-#include <qtabwidget.h>
+#include <tqstatusbar.h>
+#include <tqcombobox.h>
+#include <tqtabwidget.h>
 #include <ktoolbar.h>
-#include <qlabel.h>
-#include <qsimplerichtext.h>
-#include <qiconview.h>
+#include <tqlabel.h>
+#include <tqsimplerichtext.h>
+#include <tqiconview.h>
 #include <kconfig.h>
-#include <qapplication.h>
-#include <qtoolbox.h>
-#include <qstylesheet.h>
-// #include <qsplitter.h>
-#include <qwidgetstack.h>
-#include <qtimer.h>
+#include <tqapplication.h>
+#include <tqtoolbox.h>
+#include <tqstylesheet.h>
+// #include <tqsplitter.h>
+#include <tqwidgetstack.h>
+#include <tqtimer.h>
 #include <kmultitabbar.h>
-#include <qspinbox.h>
-#include <qcursor.h>
-#include <qtextedit.h>
+#include <tqspinbox.h>
+#include <tqcursor.h>
+#include <tqtextedit.h>
 #include <kdeversion.h>
 #include <kimageeffect.h>
 
@@ -114,24 +114,24 @@ ButtonContour::ButtonContour()
 	ContourType ty;
 	ty = Contour_Sunken;
 	for(int s = 0; s < num_states; s++) {
-		c1[ty][s] = qRgba(31, 31, 31, 32);  // top first shadow line
-		c4[ty][s] = qRgba(255, 255, 255, 78); // bottom first shadow line
-		c5[ty][s] = qRgba(255, 255, 255, 30); // bottom second shadow line
-		c6[ty][s] = qRgba(217, 217, 217, 34); // first left shadow line
+		c1[ty][s] = tqRgba(31, 31, 31, 32);  // top first shadow line
+		c4[ty][s] = tqRgba(255, 255, 255, 78); // bottom first shadow line
+		c5[ty][s] = tqRgba(255, 255, 255, 30); // bottom second shadow line
+		c6[ty][s] = tqRgba(217, 217, 217, 34); // first left shadow line
 	}
 	ty = Contour_Raised;
 	for(int s = 0; s < num_states; s++) {
-		c1[ty][s] = qRgba(0, 0, 0, 14);  // top first shadow line
-		c4[ty][s] = qRgba(0, 0, 0, 26); // bottom first shadow line
-		c5[ty][s] = qRgba(0, 0, 0, 10); // bottom second shadow line
-		c6[ty][s] = qRgba(0, 0, 0, 12); // first left shadow line
+		c1[ty][s] = tqRgba(0, 0, 0, 14);  // top first shadow line
+		c4[ty][s] = tqRgba(0, 0, 0, 26); // bottom first shadow line
+		c5[ty][s] = tqRgba(0, 0, 0, 10); // bottom second shadow line
+		c6[ty][s] = tqRgba(0, 0, 0, 12); // first left shadow line
 	}
 	ty = Contour_Simple;
 	for(int s = 0; s < num_states; s++) {
-		c1[ty][s] = qRgba(0, 0, 0, 0);  // top first shadow line
-		c4[ty][s] = qRgba(0, 0, 0, 0); // bottom first shadow line
-		c5[ty][s] = qRgba(0, 0, 0, 0); // bottom second shadow line
-		c6[ty][s] = qRgba(0, 0, 0, 0); // first left shadow line
+		c1[ty][s] = tqRgba(0, 0, 0, 0);  // top first shadow line
+		c4[ty][s] = tqRgba(0, 0, 0, 0); // bottom first shadow line
+		c5[ty][s] = tqRgba(0, 0, 0, 0); // bottom second shadow line
+		c6[ty][s] = tqRgba(0, 0, 0, 0); // first left shadow line
 	}
 	drawButtonSunkenShadow = true;
 }
@@ -156,10 +156,10 @@ ButtonContour::~ButtonContour()
 }
 
 RubberWidget::RubberWidget(Window window )
-	: QWidget()
+	: TQWidget()
 {
 	setWState(WState_Disabled|WState_Polished);
-	QWidget::create( window, true, true);
+	TQWidget::create( window, true, true);
 }
 
 RubberWidget::~RubberWidget()
@@ -174,9 +174,9 @@ Rubber::Rubber(uint col)
 	rubber = 0;
 	parent = 0;
 	window = 0;
-	mask = QRegion();
-	Display *dpy = qt_xdisplay();
-	int screen = qt_xscreen();
+	mask = TQRegion();
+	Display *dpy = tqt_xdisplay();
+	int screen = tqt_xscreen();
 	visual = 0;
 	colormap = 0;
 	int event_base, error_base;
@@ -209,54 +209,54 @@ Rubber::Rubber(uint col)
 	color = col;
 }
 
-void Rubber::create(QRect& r, QRegion& m) {
+void Rubber::create(TQRect& r, TQRegion& m) {
 	if(parent)
 		return;
 	
 	mask = m;
 	
 	wsa.background_pixel = 0x00000000;
-	Window parentwin = XCreateWindow(qt_xdisplay(), qApp->desktop()->winId(), r.x(), r.y(), r.width(), r.height(), 0, 32, InputOutput, visual, CWBackPixel|CWColormap|CWBorderPixel|CWOverrideRedirect, &wsa);
+	Window parentwin = XCreateWindow(tqt_xdisplay(), tqApp->desktop()->winId(), r.x(), r.y(), r.width(), r.height(), 0, 32, InputOutput, visual, CWBackPixel|CWColormap|CWBorderPixel|CWOverrideRedirect, &wsa);
 	parent = new RubberWidget(parentwin);
 	
 	wsa.background_pixel = color;
-	window = XCreateWindow(qt_xdisplay(), parentwin, 0, 0, r.width(), r.height(), 0, 32, InputOutput, visual, CWBackPixel|CWColormap|CWBorderPixel|CWOverrideRedirect, &wsa);
+	window = XCreateWindow(tqt_xdisplay(), parentwin, 0, 0, r.width(), r.height(), 0, 32, InputOutput, visual, CWBackPixel|CWColormap|CWBorderPixel|CWOverrideRedirect, &wsa);
 	rubber = new RubberWidget(window);
 	
 #ifdef ShapeInput
-	QBitmap bm(r.width(), r.height(), true);
-	XShapeCombineMask(qt_xdisplay(), rubber->winId(), ShapeInput, 0, 0, bm.handle(), ShapeSet);
+	TQBitmap bm(r.width(), r.height(), true);
+	XShapeCombineMask(tqt_xdisplay(), rubber->winId(), ShapeInput, 0, 0, bm.handle(), ShapeSet);
 #endif
-	XShapeCombineRegion( qt_xdisplay(), rubber->winId(), ShapeBounding, 0, 0, mask.handle(), ShapeSet );
+	XShapeCombineRegion( tqt_xdisplay(), rubber->winId(), ShapeBounding, 0, 0, mask.handle(), ShapeSet );
 	
 	rubber->show();
 	parent->show();
 	
-	XFlush(qt_xdisplay());
+	XFlush(tqt_xdisplay());
 }
 
 Rubber::~Rubber()
 {
 }
 
-void Rubber::updateMask(QRegion& m) {
+void Rubber::updateMask(TQRegion& m) {
 	if(mask != m)
-		XShapeCombineRegion( qt_xdisplay(), rubber->winId(), ShapeBounding, 0, 0, m.handle(), ShapeSet );
+		XShapeCombineRegion( tqt_xdisplay(), rubber->winId(), ShapeBounding, 0, 0, m.handle(), ShapeSet );
 }
 
 
 // -- Style Plugin Interface -------------------------
-class DominoStylePlugin : public QStylePlugin
+class DominoStylePlugin : public TQStylePlugin
 {
 	public:
 		DominoStylePlugin() {}
 		~DominoStylePlugin() {}
 
-		QStringList keys() const {
-			return QStringList() << "Domino";
+		TQStringList keys() const {
+			return TQStringList() << "Domino";
 		}
 
-		QStyle* create( const QString& key ) {
+		TQStyle* create( const TQString& key ) {
 			if (key.lower() == "domino")
 				return new DominoStyle;
 			return 0;
@@ -273,7 +273,7 @@ KDE_Q_EXPORT_PLUGIN( DominoStylePlugin )
 	konquerorMode = false;
 	flatMode = false;
 	viewPortPressed = false;
-	oldRubberRect = QRect();
+	oldRubberRect = TQRect();
 	rubber = 0;
 	ignoreNextFocusRect = false;
 #if KDE_VERSION < 0x30506
@@ -282,13 +282,13 @@ KDE_Q_EXPORT_PLUGIN( DominoStylePlugin )
 	configMode = "0"; // temporaly to avoid cache problems between the configs previewStyle and this style
 	spinWidgetDown = false;
 	
-	popupTimer = new QTimer(this);
+	popupTimer = new TQTimer(this);
 	
-	QColor background = qApp->palette().active().background();
-	QColor buttonColor = qApp->palette().active().button();
-	QColor highlight = qApp->palette().active().highlight();
-	QSettings settings;
-// 	_contrast = settings.readNumEntry("/Qt/KDE/contrast", 0);
+	TQColor background = tqApp->palette().active().background();
+	TQColor buttonColor = tqApp->palette().active().button();
+	TQColor highlight = tqApp->palette().active().highlight();
+	TQSettings settings;
+// 	_contrast = settings.readNumEntry("/TQt/KDE/contrast", 0);
 	
 	settings.beginGroup("/domino/Settings");
 	
@@ -305,8 +305,8 @@ KDE_Q_EXPORT_PLUGIN( DominoStylePlugin )
 	groupBoxSettings.brightness = settings.readNumEntry("/groupBoxBrightness", 10);
 	groupBoxSettings.color = settings.readEntry("/groupBoxBackgroundColor", darkenColor(background, 10).name());
 	bool customToolTipColor = settings.readBoolEntry("/customToolTipColor", false);
-	_toolTipColor = customToolTipColor? settings.readEntry("/toolTipColor", QColor(218,218,179).name()) : QColor(218,218,179);
-	//_toolTipColor = QColor(255,255,220); // yellow
+	_toolTipColor = customToolTipColor? settings.readEntry("/toolTipColor", TQColor(218,218,179).name()) : TQColor(218,218,179);
+	//_toolTipColor = TQColor(255,255,220); // yellow
 	_smoothScrolling = settings.readBoolEntry("/smoothScrolling", true);
 	_buttonHeightAdjustment = settings.readNumEntry("/buttonHeightAdjustment", 0);
 	_customPopupMenuColor = settings.readBoolEntry("/customPopupMenuColor", false);
@@ -321,10 +321,10 @@ KDE_Q_EXPORT_PLUGIN( DominoStylePlugin )
 	rubberBandType = (RubberType) settings.readNumEntry("/rubberBandType", DistRubber);
 	if(rubberBandType == ArgbRubber) {
 		int dummy;
-		if(XQueryExtension(qt_xdisplay(), "Composite", &dummy, &dummy, &dummy)) {
-			QColor c = settings.readEntry("/rubberBandColor", highlight.name());
+		if(XQueryExtension(tqt_xdisplay(), "Composite", &dummy, &dummy, &dummy)) {
+			TQColor c = settings.readEntry("/rubberBandColor", highlight.name());
 			int a = settings.readNumEntry("/rubberBandOpacity", 30)*255/100;
-			_argbRubberBandColor = qRgba(c.red(), c.green(), c.blue(), a);
+			_argbRubberBandColor = tqRgba(c.red(), c.green(), c.blue(), a);
 			
 			rubber = new Rubber(preMultiplyColor(_argbRubberBandColor));
 		}
@@ -360,68 +360,68 @@ KDE_Q_EXPORT_PLUGIN( DominoStylePlugin )
 	if(drawTextEffect) {
 		
 		textEffectSettings.mode = settings.readNumEntry("/textEffectMode", 0) ? TextEffect_Everywhere : TextEffect_OnlyButton;
-		textEffectSettings.color = settings.readEntry("/textEffectColor", Qt::white.name());
+		textEffectSettings.color = settings.readEntry("/textEffectColor", TQt::white.name());
 		textEffectSettings.opacity = settings.readNumEntry("/textEffectOpacity", 60)*255/100;
-		textEffectSettings.buttonColor = settings.readEntry("/textEffectButtonColor", Qt::white.name());
+		textEffectSettings.buttonColor = settings.readEntry("/textEffectButtonColor", TQt::white.name());
 		textEffectSettings.buttonOpacity = settings.readNumEntry("/textEffectButtonOpacity", 60)*255/100;
 		int textEffectPos = settings.readNumEntry("/textEffectPos", 5);
 		switch(textEffectPos) {
 			case 0:
-				textEffectSettings.pos = QPoint(-1,-1);
+				textEffectSettings.pos = TQPoint(-1,-1);
 				break;
 			case 1:
-				textEffectSettings.pos = QPoint(0,-1);
+				textEffectSettings.pos = TQPoint(0,-1);
 				break;
 			case 2:
-				textEffectSettings.pos = QPoint(1,-1);
+				textEffectSettings.pos = TQPoint(1,-1);
 				break;
 			case 3:
-				textEffectSettings.pos = QPoint(1,0);
+				textEffectSettings.pos = TQPoint(1,0);
 				break;
 			case 4:
-				textEffectSettings.pos = QPoint(1,1);
+				textEffectSettings.pos = TQPoint(1,1);
 				break;
 			case 5:
-				textEffectSettings.pos = QPoint(0,1);
+				textEffectSettings.pos = TQPoint(0,1);
 				break;
 			case 6:
-				textEffectSettings.pos = QPoint(-1,1);
+				textEffectSettings.pos = TQPoint(-1,1);
 				break;
 			case 7:
-				textEffectSettings.pos = QPoint(-1,0);
+				textEffectSettings.pos = TQPoint(-1,0);
 				break;
 			default:
-				textEffectSettings.pos = QPoint(0,1);
+				textEffectSettings.pos = TQPoint(0,1);
 		}
 		
 		int textEffectButtonPos = settings.readNumEntry("/textEffectButtonPos", 5);
 		switch(textEffectButtonPos) {
 			case 0:
-				textEffectSettings.buttonPos = QPoint(-1,-1);
+				textEffectSettings.buttonPos = TQPoint(-1,-1);
 				break;
 			case 1:
-				textEffectSettings.buttonPos = QPoint(0,-1);
+				textEffectSettings.buttonPos = TQPoint(0,-1);
 				break;
 			case 2:
-				textEffectSettings.buttonPos = QPoint(1,-1);
+				textEffectSettings.buttonPos = TQPoint(1,-1);
 				break;
 			case 3:
-				textEffectSettings.buttonPos = QPoint(1,0);
+				textEffectSettings.buttonPos = TQPoint(1,0);
 				break;
 			case 4:
-				textEffectSettings.buttonPos = QPoint(1,1);
+				textEffectSettings.buttonPos = TQPoint(1,1);
 				break;
 			case 5:
-				textEffectSettings.buttonPos = QPoint(0,1);
+				textEffectSettings.buttonPos = TQPoint(0,1);
 				break;
 			case 6:
-				textEffectSettings.buttonPos = QPoint(-1,1);
+				textEffectSettings.buttonPos = TQPoint(-1,1);
 				break;
 			case 7:
-				textEffectSettings.buttonPos = QPoint(-1,0);
+				textEffectSettings.buttonPos = TQPoint(-1,0);
 				break;
 			default:
-				textEffectSettings.buttonPos = QPoint(0,1);
+				textEffectSettings.buttonPos = TQPoint(0,1);
 		}
 	}
 	else
@@ -529,15 +529,15 @@ KDE_Q_EXPORT_PLUGIN( DominoStylePlugin )
 
 	settings.endGroup();
 	
-	if(!strcmp(qApp->argv()[0], "konqueror")) {
+	if(!strcmp(tqApp->argv()[0], "konqueror")) {
 		KGlobal::config()->setGroup("General");
 		minTabLength = KGlobal::config()->readNumEntry("MinimumTabLength", 3);
 	}
 	else
 		minTabLength = 0;
 	
-	if(!strcmp(qApp->className(), "KApplication")) {
-		QString oldgroup = KGlobal::config()->group();
+	if(!strcmp(tqApp->className(), "KApplication")) {
+		TQString oldgroup = KGlobal::config()->group();
 		KGlobal::config()->setGroup("KDE");
 		macStyleBar = KGlobal::config()->readBoolEntry("macStyle", false);
 		KGlobal::config()->setGroup(oldgroup); // reset the group, do not interfere with the application
@@ -555,43 +555,43 @@ KDE_Q_EXPORT_PLUGIN( DominoStylePlugin )
 	sideRepaint = 0;
 	hoveredToolBoxTab = 0;
 
-	checkMark = createCheckMark(_customCheckMarkColor? _checkMarkColor : qApp->palette().active().foreground());
-	radioIndicator = createRadioIndicator(_customCheckMarkColor? _checkMarkColor : qApp->palette().active().foreground());
+	checkMark = createCheckMark(_customCheckMarkColor? _checkMarkColor : tqApp->palette().active().foreground());
+	radioIndicator = createRadioIndicator(_customCheckMarkColor? _checkMarkColor : tqApp->palette().active().foreground());
 	
-	popupFrame = new QPixmap(tintImage(qembed_findImage("popup5"), _popupMenuColor.dark(150) ));
+	popupFrame = new TQPixmap(tintImage(qembed_findImage("popup5"), _popupMenuColor.dark(150) ));
 	
 	// setup pixmap cache...
-	pixmapCache = new QIntCache<CacheEntry>(150000, 499);
+	pixmapCache = new TQIntCache<CacheEntry>(150000, 499);
 	pixmapCache->setAutoDelete(true);
 
 	if ( _animateProgressBar )
 	{
-		animationTimer = new QTimer( this );
+		animationTimer = new TQTimer( this );
 		connect( animationTimer, SIGNAL(timeout()), this, SLOT(updateProgressPos()) );
 	}
 
 	scrollDistance = 0;
 	scrollWidget = 0;
-	scrollTimer = new QTimer(this);
+	scrollTimer = new TQTimer(this);
 	connect( scrollTimer, SIGNAL(timeout()), this, SLOT(updateScrollPos()) );
 	
-	QColor tabContour2 = qApp->palette().active().background().dark(150);
-	border1= new QPixmap(tintImage(qembed_findImage("border1"), tabContour2));
+	TQColor tabContour2 = tqApp->palette().active().background().dark(150);
+	border1= new TQPixmap(tintImage(qembed_findImage("border1"), tabContour2));
 }
 
 void DominoStyle::updateProgressPos()
 {
 	
-	QProgressBar* pb;
+	TQProgressBar* pb;
 	//Update the registered progressbars.
-	QMap<QWidget*, int>::iterator iter;
+	TQMap<TQWidget*, int>::iterator iter;
 	bool visible = false;
 	for (iter = progAnimWidgets.begin(); iter != progAnimWidgets.end(); iter++)
 	{	
-		if ( !dynamic_cast<QProgressBar*>(iter.key()) )
+		if ( !dynamic_cast<TQProgressBar*>(iter.key()) )
 			continue;
 		
-		pb = dynamic_cast<QProgressBar*>(iter.key());
+		pb = dynamic_cast<TQProgressBar*>(iter.key());
 		if ( iter.key() -> isEnabled() && 
 				   pb->progress() != pb->totalSteps() && pb->progress())
 		{
@@ -608,7 +608,7 @@ void DominoStyle::updateProgressPos()
 
 void DominoStyle::updateScrollPos()
 {
-	if(dynamic_cast<QScrollView*>(scrollWidget) && scrollDistance != 0) {
+	if(dynamic_cast<TQScrollView*>(scrollWidget) && scrollDistance != 0) {
 		int scroll;
 		if(scrollDistance < 0) {
 			if(scrollDistance < -200)
@@ -619,7 +619,7 @@ void DominoStyle::updateScrollPos()
 				scroll = +15;
 			
 			scrollDistance += scroll;
-			scrollDistance = QMIN(scrollDistance, 0);
+			scrollDistance = TQMIN(scrollDistance, 0);
 		}
 		else {
 			if(scrollDistance > 200)
@@ -630,7 +630,7 @@ void DominoStyle::updateScrollPos()
 				scroll = -15;
 			
 			scrollDistance += scroll;
-			scrollDistance = QMAX(scrollDistance, 0);
+			scrollDistance = TQMAX(scrollDistance, 0);
 		}
 		
 		if(scrollVertical)
@@ -658,7 +658,7 @@ DominoStyle::~DominoStyle()
 	delete buttonContour;
 }
 
-void DominoStyle::polish(QApplication* app)
+void DominoStyle::polish(TQApplication* app)
 {
 	if(!qstrcmp(app->name(), "konsole"))
 		konsoleMode = true;
@@ -667,55 +667,55 @@ void DominoStyle::polish(QApplication* app)
 	else if(!qstrcmp(app->name(), "kicker"))
 		kickerMode = true;
 	
-	QPixmapCache::clear();
+	TQPixmapCache::clear();
 }
 
-void DominoStyle::polish(QPalette &p) {
+void DominoStyle::polish(TQPalette &p) {
 	
-	p.setBrush(QColorGroup::Button, p.active().background());
+	p.setBrush(TQColorGroup::Button, p.active().background());
 
 	if(!_customPopupMenuColor)
-		_popupMenuColor = qApp->palette().active().background();
+		_popupMenuColor = tqApp->palette().active().background();
 	if(!_customSelMenuItemColor)
-		_selMenuItemColor = qApp->palette().active().highlight();
+		_selMenuItemColor = tqApp->palette().active().highlight();
 	
-	QColor tabContour2 = qApp->palette().active().background().dark(150);
+	TQColor tabContour2 = tqApp->palette().active().background().dark(150);
 	delete border1;
-	border1= new QPixmap(tintImage(qembed_findImage("border1"), tabContour2));
+	border1= new TQPixmap(tintImage(qembed_findImage("border1"), tabContour2));
 	delete popupFrame;
-	popupFrame = new QPixmap(tintImage(qembed_findImage("popup5"), _popupMenuColor.dark(150)));
+	popupFrame = new TQPixmap(tintImage(qembed_findImage("popup5"), _popupMenuColor.dark(150)));
 	if(!_customCheckMarkColor) {
 		delete checkMark;
-		checkMark = createCheckMark(qApp->palette().active().foreground());
+		checkMark = createCheckMark(tqApp->palette().active().foreground());
 		delete radioIndicator;
-		radioIndicator = createRadioIndicator(qApp->palette().active().foreground());
+		radioIndicator = createRadioIndicator(tqApp->palette().active().foreground());
 	}
 }
 
-void DominoStyle::polish(QWidget* widget)
+void DominoStyle::polish(TQWidget* widget)
 {
 	
 	if(!strcmp(widget->name(), "__khtml")) { // is it a khtml widget...?
 		khtmlWidgets[widget] = true;
-		connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(khtmlWidgetDestroyed(QObject*)));
+		connect(widget, SIGNAL(destroyed(TQObject*)), this, SLOT(khtmlWidgetDestroyed(TQObject*)));
 	}
 	else if((!strcmp(widget->name(), "kfile button") || (widget->isA("KLineEdit") && widget->parentWidget())) && !strcmp(widget->parentWidget()->name(), "__khtml")) {
-		widget->setBackgroundMode(Qt::NoBackground);
-		widget->parentWidget()->setBackgroundMode(Qt::NoBackground);
+		widget->setBackgroundMode(TQt::NoBackground);
+		widget->parentWidget()->setBackgroundMode(TQt::NoBackground);
 		khtmlWidgets[widget] = true;
-		connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(khtmlWidgetDestroyed(QObject*)));
+		connect(widget, SIGNAL(destroyed(TQObject*)), this, SLOT(khtmlWidgetDestroyed(TQObject*)));
 	}
 	
-	if(dynamic_cast<QPushButton*>(widget)) {
+	if(dynamic_cast<TQPushButton*>(widget)) {
 		
 		setDominoButtonPalette(widget, Palette_Widget);
 		
 		if (widget->isA("KDockButton_Private"))
 			widget->setFixedSize(13, 13); // 12x12 pixmap + 1px top and right spacing
 		else {
-			((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+			((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 			if(widget->parentWidget() && widget->parentWidget()->paletteBackgroundPixmap() && !khtmlWidgets.contains(widget)) {
-				widget->setBackgroundMode(Qt::PaletteButton);
+				widget->setBackgroundMode(TQt::PaletteButton);
 				widget->setBackgroundPixmap(*widget->parentWidget()->paletteBackgroundPixmap());
 				widget->setBackgroundOrigin(setPixmapOrigin(widget->parentWidget()->backgroundOrigin()));
 			}
@@ -723,8 +723,8 @@ void DominoStyle::polish(QWidget* widget)
 		
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QCheckBox*>(widget)) {
-		((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+	else if(dynamic_cast<TQCheckBox*>(widget)) {
+		((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 		widget->installEventFilter(this);
 	}
 	else if(dynamic_cast<KToolBarButton*>(widget)) {
@@ -735,9 +735,9 @@ void DominoStyle::polish(QWidget* widget)
 			tb->setPopupDelay(5); // now we have time to draw a pressed button
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QToolButton*>(widget)) {
-		QToolButton* tb = static_cast<QToolButton*>(widget);
-		tb->setBackgroundMode(Qt::PaletteBackground);
+	else if(dynamic_cast<TQToolButton*>(widget)) {
+		TQToolButton* tb = static_cast<TQToolButton*>(widget);
+		tb->setBackgroundMode(TQt::PaletteBackground);
 		tb->setPaletteForegroundColor(tb->palette().active().buttonText());
 		setDominoButtonPalette(widget, Palette_Widget);
 		
@@ -756,109 +756,109 @@ void DominoStyle::polish(QWidget* widget)
 		}
 		
 // 		if(widget->isA("TaskContainer"))
-// 			((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+// 			((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 // 		else
 			widget->installEventFilter(this);
-			((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+			((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 	}
-	else if(dynamic_cast<QRadioButton*>(widget)) {
-		((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+	else if(dynamic_cast<TQRadioButton*>(widget)) {
+		((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QComboBox*>(widget)) {
-		QComboBox* cb = static_cast<QComboBox*>(widget);
+	else if(dynamic_cast<TQComboBox*>(widget)) {
+		TQComboBox* cb = static_cast<TQComboBox*>(widget);
 		
-		((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+		((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 		if(widget->parentWidget() && widget->parentWidget()->paletteBackgroundPixmap() && !khtmlWidgets.contains(widget)) {
-			widget->setBackgroundMode(Qt::PaletteButton);
+			widget->setBackgroundMode(TQt::PaletteButton);
 			widget->setBackgroundOrigin(setPixmapOrigin(widget->parentWidget()->backgroundOrigin()));
 		}
 		
 		setDominoButtonPalette(widget, Palette_Widget);
 		if(cb->listBox())
-			cb->listBox()->setFrameStyle(QFrame::Panel|QFrame::Sunken);
+			cb->listBox()->setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QGroupBox*>(widget)) {
-		QGroupBox* gb = dynamic_cast<QGroupBox*>(widget);
-		gb->setAlignment(Qt::AlignHCenter);
+	else if(dynamic_cast<TQGroupBox*>(widget)) {
+		TQGroupBox* gb = dynamic_cast<TQGroupBox*>(widget);
+		gb->setAlignment(TQt::AlignHCenter);
 		
 		if(!gb->isFlat() && !gb->lineWidth() <= 0) {
 			if(gb->layout() && gb->layout()->margin() < 7)
 				gb->layout()->setMargin(7);
-			bool groupBoxFrame = gb->frameShape() == QFrame::GroupBoxPanel;
+			bool groupBoxFrame = gb->frameShape() == TQFrame::GroupBoxPanel;
 			if(groupBoxFrame)
-				((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+				((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 			
 			if(groupBoxSettings.tintBackground && groupBoxFrame) {
-				QColor color = getGroupBoxColor(gb);
-				QPalette pal(widget->palette());
+				TQColor color = getGroupBoxColor(gb);
+				TQPalette pal(widget->palette());
 				int h, s, v;
 				pal.active().foreground().hsv(&h, &s, &v);
-				pal.setColor(QPalette::Active, QColorGroup::Background, color);
-				pal.setColor(QPalette::Inactive, QColorGroup::Background, color);
-				pal.setColor(QPalette::Disabled, QColorGroup::Background, color);
-				pal.setColor(QPalette::Disabled, QColorGroup::Text, alphaBlendColors(pal.active().foreground(), color, 40));
+				pal.setColor(TQPalette::Active, TQColorGroup::Background, color);
+				pal.setColor(TQPalette::Inactive, TQColorGroup::Background, color);
+				pal.setColor(TQPalette::Disabled, TQColorGroup::Background, color);
+				pal.setColor(TQPalette::Disabled, TQColorGroup::Text, alphaBlendColors(pal.active().foreground(), color, 40));
 				gb->setPalette(pal);
 				
 				if(gb->isCheckable()) {
-					((QCheckBox*)gb->child("qt_groupbox_checkbox", 0, false))->setPaletteBackgroundColor(gb->parentWidget()->paletteBackgroundColor());
+					((TQCheckBox*)gb->child("qt_groupbox_checkbox", 0, false))->setPaletteBackgroundColor(gb->parentWidget()->paletteBackgroundColor());
 				}
 			}
-			connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(groupBoxDestroyed(QObject*)));
+			connect(widget, SIGNAL(destroyed(TQObject*)), this, SLOT(groupBoxDestroyed(TQObject*)));
 		}
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QSpinWidget*>(widget)) {
+	else if(dynamic_cast<TQSpinWidget*>(widget)) {
 		 // Don't like this widget... too much private stuff and the spinBox/spinWidget mess.
 		// We check here if the spinBox has a backgroundPixmap. If it's a spinWidget without a spinBox, well, maybe we should fill the widget black then >:)
 		if(widget->parentWidget() && widget->parentWidget()->parentWidget() && widget->parentWidget()->parentWidget()->paletteBackgroundPixmap()) {
-			QWidget::BackgroundOrigin origin = widget->parentWidget()->backgroundOrigin();
-			if(origin == QWidget::WidgetOrigin) {
-				widget->parentWidget()->setBackgroundOrigin(QWidget::ParentOrigin);
-				widget->setBackgroundOrigin(QWidget::AncestorOrigin);
+			TQWidget::BackgroundOrigin origin = widget->parentWidget()->backgroundOrigin();
+			if(origin == TQWidget::WidgetOrigin) {
+				widget->parentWidget()->setBackgroundOrigin(TQWidget::ParentOrigin);
+				widget->setBackgroundOrigin(TQWidget::AncestorOrigin);
 			}
 			else
 				widget->setBackgroundOrigin(setPixmapOrigin(origin));
 		}
-		((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+		((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 		setDominoButtonPalette(widget, Palette_Widget);
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QSpinBox*>(widget)) {
-		connect(dynamic_cast<QSpinBox*>(widget), SIGNAL(valueChanged(int)), this, SLOT(spinBoxValueChanged(int)));
+	else if(dynamic_cast<TQSpinBox*>(widget)) {
+		connect(dynamic_cast<TQSpinBox*>(widget), SIGNAL(valueChanged(int)), this, SLOT(spinBoxValueChanged(int)));
 	}
-	else if(dynamic_cast<QLineEdit*>(widget)) {
-		QLineEdit* le = dynamic_cast<QLineEdit*>(widget);
-		QRect r = le->rect();
-		le->setFrameRect(QRect(r.x()+1, r.y(), r.width()-1, r.height()));
+	else if(dynamic_cast<TQLineEdit*>(widget)) {
+		TQLineEdit* le = dynamic_cast<TQLineEdit*>(widget);
+		TQRect r = le->rect();
+		le->setFrameRect(TQRect(r.x()+1, r.y(), r.width()-1, r.height()));
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QScrollBar*>(widget)) {
+	else if(dynamic_cast<TQScrollBar*>(widget)) {
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QStatusBar*>(widget)) {
+	else if(dynamic_cast<TQStatusBar*>(widget)) {
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QHeader*>(widget)) {
+	else if(dynamic_cast<TQHeader*>(widget)) {
 		setDominoButtonPalette(widget, Palette_Widget);
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QPopupMenu*>(widget)) {
+	else if(dynamic_cast<TQPopupMenu*>(widget)) {
 		
 		if(widget->isA("PanelKMenu"))
-			widget->setPaletteForegroundColor(alphaBlendColors(_popupMenuColor, qApp->palette().active().foreground(), 150));
+			widget->setPaletteForegroundColor(alphaBlendColors(_popupMenuColor, tqApp->palette().active().foreground(), 150));
 		
 		widget->setBackgroundMode( NoBackground );
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QTabWidget*>(widget)) {
+	else if(dynamic_cast<TQTabWidget*>(widget)) {
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QTabBar*>(widget)) {
-		QTabBar* tb = dynamic_cast<QTabBar*>(widget);
+	else if(dynamic_cast<TQTabBar*>(widget)) {
+		TQTabBar* tb = dynamic_cast<TQTabBar*>(widget);
 		if(widget->parentWidget() && widget->parentWidget()->isA("KonqFrameTabs")) {
-			tb->setShape(QTabBar::RoundedBelow);
+			tb->setShape(TQTabBar::RoundedBelow);
 			widget->setEraseColor(widget->paletteBackgroundColor().dark(konqTabBarContrast));
 		}
 		connect(tb, SIGNAL(layoutChanged()), this, SLOT(updateTabWidgetFrame()));
@@ -866,74 +866,74 @@ void DominoStyle::polish(QWidget* widget)
 		setDominoButtonPalette(widget, Palette_Widget);
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QIconView*>(widget)) {
-		((DominoQWidget*)dynamic_cast<QIconView*>(widget)->viewport())->setWFlags(Qt::WNoAutoErase);
-		((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
-		dynamic_cast<QIconView*>(widget)->viewport()->installEventFilter(this); // rubberband
+	else if(dynamic_cast<TQIconView*>(widget)) {
+		((DominoTQWidget*)dynamic_cast<TQIconView*>(widget)->viewport())->setWFlags(TQt::WNoAutoErase);
+		((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
+		dynamic_cast<TQIconView*>(widget)->viewport()->installEventFilter(this); // rubberband
 		if(strcmp(widget->className(), "KDIconView"))
 			widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QListView*>(widget)) {
-		dynamic_cast<QListView*>(widget)->viewport()->installEventFilter(this); // rubberband
+	else if(dynamic_cast<TQListView*>(widget)) {
+		dynamic_cast<TQListView*>(widget)->viewport()->installEventFilter(this); // rubberband
 		if(widget->isA("KonqTreeViewWidget")) { // konqi frames
-			QFrame* f = dynamic_cast<QFrame*>(widget);
-			f->setFrameStyle(QFrame::Box|QFrame::Plain);
+			TQFrame* f = dynamic_cast<TQFrame*>(widget);
+			f->setFrameStyle(TQFrame::Box|TQFrame::Plain);
 			f->setLineWidth(1);
 		}
 		
 		if(!widget->isA("KopeteContactListView") && !widget->isA("ViewTree")) // they have their own mousewheel handling
 			widget->installEventFilter(this);
 	}
-	else if(widget->isA("KActiveLabel")) { // before QScrollView
-		if(dynamic_cast<QGroupBox*>(widget->parentWidget()))
+	else if(widget->isA("KActiveLabel")) { // before TQScrollView
+		if(dynamic_cast<TQGroupBox*>(widget->parentWidget()))
 			widget->setPaletteBackgroundColor(widget->parentWidget()->paletteBackgroundColor());
 	}
-	else if(dynamic_cast<QTextEdit*>(widget)) {
-		dynamic_cast<QTextEdit*>(widget)->viewport()->installEventFilter(this);
+	else if(dynamic_cast<TQTextEdit*>(widget)) {
+		dynamic_cast<TQTextEdit*>(widget)->viewport()->installEventFilter(this);
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QScrollView*>(widget)) {
-		QFrame* f = dynamic_cast<QFrame*>(widget);
+	else if(dynamic_cast<TQScrollView*>(widget)) {
+		TQFrame* f = dynamic_cast<TQFrame*>(widget);
 		if((konquerorMode && widget->isA("KHTMLView")) || f->parentWidget() && !strcmp(f->parentWidget()->name(), "KonqFrame")) { // konqi frames
-			f->setFrameStyle(QFrame::Box|QFrame::Plain);
+			f->setFrameStyle(TQFrame::Box|TQFrame::Plain);
 			f->setLineWidth(1);
 			widget->installEventFilter(this);
 		}
 		else if(_smoothScrolling && !widget->isA("TaskBar") && !widget->isA("Gwenview::ImageView"))
 			widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QSlider*>(widget)) {
-		((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+	else if(dynamic_cast<TQSlider*>(widget)) {
+		((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 	}
-	else if(dynamic_cast<QListBox*>(widget)) {
+	else if(dynamic_cast<TQListBox*>(widget)) {
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<KToolBarSeparator*>(widget) || dynamic_cast<QToolBar*>(widget)) {
-		widget->setBackgroundMode(Qt::PaletteBackground);
+	else if(dynamic_cast<KToolBarSeparator*>(widget) || dynamic_cast<TQToolBar*>(widget)) {
+		widget->setBackgroundMode(TQt::PaletteBackground);
 	}
 
 	else if(widget->isA("KonqCheckBox")) {
 		widget->installEventFilter(this);
 	}
-	else if(widget->isA("QTipLabel")) {
+	else if(widget->isA("TQTipLabel")) {
 		widget->installEventFilter(this);
 	}
-	else if(widget->isA("QWhatsThat")) {
+	else if(widget->isA("TQWhatsThat")) {
 		widget->installEventFilter(this);
 	}
 	else if(widget->isA("KonqFileTip")) {
 		widget->installEventFilter(this);
 	}
 
-	else if(dynamic_cast<QButton*>(widget) && widget->parentWidget() && widget->parentWidget()->isA("QToolBox")) {
+	else if(dynamic_cast<TQButton*>(widget) && widget->parentWidget() && widget->parentWidget()->isA("TQToolBox")) {
 		widget->installEventFilter(this);
 	}
-	else if( dynamic_cast<QProgressBar*>(widget) && _animateProgressBar)
+	else if( dynamic_cast<TQProgressBar*>(widget) && _animateProgressBar)
 	{
 		setDominoButtonPalette(widget, Palette_Widget);
 		
 		progAnimWidgets[widget] = 0;
-		connect(widget, SIGNAL(destroyed(QObject*)), this, SLOT(progressBarDestroyed(QObject*)));
+		connect(widget, SIGNAL(destroyed(TQObject*)), this, SLOT(progressBarDestroyed(TQObject*)));
 // 		if (!animationTimer->isActive())
 // 			animationTimer->start( 50, false );
 		widget->installEventFilter(this);
@@ -941,60 +941,60 @@ void DominoStyle::polish(QWidget* widget)
 	else if(dynamic_cast<KPopupTitle*>(widget)) {
 		widget->installEventFilter(this);
 	}
-	else if(dynamic_cast<QFrame*>(widget)) {
-		QFrame* f = dynamic_cast<QFrame*>(widget);
+	else if(dynamic_cast<TQFrame*>(widget)) {
+		TQFrame* f = dynamic_cast<TQFrame*>(widget);
 		
 		switch (f->frameShape()) {
-			case QFrame::Box:
-				f->setFrameStyle(QFrame::StyledPanel|QFrame::Sunken);
+			case TQFrame::Box:
+				f->setFrameStyle(TQFrame::StyledPanel|TQFrame::Sunken);
 				f->setLineWidth(2);
 				break;
-			case QFrame::Panel:
+			case TQFrame::Panel:
 				if(kickerMode && f->parentWidget() &&  f->parentWidget()->isA("ClockApplet")) {
 					f->setLineWidth(0);
 					break;
 				}
-			case QFrame::WinPanel:
+			case TQFrame::WinPanel:
 				f->setLineWidth(1);
 				widget->installEventFilter(this);
 				break;
-			case QFrame::LineEditPanel: {
+			case TQFrame::LineEditPanel: {
 				widget->installEventFilter(this);
 				break;
 			}
-			case QFrame::TabWidgetPanel:
-				if(dynamic_cast<QWidgetStack*>(widget)) {
+			case TQFrame::TabWidgetPanel:
+				if(dynamic_cast<TQWidgetStack*>(widget)) {
 					if(f->parentWidget() && f->parentWidget()->isA("KonqFrameTabs"))
 						break;
 					
 					f->setLineWidth(4);
-					f->setFrameRect(QRect(0, 0, f->width(), f->height()-1));
+					f->setFrameRect(TQRect(0, 0, f->width(), f->height()-1));
 					f->setMargin(0);
 
-					QWidget* w = widget->parentWidget();
+					TQWidget* w = widget->parentWidget();
 					for(int i=0; i<3; i++) { // the third parentcheck is for the tabWidget on kcm khtml_plugins
 						if(!w) break;
-						if(dynamic_cast<QGroupBox*>(w)) {
-							widget->setPaletteBackgroundColor(qApp->palette().active().background());
+						if(dynamic_cast<TQGroupBox*>(w)) {
+							widget->setPaletteBackgroundColor(tqApp->palette().active().background());
 								break;
 						}
 						w = w->parentWidget();
 					}
 					
-					if(dynamic_cast<QWidgetStack*>(widget)->widget(0)) // only if it has contents
-						((DominoQWidget*)widget)->setWFlags(Qt::WNoAutoErase);
+					if(dynamic_cast<TQWidgetStack*>(widget)->widget(0)) // only if it has contents
+						((DominoTQWidget*)widget)->setWFlags(TQt::WNoAutoErase);
 				}
-			case QFrame::HLine:
-			case QFrame::VLine: {
+			case TQFrame::HLine:
+			case TQFrame::VLine: {
 				widget->installEventFilter(this);
 				break;
 				}
-			case QFrame::StyledPanel:
-				if(dynamic_cast<QDockWindow*>(widget)) {
+			case TQFrame::StyledPanel:
+				if(dynamic_cast<TQDockWindow*>(widget)) {
 					widget->installEventFilter(this);
 				}
-				else if(widget->isA("QWorkspaceChild")) {
-					f->setFrameStyle(QFrame::Panel|QFrame::Sunken);
+				else if(widget->isA("TQWorkspaceChild")) {
+					f->setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
 					f->setLineWidth(1);
 					widget->installEventFilter(this);
 				}
@@ -1009,10 +1009,10 @@ void DominoStyle::polish(QWidget* widget)
 // 		widget->installEventFilter(this);
 // 	} else if (dynamic_cast<KDockWidgetAbstractHeaderDrag*>(widget)) {
 // 		widget->installEventFilter(this);
-	else if(widget->isA("QDateTimeEditor")) {
+	else if(widget->isA("TQDateTimeEditor")) {
 		widget->installEventFilter(this);
 	}
-	else if(widget->inherits("QDockWindowHandle") || widget->isA("QDockWindowResizeHandle") ||
+	else if(widget->inherits("TQDockWindowHandle") || widget->isA("TQDockWindowResizeHandle") ||
 		        widget->isA("AppletHandleDrag")) { // !qstrcmp(widget->name(), "qt_dockwidget_internal")
 		widget->installEventFilter(this);
 	}
@@ -1022,131 +1022,131 @@ void DominoStyle::polish(QWidget* widget)
 	}
 	
 // 	widget->installEventFilter(this);
-	//qDebug("className %s, name: %s", widget->className(), widget->name());
+	//tqDebug("className %s, name: %s", widget->className(), widget->name());
 	
 }
 
-void DominoStyle::unPolish(QWidget* widget)
+void DominoStyle::unPolish(TQWidget* widget)
 {
 	
 	if( !strcmp(widget->name(), "__khtml") || (!strcmp(widget->name(), "kfile button") && !strcmp(widget->parentWidget()->name(), "__khtml"))) { // is it a khtml widget...?
 		khtmlWidgets.remove(widget);
 	}
 
-	if (dynamic_cast<QPushButton*>(widget) || 
-		   dynamic_cast<QSpinWidget*>(widget) || dynamic_cast<QSlider*>(widget) ||
-		   dynamic_cast<QRadioButton*>(widget) ||
-		   dynamic_cast<QListBox*>(widget) || dynamic_cast<QListView*>(widget) ||
-		   dynamic_cast<QStatusBar*>(widget) || widget->isA("AppletHandleDrag") ||
-		   widget->isA("QDockWindowHandle"))
+	if (dynamic_cast<TQPushButton*>(widget) || 
+		   dynamic_cast<TQSpinWidget*>(widget) || dynamic_cast<TQSlider*>(widget) ||
+		   dynamic_cast<TQRadioButton*>(widget) ||
+		   dynamic_cast<TQListBox*>(widget) || dynamic_cast<TQListView*>(widget) ||
+		   dynamic_cast<TQStatusBar*>(widget) || widget->isA("AppletHandleDrag") ||
+		   widget->isA("TQDockWindowHandle"))
 	{
-		((DominoQWidget*)widget)->clearWFlags(Qt::WNoAutoErase);
+		((DominoTQWidget*)widget)->clearWFlags(TQt::WNoAutoErase);
 		widget->removeEventFilter(this);
 	}
-	else if(widget->isA("KonqCheckBox") || widget->isA("QWhatsThat") || widget->isA("QTipLabel")) {
+	else if(widget->isA("KonqCheckBox") || widget->isA("TQWhatsThat") || widget->isA("TQTipLabel")) {
 		widget->removeEventFilter(this);
-		widget->setPaletteBackgroundColor(qApp->palette().active().background());
-		widget->setBackgroundMode(Qt::PaletteBackground);
+		widget->setPaletteBackgroundColor(tqApp->palette().active().background());
+		widget->setBackgroundMode(TQt::PaletteBackground);
 	}
-	else if(dynamic_cast<QTabWidget*>(widget) || dynamic_cast<QTabBar*>(widget)) {
+	else if(dynamic_cast<TQTabWidget*>(widget) || dynamic_cast<TQTabBar*>(widget)) {
 		widget->removeEventFilter(this);
-		widget->setBackgroundMode(Qt::PaletteBackground);
+		widget->setBackgroundMode(TQt::PaletteBackground);
 	}
-	else if(dynamic_cast<QCheckBox*>(widget)) {
-		((DominoQWidget*)widget)->clearWFlags(Qt::WNoAutoErase);
+	else if(dynamic_cast<TQCheckBox*>(widget)) {
+		((DominoTQWidget*)widget)->clearWFlags(TQt::WNoAutoErase);
 		widget->removeEventFilter(this);
 	}
-	else if(dynamic_cast<QComboBox*>(widget)) { // after KonqCheckBox
-		((DominoQWidget*)widget)->clearWFlags(Qt::WNoAutoErase);
+	else if(dynamic_cast<TQComboBox*>(widget)) { // after KonqCheckBox
+		((DominoTQWidget*)widget)->clearWFlags(TQt::WNoAutoErase);
 		widget->removeEventFilter(this);
 	}
-	else if(dynamic_cast<QHeader*>(widget)) {
+	else if(dynamic_cast<TQHeader*>(widget)) {
 		widget->removeEventFilter(this);
-		widget->setBackgroundMode(Qt::PaletteButton);
+		widget->setBackgroundMode(TQt::PaletteButton);
 	}
-	else if(dynamic_cast<QPopupMenu*>(widget)) {
+	else if(dynamic_cast<TQPopupMenu*>(widget)) {
 		widget->removeEventFilter(this);
-		widget->setBackgroundMode(Qt::PaletteBackground);
-		static_cast<QFrame*>(widget)->setLineWidth(2);
+		widget->setBackgroundMode(TQt::PaletteBackground);
+		static_cast<TQFrame*>(widget)->setLineWidth(2);
 		widget->clearMask();
 	}
 	else if(dynamic_cast<KToolBarButton*>(widget)) {
 		widget->removeEventFilter(this);
-		widget->setBackgroundMode(Qt::PaletteBackground);
+		widget->setBackgroundMode(TQt::PaletteBackground);
 	}
-	else if(dynamic_cast<QGroupBox*>(widget)) {
+	else if(dynamic_cast<TQGroupBox*>(widget)) {
 		widget->removeEventFilter(this);
-		((DominoQWidget*)widget)->clearWFlags(Qt::WNoAutoErase);
-		QGroupBox* gb = dynamic_cast<QGroupBox*>(widget);
-		gb->setBackgroundMode(Qt::PaletteBackground);
-		gb->setPalette(qApp->palette());
-		gb->setAlignment(Qt::AlignLeft|Qt::AlignBottom);
+		((DominoTQWidget*)widget)->clearWFlags(TQt::WNoAutoErase);
+		TQGroupBox* gb = dynamic_cast<TQGroupBox*>(widget);
+		gb->setBackgroundMode(TQt::PaletteBackground);
+		gb->setPalette(tqApp->palette());
+		gb->setAlignment(TQt::AlignLeft|TQt::AlignBottom);
 	}
-	else if(dynamic_cast<QLineEdit*>(widget)) {
+	else if(dynamic_cast<TQLineEdit*>(widget)) {
 		widget->removeEventFilter(this);
-		widget->setBackgroundMode(Qt::PaletteBase);
-		QLineEdit* le = dynamic_cast<QLineEdit*>(widget);
-		QRect r = le->rect();
-		le->setFrameRect(QRect(r.x()-1, r.y(), r.width()+1, r.height()));
+		widget->setBackgroundMode(TQt::PaletteBase);
+		TQLineEdit* le = dynamic_cast<TQLineEdit*>(widget);
+		TQRect r = le->rect();
+		le->setFrameRect(TQRect(r.x()-1, r.y(), r.width()+1, r.height()));
 		widget->clearMask();
 	}
-	else if(dynamic_cast<QProgressBar*>(widget) ) {
+	else if(dynamic_cast<TQProgressBar*>(widget) ) {
 		progAnimWidgets.remove(widget);
 	}
-	else if(dynamic_cast<KToolBarSeparator*>(widget) || dynamic_cast<QToolBar*>(widget) ) {
+	else if(dynamic_cast<KToolBarSeparator*>(widget) || dynamic_cast<TQToolBar*>(widget) ) {
 		widget->removeEventFilter(this);
-		widget->setBackgroundMode(Qt::PaletteButton);
+		widget->setBackgroundMode(TQt::PaletteButton);
 	}
 	if(widget->isA("KonqFileTip")) {
 		widget->removeEventFilter(this);
 		widget->setPaletteBackgroundColor(widget->palette().active().background());
-		QFrame* f = dynamic_cast<QFrame*>(widget);
+		TQFrame* f = dynamic_cast<TQFrame*>(widget);
 		f->setMargin(1);
-		f->setFrameStyle(QFrame::Plain|QFrame::Box);
+		f->setFrameStyle(TQFrame::Plain|TQFrame::Box);
 
-		QObjectList *list = const_cast<QObjectList *>(widget->children());
-		QObjectListIt it( *list );
-		QObject * o;
+		TQObjectList *list = const_cast<TQObjectList *>(widget->children());
+		TQObjectListIt it( *list );
+		TQObject * o;
 		while ( (o = it.current()) != 0 ) {
 			++it;
-			if(dynamic_cast<QLabel*>(o)) {
-				QLabel* l = dynamic_cast<QLabel*>(o);
-				l->setBackgroundOrigin(QWidget::WidgetOrigin);
-				l->setBackgroundMode(Qt::PaletteBackground);
+			if(dynamic_cast<TQLabel*>(o)) {
+				TQLabel* l = dynamic_cast<TQLabel*>(o);
+				l->setBackgroundOrigin(TQWidget::WidgetOrigin);
+				l->setBackgroundMode(TQt::PaletteBackground);
 				l->setPaletteBackgroundColor(l->palette().active().background());
 			}
 		}
 	}
-	else if(dynamic_cast<QScrollView*>(widget)) {
-		QFrame* f = dynamic_cast<QFrame*>(widget);
+	else if(dynamic_cast<TQScrollView*>(widget)) {
+		TQFrame* f = dynamic_cast<TQFrame*>(widget);
 		if((konquerorMode && widget->isA("KHTMLView")) || f->parentWidget() && !strcmp(f->parentWidget()->name(), "KonqFrame")) { // konqi frames
 			widget->removeEventFilter(this);
-			f->setFrameStyle(QFrame::NoFrame|QFrame::Plain);
+			f->setFrameStyle(TQFrame::NoFrame|TQFrame::Plain);
 			f->setLineWidth(0);
 		}
 	}
 	else if(dynamic_cast<KPopupTitle*>(widget)) {
 		widget->removeEventFilter(this);
 	}
-	else if(dynamic_cast<QFrame*>(widget)) {
+	else if(dynamic_cast<TQFrame*>(widget)) {
 		widget->removeEventFilter(this);
-		QFrame* f = dynamic_cast<QFrame*>(widget);
+		TQFrame* f = dynamic_cast<TQFrame*>(widget);
 		switch(f->frameShape()) {
-			case QFrame::Panel:
-				if(widget->isA("QWorkspaceChild")) {
-					f->setFrameStyle(QFrame::StyledPanel|QFrame::Sunken);
+			case TQFrame::Panel:
+				if(widget->isA("TQWorkspaceChild")) {
+					f->setFrameStyle(TQFrame::StyledPanel|TQFrame::Sunken);
 					f->setLineWidth(2);
 				}
 				break;
-			case QFrame::WinPanel:
+			case TQFrame::WinPanel:
 				f->setLineWidth(2);
 				break;
-			case QFrame::TabWidgetPanel:
+			case TQFrame::TabWidgetPanel:
 				f->setLineWidth(2);
 				f->setMargin(2);
-				f->setFrameRect(QRect(0, 0, 0, 0));
+				f->setFrameRect(TQRect(0, 0, 0, 0));
 				break;
-			case QFrame::StyledPanel:
+			case TQFrame::StyledPanel:
 				if(widget->isA("KAnimWidget"))
 					f->setLineWidth(2);
 				break;
@@ -1159,23 +1159,23 @@ void DominoStyle::unPolish(QWidget* widget)
 	KStyle::unPolish(widget);
 }
 
-void DominoStyle::khtmlWidgetDestroyed(QObject* obj)
+void DominoStyle::khtmlWidgetDestroyed(TQObject* obj)
 {
-	khtmlWidgets.remove(static_cast<QWidget*>(obj));
+	khtmlWidgets.remove(static_cast<TQWidget*>(obj));
 }
 
-void DominoStyle::groupBoxDestroyed(QObject* obj)
+void DominoStyle::groupBoxDestroyed(TQObject* obj)
 {
-	groupBoxPixmaps.remove(static_cast<QGroupBox*>(obj));
+	groupBoxPixmaps.remove(static_cast<TQGroupBox*>(obj));
 }
 
-void DominoStyle::progressBarDestroyed(QObject* obj)
+void DominoStyle::progressBarDestroyed(TQObject* obj)
 {
-	progAnimWidgets.remove(static_cast<QWidget*>(obj));
+	progAnimWidgets.remove(static_cast<TQWidget*>(obj));
 }
 
 
-void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backgroundColor, const QColor &contour, const uint flags) const {
+void DominoStyle::renderContour(TQPainter *p, const TQRect &r, const TQColor &backgroundColor, const TQColor &contour, const uint flags) const {
 	
 	if((r.width() <= 0)||(r.height() <= 0))
 		return;
@@ -1195,11 +1195,11 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 	const bool isHorizontal = flags&Is_Horizontal;
 	const bool isScrollBarBtn = flags&Is_ScrollBarBtn;
 	
-	QColor appButtonColor = qApp->palette().active().button();
+	TQColor appButtonColor = tqApp->palette().active().button();
 	
 	if(isButton) {
 		
-		QRect sr = QRect(r.x(), r.y()+2, r.width(), r.height()-5); // surface rect
+		TQRect sr = TQRect(r.x(), r.y()+2, r.width(), r.height()-5); // surface rect
 		int top = sr.y()+sr.height()*btnSurface.g1Top/100;
 		int bottom = sr.height()*btnSurface.g1Bottom/100;
 		int top2 = sr.y()+sr.height()*btnSurface.g2Top/100;
@@ -1211,13 +1211,13 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 		int width2 = sr.width()*btnSurface.g2Bottom/100-left2;
 		
 		// darker surface colors for the inner part of the contour
-		QColor insideBackground;
-		QColor gr1TopColor;
-		QColor gr1BottomColor;
-		QColor gr2TopColor;
-		QColor gr2BottomColor;
+		TQColor insideBackground;
+		TQColor gr1TopColor;
+		TQColor gr1BottomColor;
+		TQColor gr2TopColor;
+		TQColor gr2BottomColor;
 		
-		const int alphaInside = qAlpha(buttonContour->color3());
+		const int alphaInside = tqAlpha(buttonContour->color3());
 		
 		insideBackground = alphaBlendColors(buttonContour->color3(),
 				((contour != appButtonColor) ? alphaBlendColors(contour, btnSurface.background, 127) : btnSurface.background), alphaInside);
@@ -1267,15 +1267,15 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 	
 		
 		
-		QRegion clip;
+		TQRegion clip;
 		if(drawTop)
-			clip += QRegion(r.left()+6, r.top()+2, r.width()-12, 1);
+			clip += TQRegion(r.left()+6, r.top()+2, r.width()-12, 1);
 		if(drawBottom)
-			clip += QRegion(r.left()+6, r.bottom()-3, r.width()-12, 1);
+			clip += TQRegion(r.left()+6, r.bottom()-3, r.width()-12, 1);
 		if(drawLeft)
-			clip += QRegion(r.left()+2, r.top()+6, 1, r.height()-13);
+			clip += TQRegion(r.left()+2, r.top()+6, 1, r.height()-13);
 		if(drawRight)
-			clip += QRegion(r.right()-2, r.top()+6, 1, r.height()-13);
+			clip += TQRegion(r.right()-2, r.top()+6, 1, r.height()-13);
 		p->setClipRegion(clip);
 		
 		
@@ -1283,18 +1283,18 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 		switch(btnSurface.numGradients) {
 			case 1:
 				if(isHorizontal)
-					renderGradient(p, QRect(sr.x(), top, sr.width(), bottom), gr1TopColor, gr1BottomColor, true);
+					renderGradient(p, TQRect(sr.x(), top, sr.width(), bottom), gr1TopColor, gr1BottomColor, true);
 				else
-					renderGradient(p, QRect(left, sr.y(), width, sr.height()), gr1TopColor, gr1BottomColor, false);
+					renderGradient(p, TQRect(left, sr.y(), width, sr.height()), gr1TopColor, gr1BottomColor, false);
 				break;
 			case 2:
 				if(isHorizontal) {
-					renderGradient(p, QRect(r.x(), top, r.width(), bottom), gr1TopColor, gr1BottomColor, true);
-					renderGradient(p, QRect(r.x(), top2, r.width(), bottom2), gr2TopColor, gr2BottomColor, true);
+					renderGradient(p, TQRect(r.x(), top, r.width(), bottom), gr1TopColor, gr1BottomColor, true);
+					renderGradient(p, TQRect(r.x(), top2, r.width(), bottom2), gr2TopColor, gr2BottomColor, true);
 				}
 				else {
-					renderGradient(p, QRect(left, sr.y(), width, sr.height()), gr1TopColor,gr1BottomColor, false);
-					renderGradient(p, QRect(left2, sr.y(), width2, sr.height()), gr2TopColor,gr2BottomColor, false);
+					renderGradient(p, TQRect(left, sr.y(), width, sr.height()), gr1TopColor,gr1BottomColor, false);
+					renderGradient(p, TQRect(left2, sr.y(), width2, sr.height()), gr2TopColor,gr2BottomColor, false);
 				}
 			default:
 				break;
@@ -1302,11 +1302,11 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 		p->setClipping(false);
 		
 		
-		const QColor color1 = alphaBlendColors(buttonContour->color1(), backgroundColor, qAlpha(buttonContour->color1())); // 1.top
-		const QColor color4 = alphaBlendColors(buttonContour->color4(), backgroundColor, qAlpha(buttonContour->color4())); // 3.bottom
-		const QColor color5 = alphaBlendColors(buttonContour->color5(), backgroundColor, qAlpha(buttonContour->color5())); // 4.bottom
-		const QColor color2 = alphaBlendColors(buttonContour->color2(), backgroundColor, qAlpha(buttonContour->color2())); // 2.top 2.left  2.bottom
-		const QColor color6 = alphaBlendColors(buttonContour->color6(), backgroundColor, qAlpha(buttonContour->color6())); // 1.left
+		const TQColor color1 = alphaBlendColors(buttonContour->color1(), backgroundColor, tqAlpha(buttonContour->color1())); // 1.top
+		const TQColor color4 = alphaBlendColors(buttonContour->color4(), backgroundColor, tqAlpha(buttonContour->color4())); // 3.bottom
+		const TQColor color5 = alphaBlendColors(buttonContour->color5(), backgroundColor, tqAlpha(buttonContour->color5())); // 4.bottom
+		const TQColor color2 = alphaBlendColors(buttonContour->color2(), backgroundColor, tqAlpha(buttonContour->color2())); // 2.top 2.left  2.bottom
+		const TQColor color6 = alphaBlendColors(buttonContour->color6(), backgroundColor, tqAlpha(buttonContour->color6())); // 1.left
 		
 		
 		if(roundUpperLeft)
@@ -1377,11 +1377,11 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 	}
 	else if(isScrollBarBtn) {
 		
-		QColor background;
-		QColor gr1TopColor;
-		QColor gr1BottomColor;
-		QColor gr2TopColor;
-		QColor gr2BottomColor;
+		TQColor background;
+		TQColor gr1TopColor;
+		TQColor gr1BottomColor;
+		TQColor gr2TopColor;
+		TQColor gr2BottomColor;
 		
 		
 		if(contour != appButtonColor) {
@@ -1399,9 +1399,9 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 			background = scrollBarSurface.background;
 		}
 		
-		QColor btnContour = buttonContour->contourColor(Contour_Default);
-		QColor whiteColor( qRgba(Qt::white.red(), Qt::white.green(), Qt::white.blue(), 23)); // first white layer
-		QColor blackColor( qRgba(btnContour.red(), btnContour.green(), btnContour.blue(), 35)); // second contour layer
+		TQColor btnContour = buttonContour->contourColor(Contour_Default);
+		TQColor whiteColor( tqRgba(TQt::white.red(), TQt::white.green(), TQt::white.blue(), 23)); // first white layer
+		TQColor blackColor( tqRgba(btnContour.red(), btnContour.green(), btnContour.blue(), 35)); // second contour layer
 		
 		
 		gr1TopColor = blendColors(gr1TopColor, whiteColor);
@@ -1422,20 +1422,20 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 		
 		
 		
-		QRegion clip;
+		TQRegion clip;
 		if(drawTop)
-			clip += QRegion(r.left(), r.top()+1, r.width(), 1);
+			clip += TQRegion(r.left(), r.top()+1, r.width(), 1);
 		if(drawBottom)
-			clip += QRegion(r.left(), r.bottom()-1, r.width(), 1);
+			clip += TQRegion(r.left(), r.bottom()-1, r.width(), 1);
 		if(drawLeft)
-			clip += QRegion(r.left()+1, r.top(), 1, r.height());
+			clip += TQRegion(r.left()+1, r.top(), 1, r.height());
 		if(drawRight)
-			clip += QRegion(r.right()-1, r.top(), 1, r.height());
+			clip += TQRegion(r.right()-1, r.top(), 1, r.height());
 		
 		p->setClipRegion(clip);
 		
 		
-		QRect sr = r;
+		TQRect sr = r;
 		int top = sr.y()+sr.height()*scrollBarSurface.g1Top/100;
 		int bottom = sr.height()*scrollBarSurface.g1Bottom/100;
 		int top2 = sr.y()+sr.height()*scrollBarSurface.g2Top/100;
@@ -1449,18 +1449,18 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 		switch(scrollBarSurface.numGradients) {
 			case 1:
 				if(isHorizontal)
-					renderGradient(p, QRect(sr.x(), top, sr.width(), bottom), gr1TopColor, gr1BottomColor, true);
+					renderGradient(p, TQRect(sr.x(), top, sr.width(), bottom), gr1TopColor, gr1BottomColor, true);
 				else
-					renderGradient(p, QRect(left, sr.y(), width, sr.height()), gr1TopColor, gr1BottomColor, false);
+					renderGradient(p, TQRect(left, sr.y(), width, sr.height()), gr1TopColor, gr1BottomColor, false);
 				break;
 			case 2:
 				if(isHorizontal) {
-					renderGradient(p, QRect(r.x(), top, r.width(), bottom), gr1TopColor, gr1BottomColor, true);
-					renderGradient(p, QRect(r.x(), top2, r.width(), bottom2), gr2TopColor, gr2BottomColor, true);
+					renderGradient(p, TQRect(r.x(), top, r.width(), bottom), gr1TopColor, gr1BottomColor, true);
+					renderGradient(p, TQRect(r.x(), top2, r.width(), bottom2), gr2TopColor, gr2BottomColor, true);
 				}
 				else {
-					renderGradient(p, QRect(left, sr.y(), width, sr.height()), gr1TopColor,gr1BottomColor, false);
-					renderGradient(p, QRect(left2, sr.y(), width2, sr.height()), gr2TopColor,gr2BottomColor, false);
+					renderGradient(p, TQRect(left, sr.y(), width, sr.height()), gr1TopColor,gr1BottomColor, false);
+					renderGradient(p, TQRect(left2, sr.y(), width2, sr.height()), gr2TopColor,gr2BottomColor, false);
 				}
 			default:
 				break;
@@ -1469,8 +1469,8 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 		
 		
 		
-		QColor color1 = alphaBlendColors(buttonContour->contourColor(Contour_Default), backgroundColor, 203); // like btn contour
-		QColor color2 = alphaBlendColors(QColor(255, 255, 255), color1, 25);
+		TQColor color1 = alphaBlendColors(buttonContour->contourColor(Contour_Default), backgroundColor, 203); // like btn contour
+		TQColor color2 = alphaBlendColors(TQColor(255, 255, 255), color1, 25);
 		
 		p->setPen(color1);
 		if(drawTop) {
@@ -1490,20 +1490,20 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 		color1 = blendColors(color1, whiteColor);
 		p->setPen(color2);
 		if(roundUpperLeft) {
-			renderPixel(p, QPoint(r.x()+1, r.y()+1), 127, color1, color1, true);
+			renderPixel(p, TQPoint(r.x()+1, r.y()+1), 127, color1, color1, true);
 			p->drawPoint(r.x(), r.y());
 		}
 		if(roundUpperRight) {
-			renderPixel(p, QPoint(r.right()-1, r.top()+1), 127, color1, color1, true);
+			renderPixel(p, TQPoint(r.right()-1, r.top()+1), 127, color1, color1, true);
 			p->drawPoint(r.right(), r.y());
 			
 		}
 		if(roundBottomLeft) {
-			renderPixel(p, QPoint(r.x()+1, r.bottom()-1), 127, color1, color1, true);
+			renderPixel(p, TQPoint(r.x()+1, r.bottom()-1), 127, color1, color1, true);
 			p->drawPoint(r.x(), r.bottom());
 		}
 		if(roundBottomRight) {
-			renderPixel(p, QPoint(r.right()-1, r.bottom()-1), 127, color1, color1, true);
+			renderPixel(p, TQPoint(r.right()-1, r.bottom()-1), 127, color1, color1, true);
 			p->drawPoint(r.right(), r.bottom());
 		}
 	}
@@ -1511,11 +1511,11 @@ void DominoStyle::renderContour(QPainter *p, const QRect &r, const QColor &backg
 }
 
 
-void DominoStyle::renderSurface(QPainter *p,
-								 const QRect &r,
-								 const QColor &backgroundColor,
-								 const QColor &buttonColor,
-								 const QColor &/*highlightColor*/,
+void DominoStyle::renderSurface(TQPainter *p,
+								 const TQRect &r,
+								 const TQColor &backgroundColor,
+								 const TQColor &buttonColor,
+								 const TQColor &/*highlightColor*/,
 								 const uint flags) const
 {
 	
@@ -1558,13 +1558,13 @@ void DominoStyle::renderSurface(QPainter *p,
 	
 	
 	
-	QColor g1Color1;
-	QColor g1Color2;
-	QColor g2Color1;
-	QColor g2Color2;
-	QColor background;
+	TQColor g1Color1;
+	TQColor g1Color2;
+	TQColor g2Color1;
+	TQColor g2Color2;
+	TQColor background;
 
-	if(buttonColor != qApp->palette().active().button()) {
+	if(buttonColor != tqApp->palette().active().button()) {
 		g2Color1 = alphaBlendColors(buttonColor, ds->g2Color1, 127);
 		g2Color2 = alphaBlendColors(buttonColor, ds->g2Color2, 127);
 		g1Color1 = alphaBlendColors(buttonColor, ds->g1Color1, 127);
@@ -1589,26 +1589,26 @@ void DominoStyle::renderSurface(QPainter *p,
 	if(isButton) { // button / toolButton / comboBox / spinWidget / slider / progressBar
 		
 		if(!flatMode) {
-			QRegion mask(r.x()+2, r.y(), r.width()-4, r.height());
-			mask += QRegion(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
-			mask += QRegion(r.x(), r.y()+2, r.width(), r.height()-4);
-			p->setClipRegion(mask, QPainter::CoordPainter);
+			TQRegion mask(r.x()+2, r.y(), r.width()-4, r.height());
+			mask += TQRegion(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
+			mask += TQRegion(r.x(), r.y()+2, r.width(), r.height()-4);
+			p->setClipRegion(mask, TQPainter::CoordPainter);
 		}
 		
 		
-		QRect re = r;
+		TQRect re = r;
 		if(re.x() < 0 ) {
-			re.setWidth(re.width()+QABS(re.x()));
+			re.setWidth(re.width()+TQABS(re.x()));
 			re.setX(0);
 		}
 		else if(re.y() < 0 ) {
-			re.setHeight(re.height()+QABS(re.y()));
+			re.setHeight(re.height()+TQABS(re.y()));
 			re.setY(0);
 		}
 
-		QPixmap pix(re.width(), re.height());
+		TQPixmap pix(re.width(), re.height());
 		pix.fill(background);
-		QPainter painter(&pix);
+		TQPainter painter(&pix);
 
 		int top = re.height()*btnSurface.g1Top/100;
 		int bottom = re.height()*btnSurface.g1Bottom/100;
@@ -1623,21 +1623,21 @@ void DominoStyle::renderSurface(QPainter *p,
 		switch (btnSurface.numGradients) {
 			case 1:{
 				if(horizontal) {
-					renderGradient(&painter, QRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
+					renderGradient(&painter, TQRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
 				}
 				else {
-					renderGradient(&painter, QRect(left, 0, width, re.height()), g1Color1, g1Color2, false);
+					renderGradient(&painter, TQRect(left, 0, width, re.height()), g1Color1, g1Color2, false);
 				}
 				break;
 			}
 			case 2: {
 				if(horizontal) {
-					renderGradient(&painter, QRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
-					renderGradient(&painter, QRect(0, top2, re.width(), bottom2), g2Color1, g2Color2, true);
+					renderGradient(&painter, TQRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
+					renderGradient(&painter, TQRect(0, top2, re.width(), bottom2), g2Color1, g2Color2, true);
 				}
 				else {
-					renderGradient(&painter, QRect(left, 0, width, re.height()), g1Color1, g1Color2, false);
-					renderGradient(&painter, QRect(left2, 0, width2, re.height()), g2Color1, g2Color2, false);
+					renderGradient(&painter, TQRect(left, 0, width, re.height()), g1Color1, g1Color2, false);
+					renderGradient(&painter, TQRect(left2, 0, width2, re.height()), g2Color1, g2Color2, false);
 				}
 			}
 			default: break;
@@ -1657,12 +1657,12 @@ void DominoStyle::renderSurface(QPainter *p,
 		p->fillRect(r, background);
 		switch (ds->numGradients) {
 			case 1:{
-				renderGradient(p, QRect(r.x(), top, r.width(), bottom), g1Color1, g1Color2, true);
+				renderGradient(p, TQRect(r.x(), top, r.width(), bottom), g1Color1, g1Color2, true);
 				break;
 			}
 			case 2: {
-				renderGradient(p, QRect(r.x(), top, r.width(), bottom), g1Color1, g1Color2, true);
-				renderGradient(p, QRect(r.x(), top2, r.width(), bottom2), g2Color1, g2Color2, true);
+				renderGradient(p, TQRect(r.x(), top, r.width(), bottom), g1Color1, g1Color2, true);
+				renderGradient(p, TQRect(r.x(), top2, r.width(), bottom2), g2Color1, g2Color2, true);
 			}
 			default: break;
 		}
@@ -1682,21 +1682,21 @@ void DominoStyle::renderSurface(QPainter *p,
 		switch (scrollBarSurface.numGradients) {
 			case 1: {
 				if(horizontal) {
-					renderGradient(p, QRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
+					renderGradient(p, TQRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
 				}
 				else {
-					renderGradient(p, QRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
+					renderGradient(p, TQRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
 				}
 				break;
 			}
 			case 2: {
 				if(horizontal) {
-					renderGradient(p, QRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
-					renderGradient(p, QRect(r.left(),  top2, r.width(), bottom2), g2Color1, g2Color2, true);
+					renderGradient(p, TQRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
+					renderGradient(p, TQRect(r.left(),  top2, r.width(), bottom2), g2Color1, g2Color2, true);
 				}
 				else {
-					renderGradient(p, QRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
-					renderGradient(p, QRect(left2, r.top(), width2, r.height()), g2Color1, g2Color2, false);
+					renderGradient(p, TQRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
+					renderGradient(p, TQRect(left2, r.top(), width2, r.height()), g2Color1, g2Color2, false);
 				}
 			}
 			default:
@@ -1720,21 +1720,21 @@ void DominoStyle::renderSurface(QPainter *p,
 		switch (scrollBarGrooveSurface.numGradients) {
 			case 1: {
 				if(horizontal) {
-					renderGradient(p, QRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
+					renderGradient(p, TQRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
 				}
 				else {
-					renderGradient(p, QRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
+					renderGradient(p, TQRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
 				}
 				break;
 			}
 			case 2: {
 				if(horizontal) {
-					renderGradient(p, QRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
-					renderGradient(p, QRect(r.left(),  top2, r.width(), bottom2), g2Color1, g2Color2, true);
+					renderGradient(p, TQRect(r.left(), top, r.width(), bottom), g1Color1, g1Color2, true);
+					renderGradient(p, TQRect(r.left(),  top2, r.width(), bottom2), g2Color1, g2Color2, true);
 				}
 				else {
-					renderGradient(p, QRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
-					renderGradient(p, QRect(left2, r.top(), width2, r.height()), g2Color1, g2Color2, false);
+					renderGradient(p, TQRect(left, r.top(), width, r.height()), g1Color1, g1Color2, false);
+					renderGradient(p, TQRect(left2, r.top(), width2, r.height()), g2Color1, g2Color2, false);
 				}
 			}
 			default:
@@ -1744,9 +1744,9 @@ void DominoStyle::renderSurface(QPainter *p,
 	}
 	else if(isCheckItem) {
 		
-		QPixmap pix(r.width(), r.height());
+		TQPixmap pix(r.width(), r.height());
 		pix.fill(background);
-		QPainter painter(&pix);
+		TQPainter painter(&pix);
 
 		int top = r.height()*checkItemSurface.g1Top/100;
 		int bottom = r.height()*checkItemSurface.g1Bottom/100;
@@ -1755,29 +1755,29 @@ void DominoStyle::renderSurface(QPainter *p,
 		
 		switch(checkItemSurface.numGradients) {
 			case 1:{
-				renderGradient(&painter, QRect(0, top, r.width(), bottom), g1Color1, g1Color2, true);
+				renderGradient(&painter, TQRect(0, top, r.width(), bottom), g1Color1, g1Color2, true);
 				break;
 			}
 			case 2: {
-				renderGradient(&painter, QRect(0, top, r.width(), bottom), g1Color1, g1Color2, true);
-				renderGradient(&painter, QRect(0, top2, r.width(), bottom2), g2Color1, g2Color2, true);
+				renderGradient(&painter, TQRect(0, top, r.width(), bottom), g1Color1, g1Color2, true);
+				renderGradient(&painter, TQRect(0, top2, r.width(), bottom2), g2Color1, g2Color2, true);
 				break;
 			}
 			default: break;
 		}
 		painter.end();
-		p->drawPixmap(QRect(r.x(), r.y()+3, r.width(), r.height()-7), pix);
+		p->drawPixmap(TQRect(r.x(), r.y()+3, r.width(), r.height()-7), pix);
 		
 	}
 	else if(isHeader) {
-		QHeader* hdr = dynamic_cast<QHeader*>(p->device());
+		TQHeader* hdr = dynamic_cast<TQHeader*>(p->device());
 		bool needErasePixmap = false;
-		QRect re = r;
+		TQRect re = r;
 		bool horizontal = false;
 		bool drawTop = false;
 		
 		if(hdr) {
-			if(hdr->orientation() == Qt::Horizontal) {
+			if(hdr->orientation() == TQt::Horizontal) {
 				horizontal = true;
 				bool hasErasePixmap = hdr->erasePixmap();
 				if(hasErasePixmap && !isDown) {
@@ -1786,16 +1786,16 @@ void DominoStyle::renderSurface(QPainter *p,
 				}
 				else if(!hasErasePixmap && !isDown) {
 					needErasePixmap = true;
-					re = QRect(0, 0, 10, r.height());
+					re = TQRect(0, 0, 10, r.height());
 				}
 			}
 			else if(hdr->sectionAt(r.top()+hdr->offset()) == 0 && r.y() == 0)
 				drawTop = true;
 		}
 		
-		QPixmap pix(re.width(), re.height());
+		TQPixmap pix(re.width(), re.height());
 		pix.fill(background);
-		QPainter painter(&pix);
+		TQPainter painter(&pix);
 		
 		int top = re.height()*headerSurface.g1Top/100;
 		int bottom = re.height()*headerSurface.g1Bottom/100;
@@ -1804,12 +1804,12 @@ void DominoStyle::renderSurface(QPainter *p,
 		
 		switch (headerSurface.numGradients) {
 			case 1:{
-				renderGradient(&painter, QRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
+				renderGradient(&painter, TQRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
 				break;
 			}
 			case 2: {
-				renderGradient(&painter, QRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
-				renderGradient(&painter, QRect(0, top2, re.width(), bottom2), g2Color1, g2Color2, true);
+				renderGradient(&painter, TQRect(0, top, re.width(), bottom), g1Color1, g1Color2, true);
+				renderGradient(&painter, TQRect(0, top2, re.width(), bottom2), g2Color1, g2Color2, true);
 				break;
 			}
 			default: break;
@@ -1836,17 +1836,17 @@ void DominoStyle::renderSurface(QPainter *p,
 }
 
 
-void DominoStyle::renderPixel(QPainter *p,
-			const QPoint &pos,
+void DominoStyle::renderPixel(TQPainter *p,
+			const TQPoint &pos,
 			const int alpha,
-			const QColor &color,
-			const QColor &background,
+			const TQColor &color,
+			const TQColor &background,
 			bool fullAlphaBlend) const
 {	 
 	if(fullAlphaBlend)
 	// full alpha blend: paint into an image with alpha buffer and convert to a pixmap ...
 	{
-		QRgb rgb = color.rgb();
+		TQRgb rgb = color.rgb();
 		// generate a quite unique key -- use the unused width field to store the alpha value.
 		CacheEntry search(cAlphaDot, alpha, 0, rgb);
 		int key = search.key();
@@ -1863,10 +1863,10 @@ void DominoStyle::renderPixel(QPainter *p,
 		}
 
 
-		QImage aImg(1,1,32); // 1x1
+		TQImage aImg(1,1,32); // 1x1
 		aImg.setAlphaBuffer(true);
-		aImg.setPixel(0,0,qRgba(qRed(rgb),qGreen(rgb),qBlue(rgb),alpha));
-		QPixmap *result = new QPixmap(aImg);
+		aImg.setPixel(0,0,tqRgba(tqRed(rgb),tqGreen(rgb),tqBlue(rgb),alpha));
+		TQPixmap *result = new TQPixmap(aImg);
 
 		p->drawPixmap(pos, *result);
 
@@ -1879,49 +1879,49 @@ void DominoStyle::renderPixel(QPainter *p,
 	} else
 	// don't use an alpha buffer: calculate the resulting color from the alpha value, the fg- and the bg-color.
 	{
-		QRgb rgb_a = color.rgb();
-		QRgb rgb_b = background.rgb();
+		TQRgb rgb_a = color.rgb();
+		TQRgb rgb_b = background.rgb();
 		int a = alpha;
 		if(a>255) a = 255;
 		if(a<0) a = 0;
 		int a_inv = 255 - a;
 
-		QColor res	= QColor( qRgb(qRed(rgb_b)*a_inv/255 + qRed(rgb_a)*a/255,
-							  qGreen(rgb_b)*a_inv/255 + qGreen(rgb_a)*a/255,
-							  qBlue(rgb_b)*a_inv/255 + qBlue(rgb_a)*a/255) );
+		TQColor res	= TQColor( tqRgb(tqRed(rgb_b)*a_inv/255 + tqRed(rgb_a)*a/255,
+							  tqGreen(rgb_b)*a_inv/255 + tqGreen(rgb_a)*a/255,
+							  tqBlue(rgb_b)*a_inv/255 + tqBlue(rgb_a)*a/255) );
 		p->setPen(res);
 		p->drawPoint(pos);
 	} 
 }
 
-void DominoStyle::renderButtonShadow(QPainter *p, const QRect &r, const uint flags) const {
+void DominoStyle::renderButtonShadow(TQPainter *p, const TQRect &r, const uint flags) const {
 	
 	if((!buttonContour->drawButtonSunkenShadow && buttonContour->defaultType == Contour_Sunken) || (buttonContour->defaultType != Contour_Sunken && !flatMode))
 		return;
 	
 	
 	if(flags&Round_UpperLeft) {
-		bitBlt(p->device(), r.left(), r.top(), buttonContour->shadowRound(), 0, 0, 5, 5, Qt::CopyROP);
+		bitBlt(p->device(), r.left(), r.top(), buttonContour->shadowRound(), 0, 0, 5, 5, TQt::CopyROP);
 	}
 	else if(flags&Rectangular_UpperLeft){
-		bitBlt(p->device(), r.left(), r.top(), buttonContour->shadowRectangular(), 0, 0, 5, 5, Qt::CopyROP);
+		bitBlt(p->device(), r.left(), r.top(), buttonContour->shadowRectangular(), 0, 0, 5, 5, TQt::CopyROP);
 	}
 	if(flags&Round_UpperRight) {
-		bitBlt(p->device(), r.right()-6, r.top(), buttonContour->shadowRound(), 5, 0, 5, 5, Qt::CopyROP);
+		bitBlt(p->device(), r.right()-6, r.top(), buttonContour->shadowRound(), 5, 0, 5, 5, TQt::CopyROP);
 	}
 	else if(flags&Rectangular_UpperRight){
-		bitBlt(p->device(), r.right()-6, r.top(), buttonContour->shadowRectangular(), 5, 0, 5, 5, Qt::CopyROP);
+		bitBlt(p->device(), r.right()-6, r.top(), buttonContour->shadowRectangular(), 5, 0, 5, 5, TQt::CopyROP);
 	}
 	if(flags&Round_BottomLeft) {
-		bitBlt(p->device(), r.left(), r.bottom()-5, buttonContour->shadowRound(), 0, 5, 4, 4, Qt::CopyROP);
+		bitBlt(p->device(), r.left(), r.bottom()-5, buttonContour->shadowRound(), 0, 5, 4, 4, TQt::CopyROP);
 	}
 	else if(flags&Rectangular_BottomLeft)
-		bitBlt(p->device(), r.left(), r.bottom()-5, buttonContour->shadowRectangular(), 0, 5, 4, 4, Qt::CopyROP);
+		bitBlt(p->device(), r.left(), r.bottom()-5, buttonContour->shadowRectangular(), 0, 5, 4, 4, TQt::CopyROP);
 	if(flags&Round_BottomRight) {
-		bitBlt(p->device(), r.right()-5, r.bottom()-5, buttonContour->shadowRound(), 4, 5, 4, 4, Qt::CopyROP);
+		bitBlt(p->device(), r.right()-5, r.bottom()-5, buttonContour->shadowRound(), 4, 5, 4, 4, TQt::CopyROP);
 	}
 	else if(flags&Rectangular_BottomRight)
-		bitBlt(p->device(), r.right()-5, r.bottom()-5, buttonContour->shadowRectangular(), 4, 5, 4, 4, Qt::CopyROP);
+		bitBlt(p->device(), r.right()-5, r.bottom()-5, buttonContour->shadowRectangular(), 4, 5, 4, 4, TQt::CopyROP);
 	
 	if(flags&Draw_Top)
 		p->drawTiledPixmap(r.left()+5, r.top(), r.width()-12, 3, *buttonContour->shadowHLines(), 0, 0);
@@ -1934,9 +1934,9 @@ void DominoStyle::renderButtonShadow(QPainter *p, const QRect &r, const uint fla
 	
 }
 
-void DominoStyle::renderButton(QPainter *p,
-							   const QRect &r,
-							   const QColorGroup &g,
+void DominoStyle::renderButton(TQPainter *p,
+							   const TQRect &r,
+							   const TQColorGroup &g,
 							   bool sunken,
 							   bool /*mouseOver*/,
 							   bool horizontal,
@@ -1966,29 +1966,29 @@ void DominoStyle::renderButton(QPainter *p,
 		}
 	}
 
-// 	QColor buttonColor = khtmlMode ? g.button() : qApp->palette().active().background();
+// 	TQColor buttonColor = khtmlMode ? g.button() : tqApp->palette().active().background();
 	
 	if (!flatMode) {
 		contourFlags |= Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight|Is_Button;
-		renderSurface(p, QRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), g.background(), g.button(), g.button(), surfaceFlags);
+		renderSurface(p, TQRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), g.background(), g.button(), g.button(), surfaceFlags);
 		renderContour(p, r, g.background(), g.button(), contourFlags);
 		if(sunken) {
-			renderButtonShadow(p, QRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
+			renderButtonShadow(p, TQRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
 		}
 	}
 	else {
-		renderSurface(p, QRect(r.x()-3, r.y()-1, r.width()+6, r.height()+2), g.background(), g.button(), g.button(), surfaceFlags);
+		renderSurface(p, TQRect(r.x()-3, r.y()-1, r.width()+6, r.height()+2), g.background(), g.button(), g.button(), surfaceFlags);
 
 		if(sunken) {
 			contourFlags |= Rectangular_UpperLeft|Rectangular_UpperRight|Rectangular_BottomLeft|Rectangular_BottomRight;
-			renderButtonShadow(p, QRect(r.x()-2, r.y()-2, r.width()+4, r.height()+4), contourFlags);
+			renderButtonShadow(p, TQRect(r.x()-2, r.y()-2, r.width()+4, r.height()+4), contourFlags);
 		}
 	}
 }
 
-void DominoStyle::renderHeader(QPainter *p,
-								const QRect &r,
-								const QColorGroup &g,
+void DominoStyle::renderHeader(TQPainter *p,
+								const TQRect &r,
+								const TQColorGroup &g,
 								bool sunken,
 								bool /*mouseOver*/,
 								bool /*horizontal*/,
@@ -1996,14 +1996,14 @@ void DominoStyle::renderHeader(QPainter *p,
 {
 	p->save();
 	bool drawLeft = true;
-	QHeader* hd = dynamic_cast<QHeader*>(p->device());
-	if(hd && hd->orientation() == Qt::Horizontal)
+	TQHeader* hd = dynamic_cast<TQHeader*>(p->device());
+	if(hd && hd->orientation() == TQt::Horizontal)
 		drawLeft = r.x() == 0 && hd->sectionAt(r.left()+hd->offset()) == 0;
 	
 	uint surfaceFlags = Is_Header|Is_Horizontal;
 	if(sunken)
 		surfaceFlags |= Is_Down;
-	renderSurface(p, QRect(r.left(), r.top(), r.width(), r.height()), g.button(), g.button(), g.button(), surfaceFlags);
+	renderSurface(p, TQRect(r.left(), r.top(), r.width(), r.height()), g.button(), g.button(), g.button(), surfaceFlags);
 	
 // 	p->setPen(buttonContour->contourColor(Contour_Default));
 	p->setPen(alphaBlendColors(buttonContour->contourColor(Contour_Default), g.background(), 179));
@@ -2016,10 +2016,10 @@ void DominoStyle::renderHeader(QPainter *p,
 }
 
 
-void DominoStyle::renderGradient(QPainter *painter,
-								  const QRect &rect,
-								  const QColor &c1,
-								  const QColor &c2,
+void DominoStyle::renderGradient(TQPainter *painter,
+								  const TQRect &rect,
+								  const TQColor &c1,
+								  const TQColor &c2,
 								  bool horizontal) const
 {
 	if((rect.width() <= 0)||(rect.height() <= 0))
@@ -2047,9 +2047,9 @@ void DominoStyle::renderGradient(QPainter *painter,
 	}
 
 	// there wasn't anything matching in the cache, create the pixmap now...
-	QPixmap *result = new QPixmap(horizontal ? 10 : rect.width(),
+	TQPixmap *result = new TQPixmap(horizontal ? 10 : rect.width(),
 								  horizontal ? rect.height() : 10);
-	QPainter p(result);
+	TQPainter p(result);
 
 	int r_w = result->rect().width();
 	int r_h = result->rect().height();
@@ -2081,7 +2081,7 @@ void DominoStyle::renderGradient(QPainter *painter,
 			gl += gdelta;
 			bl += bdelta;
 
-			p.setPen(QColor(rl>>16, gl>>16, bl>>16));
+			p.setPen(TQColor(rl>>16, gl>>16, bl>>16));
 			p.drawLine(r_x, r_y+y, r_x2, r_y+y);
 		}
 	} else {
@@ -2090,7 +2090,7 @@ void DominoStyle::renderGradient(QPainter *painter,
 			gl += gdelta;
 			bl += bdelta;
 
-			p.setPen(QColor(rl>>16, gl>>16, bl>>16));
+			p.setPen(TQColor(rl>>16, gl>>16, bl>>16));
 			p.drawLine(r_x+x, r_y, r_x+x, r_y2);
 		}
 	}
@@ -2109,9 +2109,9 @@ void DominoStyle::renderGradient(QPainter *painter,
 		delete result;
 }
 
-void DominoStyle::renderTab(QPainter *p,
-							const QRect &r,
-							const QColorGroup &g,
+void DominoStyle::renderTab(TQPainter *p,
+							const TQRect &r,
+							const TQColorGroup &g,
 							bool /*mouseOver*/,
 							const bool selected,
 							const bool bottom,
@@ -2125,35 +2125,35 @@ void DominoStyle::renderTab(QPainter *p,
 	const bool isLast = (pos == Last);
 	const bool isSingle = (pos == Single);
 	
-	QPixmap buffer(r.width(), r.height());
-	QPainter painter(&buffer);
+	TQPixmap buffer(r.width(), r.height());
+	TQPainter painter(&buffer);
 	
-	QColor tabContour2 = g.background().dark(150);
-	QPixmap* tabEdges;
-	if(!(tabEdges = QPixmapCache::find(QString::number(tabContour2.pixel(), 16)+"tabEdges"))) {
-		QImage img1 = tintImage(qembed_findImage("border1"), tabContour2);
-		QImage img2 = qembed_findImage("tabInsideWhite");
+	TQColor tabContour2 = g.background().dark(150);
+	TQPixmap* tabEdges;
+	if(!(tabEdges = TQPixmapCache::find(TQString::number(tabContour2.pixel(), 16)+"tabEdges"))) {
+		TQImage img1 = tintImage(qembed_findImage("border1"), tabContour2);
+		TQImage img2 = qembed_findImage("tabInsideWhite");
 		blend(img1, img2, img2);
-		tabEdges = new QPixmap(img2);
-		QPixmapCache::insert(QString::number(tabContour2.pixel(), 16)+"tabEdges", tabEdges);
+		tabEdges = new TQPixmap(img2);
+		TQPixmapCache::insert(TQString::number(tabContour2.pixel(), 16)+"tabEdges", tabEdges);
 	}
 	
-	QPixmap* tabHLines;
-	if(!(tabHLines = QPixmapCache::find("tabHLines"))) {
-		tabHLines = new QPixmap(qembed_findImage("tabHLines"));
-		QPixmapCache::insert("tabHLines", tabHLines);
+	TQPixmap* tabHLines;
+	if(!(tabHLines = TQPixmapCache::find("tabHLines"))) {
+		tabHLines = new TQPixmap(qembed_findImage("tabHLines"));
+		TQPixmapCache::insert("tabHLines", tabHLines);
 	}
 	
-	QPixmap* tabVLines;
-	if(!(tabVLines = QPixmapCache::find("tabVLines"))) {
-		tabVLines = new QPixmap(qembed_findImage("tabVLines"));
-		QPixmapCache::insert("tabVLines", tabVLines);
+	TQPixmap* tabVLines;
+	if(!(tabVLines = TQPixmapCache::find("tabVLines"))) {
+		tabVLines = new TQPixmap(qembed_findImage("tabVLines"));
+		TQPixmapCache::insert("tabVLines", tabVLines);
 	}
 	
 	
 	if(konqTab) {
 		
-		const QColor background = g.background().dark(konqTabBarContrast);
+		const TQColor background = g.background().dark(konqTabBarContrast);
 		
 		if (selected) {
 			
@@ -2162,76 +2162,76 @@ void DominoStyle::renderTab(QPainter *p,
 			painter.fillRect(0, 0, r.width(), 2, g.background()); // rect above gradient
 			
 			painter.translate(0, 2);
-			renderSurface(&painter, QRect(1, 0, r.width()-2, r.height()-3), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
+			renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-3), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
 			painter.translate(0, -2);
 
 			
-			QPixmap* tabEdges2;
-			QString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
-			if(!(tabEdges2 = QPixmapCache::find(position+"tabEdges2-k-sel"+QString::number(g.background().pixel(), 16)+QString::number(r.height())))) {
-				tabEdges2 = new QPixmap(16, 8);
+			TQPixmap* tabEdges2;
+			TQString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
+			if(!(tabEdges2 = TQPixmapCache::find(position+"tabEdges2-k-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
+				tabEdges2 = new TQPixmap(16, 8);
 				tabEdges2->fill(background);
-				QPainter painter2(tabEdges2);
+				TQPainter painter2(tabEdges2);
 				
 				// parts of the unselected tabs under the rounded edges
 				if(!isSingle) {
 					if(!isFirst) {
 						painter2.translate(0, -r.height()+12);
-						renderSurface(&painter2, QRect(0, 0, 3, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
+						renderSurface(&painter2, TQRect(0, 0, 3, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
 						painter2.resetXForm();
 						painter2.drawTiledPixmap(0, 3, 3, 1, *tabHLines, 0, 2); // left
-						painter2.setPen(alphaBlendColors(QColor(0,0,0), background, 79)); // bottomShadow1
+						painter2.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
 						painter2.drawLine(0, 4, 1, 4);
-						painter2.setPen(alphaBlendColors(QColor(0,0,0), background, 30)); // bottomShadow2
+						painter2.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
 						painter2.drawPoint(2,4); // last point from bottomShadow1 a tad lighter (will be overpainted by the circle)
 						painter2.drawLine(0, 5, 3, 5);
 					}
 					if(!isLast) {
 						painter2.translate(0, -r.height()+12);
-						renderSurface(&painter2, QRect(13, 0, 3, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
+						renderSurface(&painter2, TQRect(13, 0, 3, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
 						painter2.resetXForm();
 						painter2.drawTiledPixmap(13, 3, 3, 1, *tabHLines, 0, 2); // right
-						painter2.setPen(alphaBlendColors(QColor(0,0,0), background, 79)); // bottomShadow1
+						painter2.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
 						painter2.drawLine(14, 4, 15, 4);
-						painter2.setPen(alphaBlendColors(QColor(0,0,0), background, 30)); // bottomShadow2
+						painter2.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
 						painter2.drawPoint(13,4);
 						painter2.drawLine(12, 5, 15, 5);
 					}
 				}
 				// fill the rect under the gradients (faster as clipping the gradients)
-				painter2.fillRect(QRect(0, 6, 16, 2), background);
+				painter2.fillRect(TQRect(0, 6, 16, 2), background);
 				painter2.end();
 				
-				QPixmap tabEdgesMask = qembed_findImage("groupBoxMask"); // this fits because the tab frame is just an inverted groupbox frame, but pssst ;)
+				TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask"); // this fits because the tab frame is just an inverted groupbox frame, but pssst ;)
 				painter2.begin(&tabEdgesMask);
 				painter2.translate(0, -r.height()+19);
-				renderSurface(&painter2, QRect(0, 0, 16, r.height()-3), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
+				renderSurface(&painter2, TQRect(0, 0, 16, r.height()-3), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
 				painter2.end();
 				bitBlt(tabEdges2, 0, 0, &tabEdgesMask, 0, 8);
 				
-				QPixmap circle = qembed_findImage("tabWidget");
+				TQPixmap circle = qembed_findImage("tabWidget");
 				bitBlt(tabEdges2, 0, 0, &circle, 0, 8);
 				
-				QPixmapCache::insert(position+"tabEdges2-k-sel"+QString::number(g.background().pixel(), 16)+QString::number(r.height()), tabEdges2);
+				TQPixmapCache::insert(position+"tabEdges2-k-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
 			}
 			
 			
 			
-			painter.setPen(alphaBlendColors(QColor(0,0,0), background, 79)); // bottomShadow1
+			painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
 			painter.drawLine(8, r.height()-3, r.width()-9, r.height()-3);
-			painter.setPen(alphaBlendColors(QColor(0,0,0), background, 30)); // bottomShadow2
+			painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
 			painter.drawLine(8, r.height()-2, r.width()-9, r.height()-2);
 			
-			painter.setPen(alphaBlendColors(QColor(0,0,0), background, 35));
+			painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 35));
 			painter.translate(0,3);
 			if(isFirst || isSingle)
 				painter.drawLine(0, -1, 0, r.height()-13); // left
 			else
-				renderTabSeparator(&painter, QRect(0, 0, 1, r.height()-5-3), g.button(), false);
+				renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5-3), g.button(), false);
 			if(isLast || isSingle)
 				painter.drawLine(r.width()-1, -1, r.width()-1, r.height()-13); // right
 			else
-				renderTabSeparator(&painter, QRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);
+				renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);
 			painter.translate(0,-3);
 			
 			bitBlt(&buffer, 0, r.height()-9, tabEdges2, 0, 0, 8, 8);
@@ -2243,14 +2243,14 @@ void DominoStyle::renderTab(QPainter *p,
 			
 			
 			
-			painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 20));
+			painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 20));
 			painter.drawPoint(0,1);
 			painter.drawPoint(r.width()-1,1);
-			painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 50));
+			painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 50));
 			painter.drawPoint(0,2);
 			painter.drawPoint(r.width()-1,2);
-			//QColor tmp = alphaBlendColors(QColor(255,255,255), g.background(), 14);
-			QColor tmp = g.background();
+			//TQColor tmp = alphaBlendColors(TQColor(255,255,255), g.background(), 14);
+			TQColor tmp = g.background();
 			painter.setPen(alphaBlendColors(tmp, activeTabBottomSurface.g1Top == 0 ? activeTabBottomSurface.g1Color1 : activeTabBottomSurface.background, 127));
 // 			painter.drawPoint(1,2);
 // 			painter.drawPoint(r.width()-2,2);
@@ -2265,9 +2265,9 @@ void DominoStyle::renderTab(QPainter *p,
 			
 			painter.setPen(g.background());// 0. tabbarline
 			painter.drawLine(0, 0, r.width(), 0);
-			painter.setPen(g.background().dark(120));//QColor(110,110,110) // 1. tabbarline
+			painter.setPen(g.background().dark(120));//TQColor(110,110,110) // 1. tabbarline
 			painter.drawLine(0, 1, r.width(), 1);
-			painter.setPen(g.background().dark(konqTabBarContrast+20)); //QColor(110,110,110)
+			painter.setPen(g.background().dark(konqTabBarContrast+20)); //TQColor(110,110,110)
 			
 			
 			// topline
@@ -2279,41 +2279,41 @@ void DominoStyle::renderTab(QPainter *p,
 			if(isFirst || isLast) {
 				
 				painter.translate(0, 3);
-				renderSurface(&painter, QRect(1, 0, r.width()-2, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
+				renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
 				painter.translate(0, -3);
 				
 				
-				QPixmap* tabEdges2;
-				if(!(tabEdges2 = QPixmapCache::find("tabEdges2-k"+QString::number(g.background().pixel(), 16)+QString::number(r.height())))) {
-					tabEdges2 = new QPixmap(16, 8);
+				TQPixmap* tabEdges2;
+				if(!(tabEdges2 = TQPixmapCache::find("tabEdges2-k"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
+					tabEdges2 = new TQPixmap(16, 8);
 					tabEdges2->fill(background);
 				
-					QPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
-					QPainter painter2(&tabEdgesMask);
+					TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
+					TQPainter painter2(&tabEdgesMask);
 					painter2.translate(0, -r.height()+19+3);
-					renderSurface(&painter2, QRect(1, 0, 14, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
+					renderSurface(&painter2, TQRect(1, 0, 14, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
 					painter2.end();
 					bitBlt(tabEdges2, 0, 0, &tabEdgesMask, 0, 8);
 				
-					QPixmap circle = qembed_findImage("tabWidget");
+					TQPixmap circle = qembed_findImage("tabWidget");
 					bitBlt(tabEdges2, 0, 0, &circle, 0, 8);
 				
-					QPixmapCache::insert("tabEdges2-k"+QString::number(g.background().pixel(), 16)+QString::number(r.height()), tabEdges2);
+					TQPixmapCache::insert("tabEdges2-k"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
 				}
 				
 				
 				if(isFirst) {
 					
 					painter.translate(0,3);
-					renderTabSeparator(&painter, QRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);// right
+					renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);// right
 					painter.translate(0,-3);
 					
-					painter.setPen(alphaBlendColors(QColor(0,0,0), background, 79)); // bottomShadow1
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
 					painter.drawLine(8, r.height()-5, r.width()-1, r.height()-5);
-					painter.setPen(alphaBlendColors(QColor(0,0,0), background, 30)); // bottomShadow2
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
 					painter.drawLine(8, r.height()-4, r.width()-1, r.height()-4);
 					
-					painter.setPen(alphaBlendColors(QColor(0,0,0), background, 35));
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 35));
 					painter.drawLine(0, 2, 0, r.height()-11); // left
 					
 					
@@ -2326,15 +2326,15 @@ void DominoStyle::renderTab(QPainter *p,
 				else {
 					
 					painter.translate(0,3);
-					renderTabSeparator(&painter, QRect(0, 0, 1, r.height()-5-3), g.button(), false); // left
+					renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5-3), g.button(), false); // left
 					painter.translate(0,-3);
 					
-					painter.setPen(alphaBlendColors(QColor(0,0,0), background, 79)); // bottomShadow1
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
 					painter.drawLine(0, r.height()-5, r.width()-8, r.height()-5);
-					painter.setPen(alphaBlendColors(QColor(0,0,0), background, 30)); // bottomShadow2
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
 					painter.drawLine(0, r.height()-4, r.width()-8, r.height()-4);
 						
-					painter.setPen(alphaBlendColors(QColor(0,0,0), background, 35));
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 35));
 					painter.drawLine(r.width()-1, 2, r.width()-1, r.height()-11); // right
 					
 					
@@ -2347,23 +2347,23 @@ void DominoStyle::renderTab(QPainter *p,
 			else { // middle
 				
 				painter.translate(0,3);
-				renderTabSeparator(&painter, QRect(0, 0, 1, r.height()-5-3), g.button(), false); // left
-				renderTabSeparator(&painter, QRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);// right
+				renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5-3), g.button(), false); // left
+				renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5-3), g.button(), false);// right
 				painter.translate(0,-3);
 				
 				painter.translate(0, 3);
-				renderSurface(&painter, QRect(1, 0, r.width()-2, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
+				renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-5-3), g.background(), g.button(), g.button(), Is_TabBottom);
 				painter.translate(0, -3);
 				
-				painter.setPen(alphaBlendColors(QColor(0,0,0), background, 79)); // bottomShadow1
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 79)); // bottomShadow1
 				painter.drawLine(0, r.height()-5, r.width()-1, r.height()-5);
-				painter.setPen(alphaBlendColors(QColor(0,0,0), background, 30)); // bottomShadow2
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), background, 30)); // bottomShadow2
 				painter.drawLine(0, r.height()-4, r.width()-1, r.height()-4);
 				
 				painter.drawTiledPixmap(0, r.height()-6, r.width(), 1, *tabHLines, 0, 2); // bottom
 				
 			}
-			painter.fillRect(QRect(0, r.height()-3, r.width(), 3), background);
+			painter.fillRect(TQRect(0, r.height()-3, r.width(), 3), background);
 		}
 		p->drawPixmap(r.left(), r.top(), buffer);
 	}
@@ -2372,71 +2372,71 @@ void DominoStyle::renderTab(QPainter *p,
 		if(bottom) {
 			if (selected) {
 	
-				renderSurface(&painter, QRect(1, 0, r.width()-2, r.height()-2), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
+				renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-2), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
 				
 				
-				QPixmap* tabEdges2;
-				QString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
-				if(!(tabEdges2 = QPixmapCache::find(position+"tabEdges2-bottom-sel"+QString::number(g.background().pixel(), 16)+QString::number(r.height())))) {
-					tabEdges2 = new QPixmap(16, 8);
+				TQPixmap* tabEdges2;
+				TQString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
+				if(!(tabEdges2 = TQPixmapCache::find(position+"tabEdges2-bottom-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
+					tabEdges2 = new TQPixmap(16, 8);
 					tabEdges2->fill(g.background());
-					QPainter painter2(tabEdges2);
+					TQPainter painter2(tabEdges2);
 					
 					if(!isSingle) {
 						if(!isFirst) {
 							painter2.translate(0, -r.height()+8);
-							renderSurface(&painter2, QRect(0, 0, 2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
+							renderSurface(&painter2, TQRect(0, 0, 2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
 							painter2.resetXForm();
 							painter2.drawTiledPixmap(0, 2, 2, 1, *tabHLines, 0, 2); // left
-							painter2.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 79));
+							painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79));
 							painter2.drawLine(0, 3, 1,3);
-							painter2.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 30));
+							painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30));
 							painter2.drawLine(0, 4, 3, 4);
 						}
 						if(!isLast) {
 							
 							painter2.translate(0, -r.height()+8);
-							renderSurface(&painter2, QRect(14, 0, 2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
+							renderSurface(&painter2, TQRect(14, 0, 2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
 							painter2.resetXForm();
 							painter2.drawTiledPixmap(14, 2, 2, 1, *tabHLines, 0, 2); // right
-							painter2.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 79));
+							painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79));
 							painter2.drawLine(14, 3, 15, 3);
-							painter2.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 30));
+							painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30));
 							painter2.drawLine(12, 4, 15, 4);
 						}
 					}
-					painter2.fillRect(QRect(0, 5, 16, 3), g.background());
+					painter2.fillRect(TQRect(0, 5, 16, 3), g.background());
 					painter2.end();
 					
 				
-					QPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
+					TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
 					painter2.begin(&tabEdgesMask);
 					painter2.translate(0, -r.height()+16);
-					renderSurface(&painter2, QRect(1, 0, 14, r.height()-2), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
+					renderSurface(&painter2, TQRect(1, 0, 14, r.height()-2), g.background(), g.button(), g.button(), Is_ActiveTabBottom);
 					painter2.end();
 					bitBlt(tabEdges2, 0, 0, &tabEdgesMask, 0, 8);
 				
-					QPixmap circle = qembed_findImage("tabWidget");
+					TQPixmap circle = qembed_findImage("tabWidget");
 					bitBlt(tabEdges2, 0, 0, &circle, 0, 8);
 				
-					QPixmapCache::insert(position+"tabEdges2-bottom-sel"+QString::number(g.background().pixel(), 16)+QString::number(r.height()), tabEdges2);
+					TQPixmapCache::insert(position+"tabEdges2-bottom-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
 				}
 				
 				
-				painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 79)); // bottomShadow1
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79)); // bottomShadow1
 				painter.drawLine(8, r.height()-2, r.width()-9, r.height()-2);
-				painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 30)); // bottomShadow2
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30)); // bottomShadow2
 				painter.drawLine(8, r.height()-1, r.width()-9, r.height()-1);
 				
-				painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35));
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
 				if(isFirst || isSingle)
 					painter.drawLine(0, 0, 0, r.height()-8); // left
 				else
-					renderTabSeparator(&painter, QRect(0, 0, 1, r.height()-5), g.button(), false);
+					renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5), g.button(), false);
 				if(isLast || isSingle)
 					painter.drawLine(r.width()-1, 0, r.width()-1, r.height()-8); // right
 				else
-					renderTabSeparator(&painter, QRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);
+					renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);
 				
 				bitBlt(&buffer, 0, r.bottom()-7, tabEdges2, 0, 0, 8, 8);
 				bitBlt(&buffer, r.width()-8, r.bottom()-7, tabEdges2, 8, 0, 8, 8);
@@ -2446,46 +2446,46 @@ void DominoStyle::renderTab(QPainter *p,
 				painter.drawTiledPixmap(1, 0, 1, r.height()-8, *tabVLines); // left
 				painter.drawTiledPixmap(r.width()-2, 0, 1, r.height()-8, *tabVLines); // right
 				
-				painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35)); // clip the first pixels of the separators
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35)); // clip the first pixels of the separators
 				painter.drawPoint(0, 0);
 				painter.drawPoint(r.width()-1, 0);
 				
 			}
 			else { // unselected
 				
-				renderSurface(&painter, QRect(1, 0, r.width()-2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
+				renderSurface(&painter, TQRect(1, 0, r.width()-2, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
 				
 				
 				if(isFirst || isLast) {
 					
-					QPixmap* tabEdges2;
-					if(!(tabEdges2 = QPixmapCache::find("tabEdges2-bottom"+QString::number(g.background().pixel(), 16)+QString::number(r.height())))) {
-						tabEdges2 = new QPixmap(16, 8);
+					TQPixmap* tabEdges2;
+					if(!(tabEdges2 = TQPixmapCache::find("tabEdges2-bottom"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
+						tabEdges2 = new TQPixmap(16, 8);
 						tabEdges2->fill(g.background());
 				
-						QPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
-						QPainter painter2(&tabEdgesMask);
+						TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
+						TQPainter painter2(&tabEdgesMask);
 						painter2.translate(0, -r.height()+19);
-						renderSurface(&painter2, QRect(1, 0, 14, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
+						renderSurface(&painter2, TQRect(1, 0, 14, r.height()-5), g.background(), g.button(), g.button(), Is_TabBottom);
 						painter2.end();
 						bitBlt(tabEdges2, 0, 0, &tabEdgesMask, 0, 8);
 				
-						QPixmap circle = qembed_findImage("tabWidget");
+						TQPixmap circle = qembed_findImage("tabWidget");
 						bitBlt(tabEdges2, 0, 0, &circle, 0, 8);
 				
-						QPixmapCache::insert("tabEdges2-bottom"+QString::number(g.background().pixel(), 16)+QString::number(r.height()), tabEdges2);
+						TQPixmapCache::insert("tabEdges2-bottom"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
 					}
 					
 					
 					if(isFirst) {
-						renderTabSeparator(&painter, QRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);// right
+						renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);// right
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 79)); // bottomShadow1
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79)); // bottomShadow1
 						painter.drawLine(8, r.height()-5, r.width()-1, r.height()-5);
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 30)); // bottomShadow2
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30)); // bottomShadow2
 						painter.drawLine(8, r.height()-4, r.width()-1, r.height()-4);
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35));
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
 						painter.drawLine(0, 1, 0, r.height()-12); // left
 						
 						bitBlt(&buffer, 0, r.height()-11, tabEdges2, 0, 0, 8, 8);
@@ -2493,19 +2493,19 @@ void DominoStyle::renderTab(QPainter *p,
 						painter.drawTiledPixmap(1, 1, 1, r.height()-12, *tabVLines); // left
 						painter.drawTiledPixmap(8, r.height()-6, r.width()-8, 1, *tabHLines, 0, 2); // bottom
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 55));
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 55));
 						painter.drawLine(0, 0, r.width()-1, 0); // top
 						
 					}
 					else {
-						renderTabSeparator(&painter, QRect(0, 0, 1, r.height()-5), g.button(), false); // left
+						renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5), g.button(), false); // left
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 79)); // bottomShadow1
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79)); // bottomShadow1
 						painter.drawLine(0, r.height()-5, r.width()-8, r.height()-5);
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 30)); // bottomShadow2
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30)); // bottomShadow2
 						painter.drawLine(0, r.height()-4, r.width()-8, r.height()-4);
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35));
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
 						painter.drawLine(r.width()-1, 1, r.width()-1, r.height()-12); // right
 						
 						bitBlt(&buffer, r.width()-8, r.height()-11, tabEdges2, 8, 0, 8, 8);
@@ -2513,91 +2513,91 @@ void DominoStyle::renderTab(QPainter *p,
 						painter.drawTiledPixmap(r.width()-2, 1, 1, r.height()-12, *tabVLines); // right
 						painter.drawTiledPixmap(0, r.height()-6, r.width()-8, 1, *tabHLines, 0, 2); // bottom
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 55));
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 55));
 						painter.drawLine(0, 0, r.width()-1, 0); // top
 					}
 				}
 				else { // middle
-					renderTabSeparator(&painter, QRect(0, 0, 1, r.height()-5), g.button(), false); // left
-					renderTabSeparator(&painter, QRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);// right
+					renderTabSeparator(&painter, TQRect(0, 0, 1, r.height()-5), g.button(), false); // left
+					renderTabSeparator(&painter, TQRect(r.width()-1, 0, 1, r.height()-5), g.button(), false);// right
 					
-					painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 79)); // bottomShadow1
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 79)); // bottomShadow1
 					painter.drawLine(0, r.height()-5, r.width()-1, r.height()-5);
-					painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 30)); // bottomShadow2
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 30)); // bottomShadow2
 					painter.drawLine(0, r.height()-4, r.width()-1, r.height()-4);
 					painter.drawTiledPixmap(0, r.height()-6, r.width(), 1, *tabHLines, 0, 2); // bottom
 					
-					painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 55));
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 55));
 					painter.drawLine(0, 0, r.width()-1, 0); // top
 				}
 				
-				painter.fillRect(QRect(0, r.height()-3, r.width(), 3), g.background()); // rect under the tab, clips also the tabSeperator
+				painter.fillRect(TQRect(0, r.height()-3, r.width(), 3), g.background()); // rect under the tab, clips also the tabSeperator
 				
 			}
 		}
 		else { // above
 			if (selected) {
 				
-				renderSurface(&painter, QRect(1, 1, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_ActiveTabTop);
+				renderSurface(&painter, TQRect(1, 1, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_ActiveTabTop);
 				
-				QPixmap* tabEdges2;
-				QString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
-				if(!(tabEdges2 = QPixmapCache::find(position+"tabEdges2-top-sel"+QString::number(g.background().pixel(), 16)+QString::number(r.height())))) {
-					tabEdges2 = new QPixmap(16,8);
+				TQPixmap* tabEdges2;
+				TQString position = isFirst ? "first" : isLast ? "last" : isSingle ? "single" : "middle";
+				if(!(tabEdges2 = TQPixmapCache::find(position+"tabEdges2-top-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
+					tabEdges2 = new TQPixmap(16,8);
 					tabEdges2->fill(g.background());
-					QPainter painter2(tabEdges2);
+					TQPainter painter2(tabEdges2);
 					
 					if(!isSingle) {
-						painter2.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 25));
+						painter2.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
 						if(!isFirst) {
-							renderSurface(&painter2, QRect(0, 4, 2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
+							renderSurface(&painter2, TQRect(0, 4, 2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
 							painter2.drawLine(0, 3, 1, 3); // topLine
 							painter2.drawTiledPixmap(0, 4, 2, 2, *tabHLines);
 						}
 						if(!isLast) {
-							renderSurface(&painter2, QRect(14, 4, 2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
+							renderSurface(&painter2, TQRect(14, 4, 2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
 							painter2.drawLine(14, 3, 15, 3); // topLine
 							painter2.drawTiledPixmap(14, 4, 2, 2, *tabHLines);
 						}
 					}
 					painter2.end();
 					
-					QPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
+					TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
 					painter2.begin(&tabEdgesMask);
-					renderSurface(&painter2, QRect(1, 1, 14, r.height()), g.background(), g.button(), g.button(), Is_ActiveTabTop);
+					renderSurface(&painter2, TQRect(1, 1, 14, r.height()), g.background(), g.button(), g.button(), Is_ActiveTabTop);
 					painter2.end();
 					bitBlt(tabEdges2, 0, 0, &tabEdgesMask);
 				
-					QPixmap circle = qembed_findImage("tabWidget");
+					TQPixmap circle = qembed_findImage("tabWidget");
 					bitBlt(tabEdges2, 0, 0, &circle);
 				
-					QPixmapCache::insert(position+"tabEdges2-top-sel"+QString::number(g.background().pixel(), 16)+QString::number(r.height()), tabEdges2);
+					TQPixmapCache::insert(position+"tabEdges2-top-sel"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
 				}
 				
 				///////////////////////////////////////////////
-				painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35));
-				///painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 40));
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
+				///painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 40));
 				if(isFirst || isSingle)
 					painter.drawLine(0, 8, 0, r.height()-1); // left
 				else
-					renderTabSeparator(&painter, QRect(0, 4, 1, r.height()), g.button(), true);
+					renderTabSeparator(&painter, TQRect(0, 4, 1, r.height()), g.button(), true);
 				if(isLast || isSingle)
 					painter.drawLine(r.width()-1, 8, r.width()-1, r.height()-1); // right
 				else
-					renderTabSeparator(&painter, QRect(r.width()-1, 4, 1, r.height()), g.button(), true);
+					renderTabSeparator(&painter, TQRect(r.width()-1, 4, 1, r.height()), g.button(), true);
 				
-				painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 25));
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
 				painter.drawLine(8, 0, r.width()-9, 0); // top
 				
 				
-				bitBlt(&buffer, 0, 0, tabEdges2, 0, 0, 8, 8, Qt::CopyROP);
-				bitBlt(&buffer, r.width()-8, 0, tabEdges2, 8, 0, 8, 8, Qt::CopyROP);
+				bitBlt(&buffer, 0, 0, tabEdges2, 0, 0, 8, 8, TQt::CopyROP);
+				bitBlt(&buffer, r.width()-8, 0, tabEdges2, 8, 0, 8, 8, TQt::CopyROP);
 				
 				painter.drawTiledPixmap(8, 1, r.width()-16, 2, *tabHLines); // top
 				painter.drawTiledPixmap(1, 8, 1, r.height()-1, *tabVLines); // left
 				painter.drawTiledPixmap(r.width()-2, 8, 1, r.height()-1, *tabVLines); // right
 				
-				painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35)); // clip the last pixels of the separators
+				painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35)); // clip the last pixels of the separators
 				painter.drawPoint(0, r.height()-1);
 				painter.drawPoint(r.width()-1, r.height()-1);
 				
@@ -2608,37 +2608,37 @@ void DominoStyle::renderTab(QPainter *p,
 				painter.fillRect(0, 0, r.width(), 10, g.background());
 				painter.setPen(g.background().dark(150));
 				
-				renderSurface(&painter, QRect(1, 4, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
+				renderSurface(&painter, TQRect(1, 4, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
 				
 				if(isFirst || isLast) {
 					
-					QPixmap* tabEdges2;
-					if(!(tabEdges2 = QPixmapCache::find("tabEdges2-top"+QString::number(g.background().pixel(), 16)+QString::number(r.height())))) {
-						tabEdges2 = new QPixmap(16, 8);
+					TQPixmap* tabEdges2;
+					if(!(tabEdges2 = TQPixmapCache::find("tabEdges2-top"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height())))) {
+						tabEdges2 = new TQPixmap(16, 8);
 						tabEdges2->fill(g.background());
 				
-						QPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
-						QPainter painter2(&tabEdgesMask);
-						renderSurface(&painter2, QRect(1, 1, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
+						TQPixmap tabEdgesMask = qembed_findImage("groupBoxMask");
+						TQPainter painter2(&tabEdgesMask);
+						renderSurface(&painter2, TQRect(1, 1, r.width()-2, r.height()), g.background(), g.button(), g.button(), Is_TabTop);
 						painter2.end();
 						bitBlt(tabEdges2, 0, 0, &tabEdgesMask);
 				
-						QPixmap circle = qembed_findImage("tabWidget");
+						TQPixmap circle = qembed_findImage("tabWidget");
 						bitBlt(tabEdges2, 0, 0, &circle);
 				
-						QPixmapCache::insert("tabEdges2-top"+QString::number(g.background().pixel(), 16)+QString::number(r.height()), tabEdges2);
+						TQPixmapCache::insert("tabEdges2-top"+TQString::number(g.background().pixel(), 16)+TQString::number(r.height()), tabEdges2);
 					}
 					
 					
 					
 					if(isFirst) {
 						// darker separator
-						renderTabSeparator(&painter, QRect(r.width()-1, 4, 1, r.height()), g.button(), true); // left
+						renderTabSeparator(&painter, TQRect(r.width()-1, 4, 1, r.height()), g.button(), true); // left
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 25));
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
 						painter.drawLine(8, 3, r.width()-1, 3); // topLine
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35));
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
 						painter.drawLine(0, 10, 0, r.height()-1); // left
 						painter.drawLine(1, r.height()-1, r.width()-1, r.height()-1); // bottom
 						
@@ -2650,12 +2650,12 @@ void DominoStyle::renderTab(QPainter *p,
 					}
 					else {
 						// darker separator
-						renderTabSeparator(&painter, QRect(0, 4, 1, r.height()), g.button(), true); // right
+						renderTabSeparator(&painter, TQRect(0, 4, 1, r.height()), g.button(), true); // right
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 25));
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
 						painter.drawLine(0, 3, r.width()-9, 3); // topLine
 						
-						painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35));
+						painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
 						painter.drawLine(r.width()-1, 10, r.width()-1, r.height()-1); // right
 						painter.drawLine(0, r.height()-1, r.width()-2, r.height()-1); // bottom
 						
@@ -2668,14 +2668,14 @@ void DominoStyle::renderTab(QPainter *p,
 				}
 				else {  // middle
 					
-					renderTabSeparator(&painter, QRect(r.width()-1, 4, 1, r.height()), g.button(), true); // left
-					renderTabSeparator(&painter, QRect(0, 4, 1, r.height()), g.button(), true); // right
+					renderTabSeparator(&painter, TQRect(r.width()-1, 4, 1, r.height()), g.button(), true); // left
+					renderTabSeparator(&painter, TQRect(0, 4, 1, r.height()), g.button(), true); // right
 					
-					painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 25));
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 25));
 					painter.drawLine(0, 3, r.width()-1, 3); // top
 					painter.drawTiledPixmap(0, 4, r.width(), 2, *tabHLines);
 					
-					painter.setPen(alphaBlendColors(QColor(0,0,0), g.background(), 35));
+					painter.setPen(alphaBlendColors(TQColor(0,0,0), g.background(), 35));
 					painter.drawLine(0, r.height()-1, r.width()-1, r.height()-1); // bottom
 						
 				}
@@ -2686,12 +2686,12 @@ void DominoStyle::renderTab(QPainter *p,
 }
 
 void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
-									  QPainter *p,
-									  const QWidget* widget,
-									  const QRect &r,
-									  const QColorGroup &cg,
+									  TQPainter *p,
+									  const TQWidget* widget,
+									  const TQRect &r,
+									  const TQColorGroup &cg,
 									  SFlags flags,
-									  const QStyleOption& opt) const
+									  const TQStyleOption& opt) const
 {
 	//return KStyle::drawKStylePrimitive(kpe, p, widget, r, cg, flags, opt);
 
@@ -2700,41 +2700,41 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 	switch( kpe ) {
 		case KPE_SliderGroove: {
 			
-			bool horizontal = ((const QSlider*)widget)->orientation() == Horizontal;
+			bool horizontal = ((const TQSlider*)widget)->orientation() == Horizontal;
 			
-			QRect re;
+			TQRect re;
 			if(horizontal)
 				re.setRect(r.left(), r.y()+r.height()/2-3, r.width(), 4);
 			else
 				re.setRect(r.x()+r.width()/2-3, r.top(), 4, r.height());
 			
 			bool parentBgPix = widget->parentWidget() ? widget->parentWidget()->paletteBackgroundPixmap() : 0;
-			QString hori = horizontal ? "1" : "0";
-			QString trans = parentBgPix ? "1" : "0";
-			QPixmap* sliderGroove;
-			if(!(sliderGroove = QPixmapCache::find(QString::number(cg.background().pixel(), 16)+"sliderGroove"+hori+trans))) {
+			TQString hori = horizontal ? "1" : "0";
+			TQString trans = parentBgPix ? "1" : "0";
+			TQPixmap* sliderGroove;
+			if(!(sliderGroove = TQPixmapCache::find(TQString::number(cg.background().pixel(), 16)+"sliderGroove"+hori+trans))) {
 
 				if(parentBgPix) { // ### the pix are transparent!
 					if(!horizontal) {
-						QWMatrix m;
+						TQWMatrix m;
 						m.rotate(-90);
-						sliderGroove = new QPixmap(qembed_findImage("slGHBody").xForm(m));
+						sliderGroove = new TQPixmap(qembed_findImage("slGHBody").xForm(m));
 					}
 					else
-						sliderGroove = new QPixmap(qembed_findImage("slGHBody"));
+						sliderGroove = new TQPixmap(qembed_findImage("slGHBody"));
 				}
 				else {
-					const QColor c1 = alphaBlendColors(QColor(0,0,0), cg.background(), 11);
-					const QColor c2 = alphaBlendColors(QColor(53,53,53), cg.background(), 155);
-					const QColor c3 = alphaBlendColors(QColor(67,67,67), cg.background(), 146);
-					const QColor c4 = alphaBlendColors(QColor(83,83,83), cg.background(), 140);
-					const QColor c5 = alphaBlendColors(QColor(101,101,101), cg.background(), 134);
-					const QColor c6 = alphaBlendColors(QColor(254,254,254), cg.background(), 43);
-					const QColor c7 = alphaBlendColors(QColor(255,255,255), cg.background(), 9);
+					const TQColor c1 = alphaBlendColors(TQColor(0,0,0), cg.background(), 11);
+					const TQColor c2 = alphaBlendColors(TQColor(53,53,53), cg.background(), 155);
+					const TQColor c3 = alphaBlendColors(TQColor(67,67,67), cg.background(), 146);
+					const TQColor c4 = alphaBlendColors(TQColor(83,83,83), cg.background(), 140);
+					const TQColor c5 = alphaBlendColors(TQColor(101,101,101), cg.background(), 134);
+					const TQColor c6 = alphaBlendColors(TQColor(254,254,254), cg.background(), 43);
+					const TQColor c7 = alphaBlendColors(TQColor(255,255,255), cg.background(), 9);
 					
-					sliderGroove = new QPixmap(7, 7);
-					QPainter painter(sliderGroove);
-					QRect rr = sliderGroove->rect();
+					sliderGroove = new TQPixmap(7, 7);
+					TQPainter painter(sliderGroove);
+					TQRect rr = sliderGroove->rect();
 					
 					if (horizontal) {
 						painter.setPen(c1);
@@ -2769,43 +2769,43 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 						painter.drawLine(6, 0, 6, 7);
 					}
 				}
-				QPixmapCache::insert(QString::number(cg.background().pixel(), 16)+"sliderGroove"+hori+trans, sliderGroove);
+				TQPixmapCache::insert(TQString::number(cg.background().pixel(), 16)+"sliderGroove"+hori+trans, sliderGroove);
 			}
 			
 			if (horizontal) {
-				QPixmap* slGh;
-				if(parentBgPix || !(slGh = QPixmapCache::find(QString::number(cg.background().pixel(), 16)+"slGh"))) { // rounded edges
+				TQPixmap* slGh;
+				if(parentBgPix || !(slGh = TQPixmapCache::find(TQString::number(cg.background().pixel(), 16)+"slGh"))) { // rounded edges
 					
 					if(parentBgPix)
-						slGh = new QPixmap(qembed_findImage("slGh"));
+						slGh = new TQPixmap(qembed_findImage("slGh"));
 					else {
-						slGh = new QPixmap(6, 7);
+						slGh = new TQPixmap(6, 7);
 						slGh->fill(cg.background());
-						QPixmap pix = qembed_findImage("slGh");
-						bitBlt(slGh, 0, 0, &pix, 0, 0, -1, -1, Qt::CopyROP);
+						TQPixmap pix = qembed_findImage("slGh");
+						bitBlt(slGh, 0, 0, &pix, 0, 0, -1, -1, TQt::CopyROP);
 					}
-					QPixmapCache::insert(QString::number(cg.background().pixel(), 16)+"slGh",slGh );
+					TQPixmapCache::insert(TQString::number(cg.background().pixel(), 16)+"slGh",slGh );
 				}
 				
-				bitBlt(p->device(), re.x(), re.y(), slGh, 0, 0, 3, 7, Qt::CopyROP);
-				bitBlt(p->device(), r.width()-3, re.y(), slGh, 3, 0, 3, 7, Qt::CopyROP);
+				bitBlt(p->device(), re.x(), re.y(), slGh, 0, 0, 3, 7, TQt::CopyROP);
+				bitBlt(p->device(), r.width()-3, re.y(), slGh, 3, 0, 3, 7, TQt::CopyROP);
 				p->drawTiledPixmap(re.x()+3, re.y(), r.width()-6, 7, *sliderGroove);
 			}
 			else {
-				QPixmap* slGv;
-				if(parentBgPix || !(slGv = QPixmapCache::find(QString::number(cg.background().pixel(), 16)+"slGv"))) {
+				TQPixmap* slGv;
+				if(parentBgPix || !(slGv = TQPixmapCache::find(TQString::number(cg.background().pixel(), 16)+"slGv"))) {
 					if(parentBgPix)
-						slGv = new QPixmap(qembed_findImage("slGv"));
+						slGv = new TQPixmap(qembed_findImage("slGv"));
 					else {
-						slGv = new QPixmap(7, 6);
+						slGv = new TQPixmap(7, 6);
 						slGv->fill(cg.background());
-						QPixmap pix = qembed_findImage("slGv");
-						bitBlt(slGv, 0, 0, &pix, 0, 0, -1, -1, Qt::CopyROP);
+						TQPixmap pix = qembed_findImage("slGv");
+						bitBlt(slGv, 0, 0, &pix, 0, 0, -1, -1, TQt::CopyROP);
 					}
-					QPixmapCache::insert(QString::number(cg.background().pixel(), 16)+"slGv",slGv );
+					TQPixmapCache::insert(TQString::number(cg.background().pixel(), 16)+"slGv",slGv );
 				}
-				bitBlt(p->device(), re.x(), re.y(), slGv, 0, 0, 7, 3, Qt::CopyROP);
-				bitBlt(p->device(), re.x(), re.height()-3, slGv, 0, 3, 7, 3, Qt::CopyROP);
+				bitBlt(p->device(), re.x(), re.y(), slGv, 0, 0, 7, 3, TQt::CopyROP);
+				bitBlt(p->device(), re.x(), re.height()-3, slGv, 0, 3, 7, 3, TQt::CopyROP);
 				p->drawTiledPixmap(re.x(), re.y()+3, 7, r.height()-6, *sliderGroove);
 			}
 			
@@ -2813,7 +2813,7 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 		}
 
 		case KPE_SliderHandle: {
-			const QSlider* slider = (const QSlider*)widget;
+			const TQSlider* slider = (const TQSlider*)widget;
 			
 			int y, x;
 			if(slider->orientation() == Horizontal) {
@@ -2825,62 +2825,62 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 				x = r.x()+r.width()/2-8;
 			}
 			
-			QPixmap* handle;
-			if(!(handle = QPixmapCache::find("sliderHandle"+QString::number(cg.button().pixel(), 16)))) {
-				QPixmap insidePix =  qembed_findImage("sliderHandle2inside"); // a filled antialiased circle to draw the gradients on
-				QPainter painter(&insidePix);
+			TQPixmap* handle;
+			if(!(handle = TQPixmapCache::find("sliderHandle"+TQString::number(cg.button().pixel(), 16)))) {
+				TQPixmap insidePix =  qembed_findImage("sliderHandle2inside"); // a filled antialiased circle to draw the gradients on
+				TQPainter painter(&insidePix);
 				flatMode=true;
-				renderSurface(&painter, QRect(1, 0, 13, 15), cg.background(), cg.button(), cg.button(), Is_Button|Is_Horizontal);
+				renderSurface(&painter, TQRect(1, 0, 13, 15), cg.background(), cg.button(), cg.button(), Is_Button|Is_Horizontal);
 				flatMode=false;
-				QImage inside = insidePix.convertToImage();
+				TQImage inside = insidePix.convertToImage();
 				
-				QImage circle = tintImage(qembed_findImage("sliderHandle2circle"),
+				TQImage circle = tintImage(qembed_findImage("sliderHandle2circle"),
 						_customSliderHandleContourColor ? buttonContour->contourColor(Contour_Default) : alphaBlendColors(black, cg.button(), 110));
 				
-				QImage shadow =  qembed_findImage("sliderHandle2shadow");
+				TQImage shadow =  qembed_findImage("sliderHandle2shadow");
 				blend(shadow, inside, inside);
 				blend(circle, inside, inside);
-				handle = new QPixmap(inside);
-				QPixmapCache::insert("sliderHandle"+QString::number(cg.button().pixel(), 16), handle );
+				handle = new TQPixmap(inside);
+				TQPixmapCache::insert("sliderHandle"+TQString::number(cg.button().pixel(), 16), handle );
 			}
-			bitBlt(p->device(), x, y, handle, 0, 0, -1, -1, Qt::CopyROP);
+			bitBlt(p->device(), x, y, handle, 0, 0, -1, -1, TQt::CopyROP);
 			
 			break;
 		}
 
 		case KPE_ListViewExpander: {
 			
-			QWidget* w = dynamic_cast<QWidget*>(p->device());
+			TQWidget* w = dynamic_cast<TQWidget*>(p->device());
 			p->setPen( cg.text() );
-			QColor bg = w ? w->paletteBackgroundColor() : cg.background();
-			QString hasBgPix = w && w->paletteBackgroundPixmap() ? "1" : "0";
-			QString expanded = flags & Style_Off ? "1" : "0";
-			QPixmap* lve;
+			TQColor bg = w ? w->paletteBackgroundColor() : cg.background();
+			TQString hasBgPix = w && w->paletteBackgroundPixmap() ? "1" : "0";
+			TQString expanded = flags & Style_Off ? "1" : "0";
+			TQPixmap* lve;
 			
 			if(_drawTriangularExpander) {
 				
-				if(!(lve = QPixmapCache::find(QString::number(bg.pixel(), 16)+QString::number(cg.text().pixel(), 16)+"lveT"+hasBgPix+expanded))) {
-					QWMatrix m;
+				if(!(lve = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveT"+hasBgPix+expanded))) {
+					TQWMatrix m;
 					m.rotate(90);
 					if(w && !w->paletteBackgroundPixmap()) {
-						QImage img = tintImage(qembed_findImage("lveTriangular"), cg.text());
+						TQImage img = tintImage(qembed_findImage("lveTriangular"), cg.text());
 						int w=7, h=9;
 						if(flags & Style_Off) {
 							w=9, h=7;
 							img = img.xForm(m);
 						}
-						QImage imgBG(w,h,32);
+						TQImage imgBG(w,h,32);
 						imgBG.fill(bg.rgb());
 						bitBlt(&imgBG, 0, 0, &img);
-						lve = new QPixmap(imgBG);
+						lve = new TQPixmap(imgBG);
 					}
 					else {
 						if(flags & Style_Off)
-							lve = new QPixmap(tintImage(qembed_findImage("lveTriangular").xForm(m), cg.text()));
+							lve = new TQPixmap(tintImage(qembed_findImage("lveTriangular").xForm(m), cg.text()));
 						else
-							lve = new QPixmap(tintImage(qembed_findImage("lveTriangular"), cg.text()));
+							lve = new TQPixmap(tintImage(qembed_findImage("lveTriangular"), cg.text()));
 					}
-					QPixmapCache::insert(QString::number(bg.pixel(), 16)+QString::number(cg.text().pixel(), 16)+"lveT"+hasBgPix+expanded, lve);
+					TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveT"+hasBgPix+expanded, lve);
 				}
 				
 				p->drawPixmap(r.x(), r.y(), *lve);
@@ -2888,11 +2888,11 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 			}
 			else {
 				
-				if(!(lve = QPixmapCache::find(QString::number(bg.pixel(), 16)+QString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+expanded))) {
+				if(!(lve = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+expanded))) {
 					if(w && !w->paletteBackgroundPixmap()) {
-						lve = new QPixmap(11,11);
+						lve = new TQPixmap(11,11);
 						lve->fill(bg);
-						QPainter painter(lve);
+						TQPainter painter(lve);
 						painter.drawPixmap(0, 0, tintImage(qembed_findImage("lve"), cg.text()));
 						
 						// plus or minus
@@ -2900,19 +2900,19 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 						if ( flags & Style_On ) // Collapsed = On
 							painter.drawLine( 5, 3, 5, 7 );
 						
-						QPixmapCache::insert(QString::number(bg.pixel(), 16)+QString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+expanded, lve);
+						TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+expanded, lve);
 					}
 					else {
-						QImage img = QImage(11, 11, 32);
+						TQImage img = TQImage(11, 11, 32);
 						img.setAlphaBuffer(true);
 						for(int x=0; x < img.width(); ++x) {
 							for(int y=0; y < img.height(); ++y) {
-								img.setPixel(x, y, qRgba(0, 0, 0, 0));
+								img.setPixel(x, y, tqRgba(0, 0, 0, 0));
 							}
 						}
 						
 						
-						QImage img2 = tintImage(qembed_findImage("lve"), cg.text());
+						TQImage img2 = tintImage(qembed_findImage("lve"), cg.text());
 						bitBlt(&img, 0, 0, &img2);
 						
 						int r, b, g;
@@ -2920,27 +2920,27 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 						cg.text().getRgb(&r, &g, &b);
 						
 						// minus
-						img.setPixel(3, 5, qRgba(r, b, g, a));
-						img.setPixel(4, 5, qRgba(r, b, g, a));
-						img.setPixel(5, 5, qRgba(r, b, g, a));
-						img.setPixel(6, 5, qRgba(r, b, g, a));
-						img.setPixel(7, 5, qRgba(r, b, g, a));
+						img.setPixel(3, 5, tqRgba(r, b, g, a));
+						img.setPixel(4, 5, tqRgba(r, b, g, a));
+						img.setPixel(5, 5, tqRgba(r, b, g, a));
+						img.setPixel(6, 5, tqRgba(r, b, g, a));
+						img.setPixel(7, 5, tqRgba(r, b, g, a));
 						
 						
 						if ( flags & Style_Off )
-							lve = new QPixmap(img);
-						QPixmapCache::insert(QString::number(bg.pixel(), 16)+QString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+"1", new QPixmap(img));
+							lve = new TQPixmap(img);
+						TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+"1", new TQPixmap(img));
 						
 						// plus
-						img.setPixel(5, 3, qRgba(r, b, g, a));
-						img.setPixel(5, 4, qRgba(r, b, g, a));
-						img.setPixel(5, 6, qRgba(r, b, g, a));
-						img.setPixel(5, 7, qRgba(r, b, g, a));
+						img.setPixel(5, 3, tqRgba(r, b, g, a));
+						img.setPixel(5, 4, tqRgba(r, b, g, a));
+						img.setPixel(5, 6, tqRgba(r, b, g, a));
+						img.setPixel(5, 7, tqRgba(r, b, g, a));
 						
 						if ( flags & Style_On )
-							lve = new QPixmap(img);
+							lve = new TQPixmap(img);
 						
-						QPixmapCache::insert(QString::number(bg.pixel(), 16)+QString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+"0", new QPixmap(img));
+						TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.text().pixel(), 16)+"lveC"+hasBgPix+"0", new TQPixmap(img));
 					}
 				}
 				p->drawPixmap(r.x()-1,r.y()-1, *lve);
@@ -2958,10 +2958,10 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 			{
 				// make 128*1 and 1*128 bitmaps that can be used for
 				// drawing the right sort of lines.
-				verticalLine   = new QBitmap( 1, 129, true );
-				horizontalLine = new QBitmap( 128, 1, true );
-				QPointArray a( 64 );
-				QPainter p2;
+				verticalLine   = new TQBitmap( 1, 129, true );
+				horizontalLine = new TQBitmap( 128, 1, true );
+				TQPointArray a( 64 );
+				TQPainter p2;
 				p2.begin( verticalLine );
 	
 				int i;
@@ -2970,7 +2970,7 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 				p2.setPen( color1 );
 				p2.drawPoints( a );
 				p2.end();
-				QApplication::flushX();
+				TQApplication::flushX();
 				verticalLine->setMask( *verticalLine );
 	
 				p2.begin( horizontalLine );
@@ -2979,7 +2979,7 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 				p2.setPen( color1 );
 				p2.drawPoints( a );
 				p2.end();
-				QApplication::flushX();
+				TQApplication::flushX();
 				horizontalLine->setMask( *horizontalLine );
 			}
 	
@@ -3027,11 +3027,11 @@ void DominoStyle::drawKStylePrimitive(KStylePrimitive kpe,
 
 
 void DominoStyle::drawPrimitive(PrimitiveElement pe,
-								QPainter *p,
-								const QRect &r,
-								const QColorGroup &cg,
+								TQPainter *p,
+								const TQRect &r,
+								const TQColorGroup &cg,
 								SFlags flags,
-								const QStyleOption &opt ) const
+								const TQStyleOption &opt ) const
 {
 	bool down	= flags & Style_Down;
 	bool on		= flags & Style_On;
@@ -3060,25 +3060,25 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				break;
 			}
 			
-			QWidget* w =  dynamic_cast<QWidget*>(p->device());
-			if(rubberBandType == ArgbRubber && compositeManagerRunning && viewPortPressed && dynamic_cast<QListView*>(w->parentWidget())) {
-				QListView* lv = dynamic_cast<QListView*>(w->parentWidget());
+			TQWidget* w =  dynamic_cast<TQWidget*>(p->device());
+			if(rubberBandType == ArgbRubber && compositeManagerRunning && viewPortPressed && dynamic_cast<TQListView*>(w->parentWidget())) {
+				TQListView* lv = dynamic_cast<TQListView*>(w->parentWidget());
 				if(!lv->currentItem())
 					break;
-				QRect sr = lv->itemRect(lv->currentItem());
-				QRect rr = r.normalize();
+				TQRect sr = lv->itemRect(lv->currentItem());
+				TQRect rr = r.normalize();
 				int step = lv->rootIsDecorated() ? (lv->currentItem()->depth()+1)*lv->treeStepSize() : lv->currentItem()->depth()*lv->treeStepSize();
-				if(dynamic_cast<QCheckListItem*>(lv->currentItem()))
+				if(dynamic_cast<TQCheckListItem*>(lv->currentItem()))
 					step += 16+lv->itemMargin()+4;
 				
 				// why is the focusrect misused as a rubberband!?
-				if((lv->selectionMode() == QListView::Multi || lv->selectionMode() == QListView::Extended) && 
+				if((lv->selectionMode() == TQListView::Multi || lv->selectionMode() == TQListView::Extended) && 
 								!((sr.y() == rr.y()) && (sr.height() == rr.height()) && (sr.x()+step == rr.x()))) {
 					
-					QScrollView* sv = static_cast<QScrollView*>(w);
+					TQScrollView* sv = static_cast<TQScrollView*>(w);
 					
-					QPoint po = w->mapFrom(sv, r.topLeft());
-					QRect re = QRect(po.x(), po.y(), r.width(), r.height());
+					TQPoint po = w->mapFrom(sv, r.topLeft());
+					TQRect re = TQRect(po.x(), po.y(), r.width(), r.height());
 					
 					drawPrimitive(PE_RubberBand, p, r, cg, flags, opt);
 					break;
@@ -3089,19 +3089,19 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				break;
 			}
 			
-			QColor color = alphaBlendColors(cg.highlight(), cg.foreground(), 160);
+			TQColor color = alphaBlendColors(cg.highlight(), cg.foreground(), 160);
 			
-			if(w && (w->isA("QViewportWidget") || dynamic_cast<QWidget*>(p->device())->isA("RegionGrabber"))) { // QListView, QListBox, KSnapshot...
+			if(w && (w->isA("TQViewportWidget") || dynamic_cast<TQWidget*>(p->device())->isA("RegionGrabber"))) { // TQListView, TQListBox, KSnapshot...
 				// we can't be sure if the pixamp edges will be erased, so only a simple rect.
-				p->setPen(QPen(color, 1, Qt::SolidLine));
+				p->setPen(TQPen(color, 1, TQt::SolidLine));
 				p->drawRect(r);
 				break;
 			}
 			
-			QPixmap* edges;
-			if(!(edges = QPixmapCache::find("fre"+QString::number(color.pixel(), 16)))) {
-				edges = new QPixmap(tintImage(qembed_findImage("focusRectEdges"), color));
-				QPixmapCache::insert("fre"+QString::number(color.pixel(), 16), edges);
+			TQPixmap* edges;
+			if(!(edges = TQPixmapCache::find("fre"+TQString::number(color.pixel(), 16)))) {
+				edges = new TQPixmap(tintImage(qembed_findImage("focusRectEdges"), color));
+				TQPixmapCache::insert("fre"+TQString::number(color.pixel(), 16), edges);
 			}
 			
 			p->drawPixmap(r.left(), r.top(), *edges, 0, 0, 3, 3);
@@ -3119,14 +3119,14 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		}
 		
 		case PE_HeaderSection: { // also taskbar buttons
-			if(dynamic_cast<QWidget*>(p->device()) && dynamic_cast<QWidget*>(p->device())->isA("PanelKMenu")) {
-				QWidget* w = dynamic_cast<QWidget*>(p->device());
+			if(dynamic_cast<TQWidget*>(p->device()) && dynamic_cast<TQWidget*>(p->device())->isA("PanelKMenu")) {
+				TQWidget* w = dynamic_cast<TQWidget*>(p->device());
 				
 				if(w->parentWidget() && w->parentWidget()->paletteBackgroundPixmap()) {
 					
-					QPixmap pix(w->width(), w->height());
-					QPainter painter(&pix);
-					QPoint point = QPoint(w->geometry().x(), w->geometry().y());
+					TQPixmap pix(w->width(), w->height());
+					TQPainter painter(&pix);
+					TQPoint point = TQPoint(w->geometry().x(), w->geometry().y());
 					painter.drawTiledPixmap( 0, 0, w->width(), w->height(),
 							*w->parentWidget()->backgroundPixmap(),
 							point.x(), point.y() );
@@ -3156,7 +3156,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		case PE_ButtonCommand: {
 			
 			// the above promitives are not called from within the style
-			if(dynamic_cast<QPixmap*>(p->device())) // more likely a backgroundPixmap than a doublebuffer
+			if(dynamic_cast<TQPixmap*>(p->device())) // more likely a backgroundPixmap than a doublebuffer
 				buttonContour->setAlphaMode();
 			
 			renderButton(p, r, cg, (on||down), mouseOver, true, enabled, khtmlWidgets.contains(opt.widget()) );
@@ -3172,11 +3172,11 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		case PE_SpinWidgetMinus: {
 			p->setPen( cg.buttonText() );
 
-			int l = QMIN( w-2, h-2 );
+			int l = TQMIN( w-2, h-2 );
 			// make the length even so that we get a nice symmetric plus...
 			if(l%2 != 0)
 				--l;
-			QPoint c = r.center();
+			TQPoint c = r.center();
 
 			p->drawLine( c.x()-l/2, c.y(), c.x()+l/2, c.y() );
 			if ( pe == PE_SpinWidgetPlus ) {
@@ -3187,24 +3187,24 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 
 		case PE_ScrollBarSlider: {
 			
-			QColor buttonColor = cg.button();
+			TQColor buttonColor = cg.button();
 			
-			QPixmap buffer;
+			TQPixmap buffer;
 			if(horiz)
 				buffer.resize(r.width()-14, r.height());
 			else
 				buffer.resize(r.width(), r.height()-14);
 			if(buffer.isNull()) break;
 			
-			QRect br = buffer.rect();
-			QPainter painter(&buffer);
+			TQRect br = buffer.rect();
+			TQPainter painter(&buffer);
 
 			if(horiz) {
 				uint surfaceFlags = Is_ScrollBarBtn|Is_Horizontal;
 				renderSurface(&painter, br, cg.button(), cg.button(), buttonColor, surfaceFlags);
 
 				uint contourFlags = Is_ScrollBarBtn|Is_Horizontal|Draw_Top|Draw_Bottom;
-				renderContour(&painter, QRect(-2, 0, br.width()+4, br.height()), cg.button(), buttonColor, contourFlags);
+				renderContour(&painter, TQRect(-2, 0, br.width()+4, br.height()), cg.button(), buttonColor, contourFlags);
 
 				p->drawPixmap(r.left()+7, r.y(), buffer);
 			}
@@ -3213,19 +3213,19 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				renderSurface(&painter, br, cg.button(), cg.button(), buttonColor, surfaceFlags);
 				
 				uint contourFlags = Is_ScrollBarBtn|Draw_Left|Draw_Right;
-				renderContour(&painter, QRect(0, -2, br.width(), br.height()+4), cg.button(), buttonColor, contourFlags);
+				renderContour(&painter, TQRect(0, -2, br.width(), br.height()+4), cg.button(), buttonColor, contourFlags);
 
-				bitBlt(p->device(), r.x(), r.y()+7, &buffer, 0, 0, -1, -1, Qt::CopyROP);
+				bitBlt(p->device(), r.x(), r.y()+7, &buffer, 0, 0, -1, -1, TQt::CopyROP);
 			}
 			break;
 		}
 
 		case PE_ScrollBarAddPage: { // bottom / right
 			
-			QColor buttonColor = cg.button();
-			QColor contourColor = alphaBlendColors(buttonContour->contourColor(Contour_Default), buttonColor, 203);
-			QPixmap* addPageBtn;
-			QPixmap buffer;
+			TQColor buttonColor = cg.button();
+			TQColor contourColor = alphaBlendColors(buttonContour->contourColor(Contour_Default), buttonColor, 203);
+			TQPixmap* addPageBtn;
+			TQPixmap buffer;
 			
 			uint surfaceFlags = Is_ScrollBarBtn;
 			if(horiz)
@@ -3240,46 +3240,46 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				buffer.resize(r.width()+sl, r.height());
 				if(buffer.isNull()) break;
 				
-				if(!(addPageBtn = QPixmapCache::find(QString::number(buttonColor.pixel(), 16)+"ah"+configMode ))) {
+				if(!(addPageBtn = TQPixmapCache::find(TQString::number(buttonColor.pixel(), 16)+"ah"+configMode ))) {
 
-					QPixmap gradientPix = qembed_findImage("scrollBtnHMask");
-					QPainter painter(&gradientPix);
-					renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
-					QImage img1 = gradientPix.convertToImage();
-					QImage img2 = qembed_findImage("scrollBtnHShadow");
-					QImage img3 = tintImage(qembed_findImage("scrollBtnHContour"), contourColor);
+					TQPixmap gradientPix = qembed_findImage("scrollBtnHMask");
+					TQPainter painter(&gradientPix);
+					renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
+					TQImage img1 = gradientPix.convertToImage();
+					TQImage img2 = qembed_findImage("scrollBtnHShadow");
+					TQImage img3 = tintImage(qembed_findImage("scrollBtnHContour"), contourColor);
 					
 					blend(img2, img1, img1);
 					blend(img3, img1, img1);
 					
-					addPageBtn = new QPixmap(img1);
+					addPageBtn = new TQPixmap(img1);
 					
-					QPixmapCache::insert(QString::number(buttonColor.pixel(), 16)+"ah"+configMode, addPageBtn);
+					TQPixmapCache::insert(TQString::number(buttonColor.pixel(), 16)+"ah"+configMode, addPageBtn);
 				}
 			}
 			else {
 				buffer.resize(r.width(), r.height()+sl);
 				if(buffer.isNull()) break;
-				if(!(addPageBtn = QPixmapCache::find(QString::number(buttonColor.pixel(), 16)+"av"+configMode ))) {
-
-					QPixmap gradientPix = qembed_findImage("scrollBtnVMask");
-					QPainter painter(&gradientPix);
-					renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
-					QImage img1 = gradientPix.convertToImage();
-					QImage img2 = qembed_findImage("scrollBtnVShadow");
-					QImage img3 = tintImage(qembed_findImage("scrollBtnVContour"), contourColor);
+				if(!(addPageBtn = TQPixmapCache::find(TQString::number(buttonColor.pixel(), 16)+"av"+configMode ))) {
+
+					TQPixmap gradientPix = qembed_findImage("scrollBtnVMask");
+					TQPainter painter(&gradientPix);
+					renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
+					TQImage img1 = gradientPix.convertToImage();
+					TQImage img2 = qembed_findImage("scrollBtnVShadow");
+					TQImage img3 = tintImage(qembed_findImage("scrollBtnVContour"), contourColor);
 					
 					blend(img2, img1, img1);
 					blend(img3, img1, img1);
 					
-					addPageBtn = new QPixmap(img1);
+					addPageBtn = new TQPixmap(img1);
 					
-					QPixmapCache::insert(QString::number(buttonColor.pixel(), 16)+"av"+configMode, addPageBtn);
+					TQPixmapCache::insert(TQString::number(buttonColor.pixel(), 16)+"av"+configMode, addPageBtn);
 				}
 			}
 			
-			QRect br(buffer.rect() );
-			QPainter bp(&buffer);
+			TQRect br(buffer.rect() );
+			TQPainter bp(&buffer);
 			
 			//// groove
 			if(sliderlen >= 10) {
@@ -3287,87 +3287,87 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				if(horiz)
 					surfaceFlags |= Is_Horizontal;
 				
-				QColor grooveLine = alphaBlendColors(black, buttonColor, 80);
-				renderSurface(&bp, QRect(0, 0, br.width(), br.height()), grooveLine, grooveLine, grooveLine, surfaceFlags);
-				bp.setClipRegion(horiz ? QRect(0, 1, br.width(), br.height()-2) : QRect(1, 0, br.width()-2, br.height()));
-				renderSurface(&bp, QRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
+				TQColor grooveLine = alphaBlendColors(black, buttonColor, 80);
+				renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), grooveLine, grooveLine, grooveLine, surfaceFlags);
+				bp.setClipRegion(horiz ? TQRect(0, 1, br.width(), br.height()-2) : TQRect(1, 0, br.width()-2, br.height()));
+				renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
 				bp.setClipping(false);
 			}
 			else {
-				renderSurface(&bp, QRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
+				renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
 				uint contourFlags = Is_ScrollBarBtn;
 				contourFlags |= (horiz)? Draw_Top|Draw_Bottom : Draw_Left|Draw_Right;
-				renderContour(&bp, horiz?QRect(-2, 0, br.width()+4, br.height()):QRect(0, -2, br.width(), br.height()+4), buttonColor, buttonColor, contourFlags);
+				renderContour(&bp, horiz?TQRect(-2, 0, br.width()+4, br.height()):TQRect(0, -2, br.width(), br.height()+4), buttonColor, buttonColor, contourFlags);
 			}
 			
 			
 			
-			QString docked = (!horiz && r.height() == 1) || (horiz && r.width() == 1) ? "1" : "0";
-			QPixmap* sliderCap;
+			TQString docked = (!horiz && r.height() == 1) || (horiz && r.width() == 1) ? "1" : "0";
+			TQPixmap* sliderCap;
 			if(horiz) {
-				if(!(sliderCap = QPixmapCache::find("sHCap"+QString::number(buttonColor.pixel(), 16)+docked+configMode))) {
+				if(!(sliderCap = TQPixmapCache::find("sHCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode))) {
 					if(r.width() == 1) {
-						QPixmap gradientPix(16, 15);
-						QPainter painter(&gradientPix);
-						renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
-						QImage img1 = gradientPix.convertToImage();
+						TQPixmap gradientPix(16, 15);
+						TQPainter painter(&gradientPix);
+						renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
+						TQImage img1 = gradientPix.convertToImage();
 						
-						QImage img2 = qembed_findImage("scrollSliderHDockedShadow");
-						QImage img3 = tintImage(qembed_findImage("scrollSliderHDockedContour"), contourColor);
+						TQImage img2 = qembed_findImage("scrollSliderHDockedShadow");
+						TQImage img3 = tintImage(qembed_findImage("scrollSliderHDockedContour"), contourColor);
 						
 						bitBlt(&img1, 0, 0, &img2);
 						bitBlt(&img1, 0, 0, &img3);
 						
-						sliderCap = new QPixmap(img1);
+						sliderCap = new TQPixmap(img1);
 					}
 					else {
-						QPixmap gradientPix = qembed_findImage("scrollSliderHMask");
-						QPainter painter(&gradientPix);
+						TQPixmap gradientPix = qembed_findImage("scrollSliderHMask");
+						TQPainter painter(&gradientPix);
 						
-						renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
-						QImage img1 = gradientPix.convertToImage();
-						QImage img2 = qembed_findImage("scrollSliderHShadow");
-						QImage img3 = tintImage(qembed_findImage("scrollSliderHContour"), contourColor);
+						renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
+						TQImage img1 = gradientPix.convertToImage();
+						TQImage img2 = qembed_findImage("scrollSliderHShadow");
+						TQImage img3 = tintImage(qembed_findImage("scrollSliderHContour"), contourColor);
 						
 						blend(img2, img1, img1);
 						blend(img3, img1, img1);
 						
-						sliderCap = new QPixmap(img1);
+						sliderCap = new TQPixmap(img1);
 					}
-					QPixmapCache::insert("sHCap"+QString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
+					TQPixmapCache::insert("sHCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
 				}
 			}
 			else {
-				if(!(sliderCap = QPixmapCache::find("sVCap"+QString::number(buttonColor.pixel(), 16)+docked+configMode))) {
+				if(!(sliderCap = TQPixmapCache::find("sVCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode))) {
 					if(r.height() == 1) {
-						QPixmap gradientPix(15, 16);
-						QPainter painter(&gradientPix);
-						renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
-						QImage img1 = gradientPix.convertToImage();
+						TQPixmap gradientPix(15, 16);
+						TQPainter painter(&gradientPix);
+						renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
+						TQImage img1 = gradientPix.convertToImage();
 						
-						QImage img2 = qembed_findImage("scrollSliderVDockedShadow");
-						QImage img3 = tintImage(qembed_findImage("scrollSliderVDockedContour"), contourColor);
+						TQImage img2 = qembed_findImage("scrollSliderVDockedShadow");
+						TQImage img3 = tintImage(qembed_findImage("scrollSliderVDockedContour"), contourColor);
 						
 						bitBlt(&img1, 0, 0, &img2);
 						bitBlt(&img1, 0, 0, &img3);
 						
-						sliderCap = new QPixmap(img1);
+						sliderCap = new TQPixmap(img1);
 					}
 					else {
-						QPixmap gradientPix = qembed_findImage("scrollSliderVMask");
-						QPainter painter(&gradientPix);
+						TQPixmap gradientPix = qembed_findImage("scrollSliderVMask");
+						TQPainter painter(&gradientPix);
 						
-						renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
-						QImage img1 = gradientPix.convertToImage();
-						QImage img2 = qembed_findImage("scrollSliderVShadow");
-						QImage img3 = tintImage(qembed_findImage("scrollSliderVContour"), contourColor);
+						renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
+						TQImage img1 = gradientPix.convertToImage();
+						TQImage img2 = qembed_findImage("scrollSliderVShadow");
+						TQImage img3 = tintImage(qembed_findImage("scrollSliderVContour"), contourColor);
 						
 						blend(img2, img1, img1);
 						blend(img3, img1, img1);
 						
-						sliderCap = new QPixmap(img1);
+						sliderCap = new TQPixmap(img1);
 					}
-					QPixmapCache::insert("sVCap"+QString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
+					TQPixmapCache::insert("sVCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
 				}
 			}
 			
@@ -3379,24 +3379,24 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 					bp.drawPixmap(br.right()-8, 0, *addPageBtn, 9, 0, 9, 15);
 					bp.drawPixmap(-6+sl, 0, *sliderCap, 8, 0, 8, 15);
 				}
-				bitBlt(p->device(), r.x()-sl, r.y(), &buffer, 0, 0, br.width(), br.height(), Qt::CopyROP);
+				bitBlt(p->device(), r.x()-sl, r.y(), &buffer, 0, 0, br.width(), br.height(), TQt::CopyROP);
 			}
 			else {
 				if(sliderlen >= 10) {
 					bp.drawPixmap(0, br.bottom()-8, *addPageBtn, 0, 9, 15, 9);
 					bp.drawPixmap(0, (br.height() <= 6)? br.bottom()-6 :br.top(), *sliderCap, 0, 8, 15, 8);
 				}
-				bitBlt(p->device(), r.x(), r.y()-sl, &buffer, 0, 0, br.width(), br.height(), Qt::CopyROP);
+				bitBlt(p->device(), r.x(), r.y()-sl, &buffer, 0, 0, br.width(), br.height(), TQt::CopyROP);
 			}
 			break;
 		}
 
 		case PE_ScrollBarSubPage: { // top / left
 			
-			QColor buttonColor = cg.button();
-			QColor contourColor = alphaBlendColors(buttonContour->contourColor(Contour_Default), buttonColor, 203);
-			QPixmap* subPageBtn;
-			QPixmap buffer;
+			TQColor buttonColor = cg.button();
+			TQColor contourColor = alphaBlendColors(buttonContour->contourColor(Contour_Default), buttonColor, 203);
+			TQPixmap* subPageBtn;
+			TQPixmap buffer;
 
 			uint surfaceFlags = Is_ScrollBarBtn;
 			
@@ -3414,47 +3414,47 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				buffer.resize(r.width()+sl, r.height());
 				if(buffer.isNull()) break;
 				
-				if(!(subPageBtn = QPixmapCache::find(QString::number(buttonColor.pixel(), 16)+"sh"+configMode ))) {
+				if(!(subPageBtn = TQPixmapCache::find(TQString::number(buttonColor.pixel(), 16)+"sh"+configMode ))) {
 
-					QPixmap gradientPix = qembed_findImage("scrollBtnHMask");
-					QPainter painter(&gradientPix);
-					renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
-					QImage img1 = gradientPix.convertToImage();
-					QImage img2 = qembed_findImage("scrollBtnHShadow");
-					QImage img3 = tintImage(qembed_findImage("scrollBtnHContour"), contourColor);
+					TQPixmap gradientPix = qembed_findImage("scrollBtnHMask");
+					TQPainter painter(&gradientPix);
+					renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
+					TQImage img1 = gradientPix.convertToImage();
+					TQImage img2 = qembed_findImage("scrollBtnHShadow");
+					TQImage img3 = tintImage(qembed_findImage("scrollBtnHContour"), contourColor);
 					
 					blend(img2, img1, img1);
 					blend(img3, img1, img1);
 					
-					subPageBtn = new QPixmap(img1);
+					subPageBtn = new TQPixmap(img1);
 					
-					QPixmapCache::insert(QString::number(buttonColor.pixel(), 16)+"sh"+configMode, subPageBtn);
+					TQPixmapCache::insert(TQString::number(buttonColor.pixel(), 16)+"sh"+configMode, subPageBtn);
 				}
 			}
 			else {
 				buffer.resize(r.width(), r.height()+sl);
 				if(buffer.isNull()) break;
 				
-				if(!(subPageBtn = QPixmapCache::find(QString::number(buttonColor.pixel(), 16)+"sv"+configMode ))) {
+				if(!(subPageBtn = TQPixmapCache::find(TQString::number(buttonColor.pixel(), 16)+"sv"+configMode ))) {
 
-					QPixmap gradientPix = qembed_findImage("scrollBtnVMask");
-					QPainter painter(&gradientPix);
-					renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
-					QImage img1 = gradientPix.convertToImage();
-					QImage img2 = qembed_findImage("scrollBtnVShadow");
-					QImage img3 = tintImage(qembed_findImage("scrollBtnVContour"), contourColor);
+					TQPixmap gradientPix = qembed_findImage("scrollBtnVMask");
+					TQPainter painter(&gradientPix);
+					renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
+					TQImage img1 = gradientPix.convertToImage();
+					TQImage img2 = qembed_findImage("scrollBtnVShadow");
+					TQImage img3 = tintImage(qembed_findImage("scrollBtnVContour"), contourColor);
 					
 					blend(img2, img1, img1);
 					blend(img3, img1, img1);
 					
-					subPageBtn = new QPixmap(img1);
+					subPageBtn = new TQPixmap(img1);
 
-					QPixmapCache::insert(QString::number(buttonColor.pixel(), 16)+"sv"+configMode, subPageBtn);
+					TQPixmapCache::insert(TQString::number(buttonColor.pixel(), 16)+"sv"+configMode, subPageBtn);
 				}
 			}
 
-			QRect br(buffer.rect());
-			QPainter bp(&buffer);
+			TQRect br(buffer.rect());
+			TQPainter bp(&buffer);
 			
 			//// groove
 			if(sliderlen >= 10) {
@@ -3462,89 +3462,89 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				if(horiz)
 					surfaceFlags |= Is_Horizontal;
 				
-				QColor grooveLine = alphaBlendColors(black, buttonColor, 80);
-				renderSurface(&bp, QRect(0, 0, br.width(), br.height()), grooveLine, grooveLine, grooveLine, surfaceFlags);
-				bp.setClipRegion(horiz ? QRect(0, 1, br.width(), br.height()-2) : QRect(1, 0, br.width()-2, br.height()));
-				renderSurface(&bp, QRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
+				TQColor grooveLine = alphaBlendColors(black, buttonColor, 80);
+				renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), grooveLine, grooveLine, grooveLine, surfaceFlags);
+				bp.setClipRegion(horiz ? TQRect(0, 1, br.width(), br.height()-2) : TQRect(1, 0, br.width()-2, br.height()));
+				renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
 				bp.setClipping(false);
 			}
 			else {
-				renderSurface(&bp, QRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
+				renderSurface(&bp, TQRect(0, 0, br.width(), br.height()), buttonColor, buttonColor, buttonColor, surfaceFlags);
 				uint contourFlags = Is_ScrollBarBtn;
 				contourFlags |= (horiz)? Draw_Top|Draw_Bottom : Draw_Left|Draw_Right;
-				renderContour(&bp, horiz?QRect(-2, 0, br.width()+4, br.height()):QRect(0, -2, br.width(), br.height()+4), buttonColor, buttonColor, contourFlags);
+				renderContour(&bp, horiz?TQRect(-2, 0, br.width()+4, br.height()):TQRect(0, -2, br.width(), br.height()+4), buttonColor, buttonColor, contourFlags);
 			}
 			
 			
-			QString docked = (!horiz && r.bottom() == 15) || (horiz && r.right() == 15) ? "1" : "0";
-			QPixmap* sliderCap;
+			TQString docked = (!horiz && r.bottom() == 15) || (horiz && r.right() == 15) ? "1" : "0";
+			TQPixmap* sliderCap;
 			if(horiz) {
-				if(!(sliderCap = QPixmapCache::find("sHCap"+QString::number(buttonColor.pixel(), 16)+docked+configMode))) {
+				if(!(sliderCap = TQPixmapCache::find("sHCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode))) {
 					
 					if(r.right() == 15) {
-						QPixmap gradientPix(16, 15);
-						QPainter painter(&gradientPix);
-						renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
-						QImage img1 = gradientPix.convertToImage();
-						QImage img2 = qembed_findImage("scrollSliderHDockedShadow");
-						QImage img3 = tintImage(qembed_findImage("scrollSliderHDockedContour"), contourColor);
+						TQPixmap gradientPix(16, 15);
+						TQPainter painter(&gradientPix);
+						renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
+						TQImage img1 = gradientPix.convertToImage();
+						TQImage img2 = qembed_findImage("scrollSliderHDockedShadow");
+						TQImage img3 = tintImage(qembed_findImage("scrollSliderHDockedContour"), contourColor);
 						
 						bitBlt(&img1, 0, 0, &img2);
 						bitBlt(&img1, 0, 0, &img3);
 						
-						sliderCap = new QPixmap(img1);
+						sliderCap = new TQPixmap(img1);
 					}
 					else {
-						QPixmap gradientPix = qembed_findImage("scrollSliderHMask");
-						QPainter painter(&gradientPix);
-						renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
-						QImage img1 = gradientPix.convertToImage();
-						QImage img2 = qembed_findImage("scrollSliderHShadow");
-						QImage img3 = tintImage(qembed_findImage("scrollSliderHContour"), contourColor);
+						TQPixmap gradientPix = qembed_findImage("scrollSliderHMask");
+						TQPainter painter(&gradientPix);
+						renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn|Is_Horizontal);
+						TQImage img1 = gradientPix.convertToImage();
+						TQImage img2 = qembed_findImage("scrollSliderHShadow");
+						TQImage img3 = tintImage(qembed_findImage("scrollSliderHContour"), contourColor);
 						
 						blend(img2, img1, img1);
 						blend(img3, img1, img1);
 						
-						sliderCap = new QPixmap(img1);
+						sliderCap = new TQPixmap(img1);
 					}
 					
-					QPixmapCache::insert("sHCap"+QString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
+					TQPixmapCache::insert("sHCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
 				}
 			}
 			else {
-				if(!(sliderCap = QPixmapCache::find("sVCap"+QString::number(buttonColor.pixel(), 16)+docked+configMode))) {
+				if(!(sliderCap = TQPixmapCache::find("sVCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode))) {
 					
 					if(r.bottom() == 15) {
-						QPixmap gradientPix(15, 16);
-						QPainter painter(&gradientPix);
-						renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
-						QImage img1 = gradientPix.convertToImage();
+						TQPixmap gradientPix(15, 16);
+						TQPainter painter(&gradientPix);
+						renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
+						TQImage img1 = gradientPix.convertToImage();
 						
-						QImage img2 = qembed_findImage("scrollSliderVDockedShadow");
-						QImage img3 = tintImage(qembed_findImage("scrollSliderVDockedContour"), contourColor);
+						TQImage img2 = qembed_findImage("scrollSliderVDockedShadow");
+						TQImage img3 = tintImage(qembed_findImage("scrollSliderVDockedContour"), contourColor);
 						
 						bitBlt(&img1, 0, 0, &img2);
 						bitBlt(&img1, 0, 0, &img3);
 						
-						sliderCap = new QPixmap(img1);
+						sliderCap = new TQPixmap(img1);
 					}
 					else {
-						QPixmap gradientPix = qembed_findImage("scrollSliderVMask");
-						QPainter painter(&gradientPix);
+						TQPixmap gradientPix = qembed_findImage("scrollSliderVMask");
+						TQPainter painter(&gradientPix);
 						
-						renderSurface(&painter, QRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
-						QImage img1 = gradientPix.convertToImage();
-						QImage img2 = qembed_findImage("scrollSliderVShadow");
-						QImage img3 = tintImage(qembed_findImage("scrollSliderVContour"), contourColor);
+						renderSurface(&painter, TQRect(0, 0, gradientPix.width(), gradientPix.height()), cg.button(), cg.button(), buttonColor, Is_ScrollBarBtn);
+						TQImage img1 = gradientPix.convertToImage();
+						TQImage img2 = qembed_findImage("scrollSliderVShadow");
+						TQImage img3 = tintImage(qembed_findImage("scrollSliderVContour"), contourColor);
 						
 						blend(img2, img1, img1);
 						blend(img3, img1, img1);
 						
-						sliderCap = new QPixmap(img1);
+						sliderCap = new TQPixmap(img1);
 					}
 					
 					
-					QPixmapCache::insert("sVCap"+QString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
+					TQPixmapCache::insert("sVCap"+TQString::number(buttonColor.pixel(), 16)+docked+configMode, sliderCap);
 				}
 			}
 			
@@ -3561,7 +3561,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				}
 			}
 			
-			bitBlt(p->device(), r.x(), r.y(), &buffer, 0, 0, br.width(), br.height(), Qt::CopyROP);
+			bitBlt(p->device(), r.x(), r.y(), &buffer, 0, 0, br.width(), br.height(), TQt::CopyROP);
 			break;
 		}
 
@@ -3572,9 +3572,9 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			
 			uint contourFlags = Is_ScrollBarBtn;
 			
-			QRect cr = r;
-			QRect ar = r;
-			QRect sr = r;
+			TQRect cr = r;
+			TQRect ar = r;
+			TQRect sr = r;
 			
 			if(horiz) {
 				contourFlags |= Is_Horizontal|Draw_Top|Draw_Bottom;
@@ -3605,17 +3605,17 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			}
 			
 			if(horiz) {
-				renderSurface(p, QRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
-				renderContour(p, QRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
+				renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
+				renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
 			}
 			else {
-				p->setClipRegion(QRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
-				renderSurface(p, QRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
+				p->setClipRegion(TQRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
+				renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
 				p->setClipping(false);
-				renderContour(p, QRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
+				renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
 			}
 			
-			QColor color = dynamic_cast<QWidget*>(p->device()) ? dynamic_cast<QWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
+			TQColor color = dynamic_cast<TQWidget*>(p->device()) ? dynamic_cast<TQWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
 			p->setPen(color);
 			drawPrimitive((horiz ? PE_ArrowLeft : PE_ArrowUp), p, ar, cg, flags);
 
@@ -3624,9 +3624,9 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 
 		case PE_ScrollBarAddLine: { // bottom / right button
 			
-			QRect cr = r;
-			QRect ar = r;
-			QRect sr = r;
+			TQRect cr = r;
+			TQRect ar = r;
+			TQRect sr = r;
 			if(horiz) {
 				sr.setWidth(13);
 				ar.setX(r.x()-4);
@@ -3639,18 +3639,18 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 
 			if(horiz) {
 				uint contourFlags = Is_ScrollBarBtn|Is_Horizontal|Draw_Top|Draw_Bottom|Draw_Right|Round_UpperRight|Round_BottomRight;
-				renderSurface(p, QRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
-				renderContour(p, QRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
+				renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
+				renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
 			}
 			else {
-				p->setClipRegion(QRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
-				renderSurface(p, QRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
+				p->setClipRegion(TQRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
+				renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
 				p->setClipping(false);
 				uint contourFlags = Is_ScrollBarBtn|Draw_Bottom|Draw_Left|Draw_Right|Round_BottomLeft|Round_BottomRight;
-				renderContour(p, QRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
+				renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
 			}
 			
-			QColor color = dynamic_cast<QWidget*>(p->device()) ? dynamic_cast<QWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
+			TQColor color = dynamic_cast<TQWidget*>(p->device()) ? dynamic_cast<TQWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
 			p->setPen(color);
 			drawPrimitive((horiz ? PE_ArrowRight : PE_ArrowDown), p, ar, cg, flags);
 			
@@ -3662,9 +3662,9 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			
 			uint contourFlags = Is_ScrollBarBtn;
 			
-			QRect cr = r;
-			QRect ar = r;
-			QRect sr = r;
+			TQRect cr = r;
+			TQRect ar = r;
+			TQRect sr = r;
 			
 			if(horiz) {
 				contourFlags |= Is_Horizontal|Draw_Top|Draw_Bottom;
@@ -3675,17 +3675,17 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			}
 			
 			if(horiz) {
-				renderSurface(p, QRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
-				renderContour(p, QRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
+				renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn|Is_Horizontal);
+				renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
 			}
 			else {
-				p->setClipRegion(QRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
-				renderSurface(p, QRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
+				p->setClipRegion(TQRect(sr.x()+2, sr.y(), sr.width()-4, sr.height()));
+				renderSurface(p, TQRect(sr.x(), sr.y(), sr.width(), sr.height()), cg.button(), cg.button(), cg.button(), Is_ScrollBarBtn);
 				p->setClipping(false);
-				renderContour(p, QRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
+				renderContour(p, TQRect(cr.x(), cr.y(), cr.width(), cr.height()), cg.button(), cg.button(), contourFlags);
 			}
 			
-			QColor color = dynamic_cast<QWidget*>(p->device()) ? dynamic_cast<QWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
+			TQColor color = dynamic_cast<TQWidget*>(p->device()) ? dynamic_cast<TQWidget*>(p->device())->palette().active().buttonText() : cg.buttonText();
 			p->setPen(color);
 			drawPrimitive((horiz ? PE_ArrowLeft : PE_ArrowUp), p, ar, cg, flags);
 			
@@ -3711,7 +3711,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 
 		case PE_ExclusiveIndicatorMask: {
 
-			QPointArray pa(8);
+			TQPointArray pa(8);
 			pa.setPoint(0, 3,6);
 			pa.setPoint(1, 6,3);
 			pa.setPoint(2, 10,3);
@@ -3757,7 +3757,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		}
 
 		case PE_GroupBoxFrame:
-		case PE_PanelGroupBox: { // QFrame::GroupBoxPanel
+		case PE_PanelGroupBox: { // TQFrame::GroupBoxPanel
 			break;
 		}
 
@@ -3768,12 +3768,12 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			p->setPen(cg.background().dark(120));
 			p->drawRect(r);
 			p->setPen(cg.background().light(110));
-			p->drawRect(QRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2));
+			p->drawRect(TQRect(r.x()+1, r.y()+1, r.width()-2, r.height()-2));
 			
 			break;
 		}
 
-		case PE_Panel: { // QFrame::StyledPanel
+		case PE_Panel: { // TQFrame::StyledPanel
 			if(kickerMode)
 				break;
 			
@@ -3798,11 +3798,11 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			break;
 		}
 
-		case PE_PanelLineEdit: { // QFrame::LineEditPanel
+		case PE_PanelLineEdit: { // TQFrame::LineEditPanel
 			break;
 		}
 
-		case PE_PanelTabWidget: { // QFrame::TabWidgetPanel
+		case PE_PanelTabWidget: { // TQFrame::TabWidgetPanel
 			
 			// we get a wrong clip rect
 			p->setClipping(false);
@@ -3813,20 +3813,20 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			bool roundBottomRight = true;
 			bool tabsAbove = true;
 			
-// 			p->fillRect(QRect(r.x()-10, r.y()-10, r.width()+20, r.height()+20), yellow);
+// 			p->fillRect(TQRect(r.x()-10, r.y()-10, r.width()+20, r.height()+20), yellow);
 			
-			QRect tr;
-			QWidget* w = dynamic_cast<QWidget*>(p->device());
-			QTabWidget* tw = w ? dynamic_cast<QTabWidget*>(w->parentWidget()) : 0;
-			bool tabBarHidden = tw && !((DominoQTabWidget*)tw)->tabBar()->isVisible();
+			TQRect tr;
+			TQWidget* w = dynamic_cast<TQWidget*>(p->device());
+			TQTabWidget* tw = w ? dynamic_cast<TQTabWidget*>(w->parentWidget()) : 0;
+			bool tabBarHidden = tw && !((DominoTQTabWidget*)tw)->tabBar()->isVisible();
 			if(tw && !tabBarHidden) {
 				
-				tabsAbove = tw->tabPosition() == QTabWidget::Top;
+				tabsAbove = tw->tabPosition() == TQTabWidget::Top;
 				
 				if(tw->count() != 0) {
 					
-					QTabBar* tb = ((DominoQTabWidget*)tw)->tabBar();
-					QRect gr = tb->geometry();
+					TQTabBar* tb = ((DominoTQTabWidget*)tw)->tabBar();
+					TQRect gr = tb->geometry();
 					
 					if(tb->isVisible()) {
 						tr = tb->tabAt(tw->currentPageIndex())->rect();
@@ -3834,13 +3834,13 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 						tr.moveBy(gr.x(), tabsAbove ? 0 : r.height()-2);
 					}
 					
-					if(!tw->cornerWidget(Qt::TopLeft) && gr.x() < 7) {
+					if(!tw->cornerWidget(TQt::TopLeft) && gr.x() < 7) {
 						if(tabsAbove)
 							roundTopLeft = false;
 						else
 							roundBottomLeft = false;
 					}
-					if(!tw->cornerWidget(Qt::TopRight) && gr.x()+gr.width() > tw->width()-7) {
+					if(!tw->cornerWidget(TQt::TopRight) && gr.x()+gr.width() > tw->width()-7) {
 						if(tabsAbove)
 							roundTopRight = false;
 						else
@@ -3848,51 +3848,51 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 					}
 				}
 			}
-			QBrush background = tw ? tw->colorGroup().brush(QColorGroup::Background) : cg.brush(QColorGroup::Background);
-			QColor bottomGradient = alphaBlendColors(QColor(0,0,0), cg.background(), 11);
-			QColor topGradient = alphaBlendColors(QColor(255,255,255), cg.background(), 15);
-			QColor tabContour2 = cg.background().dark(150);
+			TQBrush background = tw ? tw->colorGroup().brush(TQColorGroup::Background) : cg.brush(TQColorGroup::Background);
+			TQColor bottomGradient = alphaBlendColors(TQColor(0,0,0), cg.background(), 11);
+			TQColor topGradient = alphaBlendColors(TQColor(255,255,255), cg.background(), 15);
+			TQColor tabContour2 = cg.background().dark(150);
 			
 			
-			QString tabPos = tabsAbove ? "1" : "0";
-			QPixmap* tabWEdges;
-			if(!(tabWEdges = QPixmapCache::find("tabWEdges"+tabPos+QString::number(background.color().pixel(), 16)+QString::number(cg.background().pixel(), 16)))) {
-				tabWEdges = new QPixmap(16,16);
-				QPainter painter(tabWEdges);
+			TQString tabPos = tabsAbove ? "1" : "0";
+			TQPixmap* tabWEdges;
+			if(!(tabWEdges = TQPixmapCache::find("tabWEdges"+tabPos+TQString::number(background.color().pixel(), 16)+TQString::number(cg.background().pixel(), 16)))) {
+				tabWEdges = new TQPixmap(16,16);
+				TQPainter painter(tabWEdges);
 				painter.fillRect(tabWEdges->rect(), background);
 				painter.end();
 				
-				QPixmap tabWEdgesMask = qembed_findImage("groupBoxMask");
+				TQPixmap tabWEdgesMask = qembed_findImage("groupBoxMask");
 				painter.begin(&tabWEdgesMask);
-				painter.fillRect(tabWEdgesMask.rect(), cg.brush(QColorGroup::Background));
+				painter.fillRect(tabWEdgesMask.rect(), cg.brush(TQColorGroup::Background));
 				painter.end();
 				bitBlt(tabWEdges, 0, 0, &tabWEdgesMask);
 				
-				QPixmap circle = qembed_findImage("tabWidget");
+				TQPixmap circle = qembed_findImage("tabWidget");
 				bitBlt(tabWEdges, 0, 0, &circle);
 				
-				QPixmapCache::insert("tabWEdges"+tabPos+QString::number(background.color().pixel(), 16)+QString::number(cg.background().pixel(), 16), tabWEdges);
+				TQPixmapCache::insert("tabWEdges"+tabPos+TQString::number(background.color().pixel(), 16)+TQString::number(cg.background().pixel(), 16), tabWEdges);
 			}
 			
 			
-			QRect re = QRect(r.x(), r.y(), r.width(), r.height()+1);
-			QColor bg = cg.background();
-			QColor bg2 = background.color(); // parent color
+			TQRect re = TQRect(r.x(), r.y(), r.width(), r.height()+1);
+			TQColor bg = cg.background();
+			TQColor bg2 = background.color(); // parent color
 			
 			// top
-			QColor c1 = alphaBlendColors(QColor(0,0,0), bg2, 25);
-			QColor c2 = alphaBlendColors(QColor(255,255,255), bg, 70);
-			QColor c3 = alphaBlendColors(QColor(255,255,255), bg, 30);
+			TQColor c1 = alphaBlendColors(TQColor(0,0,0), bg2, 25);
+			TQColor c2 = alphaBlendColors(TQColor(255,255,255), bg, 70);
+			TQColor c3 = alphaBlendColors(TQColor(255,255,255), bg, 30);
 				
 			// left + right
-			QColor c4 = alphaBlendColors(QColor(0,0,0), bg2, 40);
-// 			QColor c5 = alphaBlendColors(QColor(255,255,255), bg, 30);
-			QColor c6 = alphaBlendColors(QColor(255,255,255), bg, 4);
+			TQColor c4 = alphaBlendColors(TQColor(0,0,0), bg2, 40);
+// 			TQColor c5 = alphaBlendColors(TQColor(255,255,255), bg, 30);
+			TQColor c6 = alphaBlendColors(TQColor(255,255,255), bg, 4);
 				
 			// bottom
-			QColor c7 = alphaBlendColors(QColor(249,249,249), bg, 25);
-			QColor c8 = alphaBlendColors(QColor(0,0,0), bg2, 79);
-			QColor c9 = alphaBlendColors(QColor(0,0,0), bg2, 30);
+			TQColor c7 = alphaBlendColors(TQColor(249,249,249), bg, 25);
+			TQColor c8 = alphaBlendColors(TQColor(0,0,0), bg2, 79);
+			TQColor c9 = alphaBlendColors(TQColor(0,0,0), bg2, 30);
 			
 			// top
 			p->setPen(c1);
@@ -3933,16 +3933,16 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			
 			
 			if(roundTopLeft) {
-				bitBlt(p->device(), re.x(), re.y(), tabWEdges, 0, 0, 8, 8, Qt::CopyROP);
+				bitBlt(p->device(), re.x(), re.y(), tabWEdges, 0, 0, 8, 8, TQt::CopyROP);
 			}
 			if(roundTopRight) {
-				bitBlt(p->device(), re.width()-8, re.y(), tabWEdges, 8, 0, 8, 8, Qt::CopyROP);
+				bitBlt(p->device(), re.width()-8, re.y(), tabWEdges, 8, 0, 8, 8, TQt::CopyROP);
 			}
 			if(roundBottomLeft) {
-				bitBlt(p->device(), re.x(), re.height()-8, tabWEdges, 0, 8, 8, 8, Qt::CopyROP);
+				bitBlt(p->device(), re.x(), re.height()-8, tabWEdges, 0, 8, 8, 8, TQt::CopyROP);
 			}
 			if(roundBottomRight) {
-				bitBlt(p->device(), re.width()-8, re.height()-8, tabWEdges, 8, 8, 8, 8, Qt::CopyROP);
+				bitBlt(p->device(), re.width()-8, re.height()-8, tabWEdges, 8, 8, 8, 8, TQt::CopyROP);
 			}
 			
 			
@@ -3951,9 +3951,9 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				p->fillRect(tr, cg.background()); // ### shrink
 				
 				if(tabsAbove) {
-					QColor p1 = alphaBlendColors(QColor(255,255,255), bg, 50);
-					QColor p2 = alphaBlendColors(QColor(255,255,255), bg, 25);
-					QColor p3 = alphaBlendColors(QColor(255,255,255), bg, 10);
+					TQColor p1 = alphaBlendColors(TQColor(255,255,255), bg, 50);
+					TQColor p2 = alphaBlendColors(TQColor(255,255,255), bg, 25);
+					TQColor p3 = alphaBlendColors(TQColor(255,255,255), bg, 10);
 					
 					p->setPen(p1);
 					p->drawPoint(tr.left(), tr.top()+1);
@@ -3968,8 +3968,8 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 					p->drawPoint(tr.right()-1, tr.top()+2);
 				}
 				else {
-					QColor p1 = alphaBlendColors(QColor(255,255,255), bg, 17);
-					QColor p2 = alphaBlendColors(QColor(255,255,255), bg, 10);
+					TQColor p1 = alphaBlendColors(TQColor(255,255,255), bg, 17);
+					TQColor p2 = alphaBlendColors(TQColor(255,255,255), bg, 10);
 					
 					p->setPen(p1);
 					p->drawPoint(tr.left(), tr.top());
@@ -3986,19 +3986,19 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			break;
 		}
 
-		case PE_PanelPopup: { // QFrame::PopupPanel
+		case PE_PanelPopup: { // TQFrame::PopupPanel
 			
-			QPopupMenu* pm = dynamic_cast<QPopupMenu*>(p->device());
-			QColor background = dynamic_cast<QListBox*>(p->device()) ? cg.base() : _customPopupMenuColor ? _popupMenuColor : cg.background();
+			TQPopupMenu* pm = dynamic_cast<TQPopupMenu*>(p->device());
+			TQColor background = dynamic_cast<TQListBox*>(p->device()) ? cg.base() : _customPopupMenuColor ? _popupMenuColor : cg.background();
 			
-			QRegion mask(x, y+5, w, h-10);
-			mask += QRegion(x+5, y, w-10, h);
-			mask += QRegion(x+1, y+2, w-2, h-4);
-			mask += QRegion(x+2, y+1, w-4, h-2);
+			TQRegion mask(x, y+5, w, h-10);
+			mask += TQRegion(x+5, y, w-10, h);
+			mask += TQRegion(x+1, y+2, w-2, h-4);
+			mask += TQRegion(x+2, y+1, w-4, h-2);
 			
 			if(_drawPopupMenuGradient) {
-				QPixmap buffer(r.width(), r.height());
-				QPainter bp(&buffer);
+				TQPixmap buffer(r.width(), r.height());
+				TQPainter bp(&buffer);
 				renderGradient(&bp, r, lightenColor(background, 18), darkenColor(background, 12), true);
 			
 				if(pm) {
@@ -4023,22 +4023,22 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			if(pm) {
 				if(pm->isA("PrettyPopupMenu") || pm->isA("Amarok::Menu") || pm->isA("Digikam::DPopupMenu")) {
 					// these popups have a side pixmap and are drawing the frame after the contents
-					QRect cr = pm->contentsRect();
-					if(QApplication::reverseLayout())
-						pm->erase(mask-QRegion(cr.width()+3, cr.y(), r.width()-cr.width()-6, cr.height()-1));
+					TQRect cr = pm->contentsRect();
+					if(TQApplication::reverseLayout())
+						pm->erase(mask-TQRegion(cr.width()+3, cr.y(), r.width()-cr.width()-6, cr.height()-1));
 					else
-						pm->erase(mask-QRegion(r.x()+3, cr.y(), r.width()-cr.width()-6, cr.height()-1));
-					((DominoQFrame*)pm)->drawContents(p );
+						pm->erase(mask-TQRegion(r.x()+3, cr.y(), r.width()-cr.width()-6, cr.height()-1));
+					((DominoTQFrame*)pm)->drawContents(p );
 				}
 				else
 					pm->erase(mask);
 			}
 			
 			
-			bitBlt(p->device(), r.x(), r.y(), popupFrame, 0, 0, 5, 5, Qt::CopyROP);
-			bitBlt(p->device(), r.width()-5, r.y(), popupFrame, 5, 0, 5, 5, Qt::CopyROP);
-			bitBlt(p->device(), r.x(), r.bottom()-4, popupFrame, 0, 5, 5, 5, Qt::CopyROP);
-			bitBlt(p->device(), r.width()-5, r.bottom()-4, popupFrame, 5, 5, 5, 5, Qt::CopyROP);
+			bitBlt(p->device(), r.x(), r.y(), popupFrame, 0, 0, 5, 5, TQt::CopyROP);
+			bitBlt(p->device(), r.width()-5, r.y(), popupFrame, 5, 0, 5, 5, TQt::CopyROP);
+			bitBlt(p->device(), r.x(), r.bottom()-4, popupFrame, 0, 5, 5, 5, TQt::CopyROP);
+			bitBlt(p->device(), r.width()-5, r.bottom()-4, popupFrame, 5, 5, 5, 5, TQt::CopyROP);
 			
 			p->setPen(background.dark(150));
 			p->drawLine(r.x()+5, r.y(), r.width()-6, r.y());
@@ -4051,15 +4051,15 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 
 	// MENU / TOOLBAR PANEL
 	// --------------------
-		case PE_PanelMenuBar: // QFrame::MenuBarPanel
-		case PE_PanelDockWindow: { // QFrame::ToolBarPanel
+		case PE_PanelMenuBar: // TQFrame::MenuBarPanel
+		case PE_PanelDockWindow: { // TQFrame::ToolBarPanel
 
 			p->setPen(cg.background());
 			// overpainting the menus leads to flicker so we draw only the frame here.
-			if(dynamic_cast<QWidget*>(p->device()))
+			if(dynamic_cast<TQWidget*>(p->device()))
 				p->drawRect(r);
 			else
-				p->fillRect(r, cg.brush(QColorGroup::Background)); // colorpreview in kcontrol
+				p->fillRect(r, cg.brush(TQColorGroup::Background)); // colorpreview in kcontrol
 			break;
 		}
 
@@ -4074,11 +4074,11 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 	// TOOLBAR/DOCK WINDOW HANDLE
 	// --------------------------
 		case PE_DockWindowResizeHandle: {
-			QWidget* w = dynamic_cast<QWidget*>(p->device()); // QDockWindowResizeHandle
+			TQWidget* w = dynamic_cast<TQWidget*>(p->device()); // TQDockWindowResizeHandle
 			
 			if(w && !w->erasePixmap()) {
-				QPixmap pix(r.size());
-				QPainter painter(&pix);
+				TQPixmap pix(r.size());
+				TQPainter painter(&pix);
 				renderGradient(&painter, r, lightenColor(cg.background(), 40), darkenColor(cg.background(), 30), horiz);
 				w->setErasePixmap(pix);
 			}
@@ -4086,7 +4086,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		}
 
 		case PE_DockWindowHandle: {
-			QWidget* widget = dynamic_cast<QWidget*>(p->device()); // qt_dockwidget_internal - QDockWindowHandle
+			TQWidget* widget = dynamic_cast<TQWidget*>(p->device()); // qt_dockwidget_internal - TQDockWindowHandle
 			
 			int ch, cs, cv;
 			cg.background().getHsv(ch, cs, cv);
@@ -4146,7 +4146,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			else if ( flags & Style_Off ) {
 			}
 			else {// tristate
-				p->setPen(_customCheckMarkColor ? _checkMarkColor : qApp->palette().active().foreground());
+				p->setPen(_customCheckMarkColor ? _checkMarkColor : tqApp->palette().active().foreground());
 				p->drawLine(6,6,11,6);
 				p->drawLine(6,8,11,8);
 				p->drawLine(6,10,11,10);
@@ -4157,27 +4157,27 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 
 		case PE_SpinWidgetUp:
 		case PE_SpinWidgetDown: {
-			QPixmap* arrow;
+			TQPixmap* arrow;
 			bool isEnabled = (flags & Style_Enabled);
-			QString enabled = isEnabled ? "1" : "0";
-			QColor color = p->pen().color();
+			TQString enabled = isEnabled ? "1" : "0";
+			TQColor color = p->pen().color();
 			
-			if(!(arrow = QPixmapCache::find(QString::number(color.pixel(), 16)+"spinArrows"+enabled))) {
-				QImage ar = tintImage(qembed_findImage("spinBoxArrows"), color);
+			if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"spinArrows"+enabled))) {
+				TQImage ar = tintImage(qembed_findImage("spinBoxArrows"), color);
 				if(!isEnabled) { // make it transparent
 					ar = setImageOpacity(ar, 25);
 				}
-				arrow = new QPixmap(ar);
-				QPixmapCache::insert(QString::number(color.pixel(), 16)+"spinArrows"+enabled, arrow);
+				arrow = new TQPixmap(ar);
+				TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"spinArrows"+enabled, arrow);
 			}
 			
 			if(textEffectSettings.mode) {
-				QPixmap* effectArrow;
-				if(!(effectArrow = QPixmapCache::find(QString::number(textEffectSettings.buttonColor.pixel(), 16)+"spinEArrows"+enabled))) {
-					QImage img = tintImage(qembed_findImage("spinBoxArrows"), textEffectSettings.buttonColor);
+				TQPixmap* effectArrow;
+				if(!(effectArrow = TQPixmapCache::find(TQString::number(textEffectSettings.buttonColor.pixel(), 16)+"spinEArrows"+enabled))) {
+					TQImage img = tintImage(qembed_findImage("spinBoxArrows"), textEffectSettings.buttonColor);
 					int opacity = textEffectSettings.buttonOpacity*100/255;
-					effectArrow = new QPixmap(setImageOpacity(img, !isEnabled ? opacity*25/100 : opacity));
-					QPixmapCache::insert(QString::number(textEffectSettings.buttonColor.pixel(), 16)+"spinEArrows"+enabled, effectArrow);
+					effectArrow = new TQPixmap(setImageOpacity(img, !isEnabled ? opacity*25/100 : opacity));
+					TQPixmapCache::insert(TQString::number(textEffectSettings.buttonColor.pixel(), 16)+"spinEArrows"+enabled, effectArrow);
 				}
 				bitBlt(p->device(), r.x()+7/2+1+textEffectSettings.buttonPos.x(), r.y()+r.height()/2-3+textEffectSettings.buttonPos.y(), effectArrow, 0, pe == PE_SpinWidgetDown ? 5 : 0, 7, 5);
 				
@@ -4192,7 +4192,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		case PE_ArrowLeft:
 		case PE_ArrowRight: {
 			
-			QRect re = r;
+			TQRect re = r;
 			int x2, w2, h2;
 			int x = -4;
 			switch (pe) {
@@ -4239,27 +4239,27 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			}
 			
 			
-			QPixmap* arrow;
+			TQPixmap* arrow;
 			bool isEnabled = (flags & Style_Enabled);
-			QString enabled = isEnabled ? "1" : "0";
-			QColor color = p->pen().color();
+			TQString enabled = isEnabled ? "1" : "0";
+			TQColor color = p->pen().color();
 			
-			if(!(arrow = QPixmapCache::find(QString::number(color.pixel(), 16)+"scrollBarArrows"+enabled))) {
-				QImage ar = tintImage(qembed_findImage("scrollBarArrows"), color);
+			if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"scrollBarArrows"+enabled))) {
+				TQImage ar = tintImage(qembed_findImage("scrollBarArrows"), color);
 				if(!isEnabled) {
 					ar = setImageOpacity(ar, 25);
 				}
-				arrow = new QPixmap(ar);
-				QPixmapCache::insert(QString::number(color.pixel(), 16)+"scrollBarArrows"+enabled, arrow);
+				arrow = new TQPixmap(ar);
+				TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"scrollBarArrows"+enabled, arrow);
 			}
 			
 			if(/*pe == PE_HeaderArrow &&*/ textEffectSettings.mode) {
-				QPixmap* effectArrow;
-				if(!(effectArrow = QPixmapCache::find(QString::number(textEffectSettings.buttonColor.pixel(), 16)+"scrollBarEArrows"+enabled))) {
-					QImage img = tintImage(qembed_findImage("scrollBarArrows"), textEffectSettings.buttonColor);
+				TQPixmap* effectArrow;
+				if(!(effectArrow = TQPixmapCache::find(TQString::number(textEffectSettings.buttonColor.pixel(), 16)+"scrollBarEArrows"+enabled))) {
+					TQImage img = tintImage(qembed_findImage("scrollBarArrows"), textEffectSettings.buttonColor);
 					int opacity = textEffectSettings.buttonOpacity*100/255;
-					effectArrow = new QPixmap(setImageOpacity(img, !isEnabled ? opacity*25/100 : opacity));
-					QPixmapCache::insert(QString::number(textEffectSettings.buttonColor.pixel(), 16)+"scrollBarEArrows"+enabled, effectArrow);
+					effectArrow = new TQPixmap(setImageOpacity(img, !isEnabled ? opacity*25/100 : opacity));
+					TQPixmapCache::insert(TQString::number(textEffectSettings.buttonColor.pixel(), 16)+"scrollBarEArrows"+enabled, effectArrow);
 				}
 				p->drawPixmap(re.x()+re.width()/2+x+textEffectSettings.buttonPos.x(), re.y()+re.height()/2-3+textEffectSettings.buttonPos.y(), *effectArrow, x2, 0, w2, h2);
 			}
@@ -4269,25 +4269,25 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		}
 
 		case PE_CheckListIndicator: {
-			// the rect in not correctly calculated in Qt, so the controller rect is 2px above the drawn rect.
+			// the rect in not correctly calculated in TQt, so the controller rect is 2px above the drawn rect.
 			
-			QCheckListItem *item = opt.checkListItem();
-			QListView *lv = item->listView();
+			TQCheckListItem *item = opt.checkListItem();
+			TQListView *lv = item->listView();
 			if(!item)
 				return;
 			
-			QString state = flags& Style_On ? "1" : "0";
+			TQString state = flags& Style_On ? "1" : "0";
 			state += flags& Style_Selected ? "1" : "0";
 			state += flags& Style_NoChange ? "1" : "0";
 			
-			QColor background = flags& Style_Selected ? cg.highlight() : cg.base();
-			QColor foreground = cg.text();
+			TQColor background = flags& Style_Selected ? cg.highlight() : cg.base();
+			TQColor foreground = cg.text();
 			
-			QPixmap* pix;
-			if(!(pix = QPixmapCache::find(QString::number(background.pixel(), 16)+QString::number(foreground.pixel(), 16)+"checkListIndicator"+state))) {
-				pix = new QPixmap(r.x()+lv->itemMargin()+r.width()+4, item->height());
+			TQPixmap* pix;
+			if(!(pix = TQPixmapCache::find(TQString::number(background.pixel(), 16)+TQString::number(foreground.pixel(), 16)+"checkListIndicator"+state))) {
+				pix = new TQPixmap(r.x()+lv->itemMargin()+r.width()+4, item->height());
 				pix->fill(background);
-				QPainter painter(pix);
+				TQPainter painter(pix);
 				
 				painter.setPen(alphaBlendColors(foreground, background, 127));
 				painter.drawLine(r.x()+1, r.y()+1, r.x()+12, r.y()+1); // t
@@ -4309,7 +4309,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				if(flags& Style_On)
 					painter.drawPixmap(r.x()-1, r.y(), tintImage(qembed_findImage("checkmark"), foreground));
 				
-				QPixmapCache::insert(QString::number(background.pixel(), 16)+QString::number(foreground.pixel(), 16)+"checkListIndicator"+state, pix);
+				TQPixmapCache::insert(TQString::number(background.pixel(), 16)+TQString::number(foreground.pixel(), 16)+"checkListIndicator"+state, pix);
 			}
 			
 			p->drawPixmap(0, 0, *pix);
@@ -4317,7 +4317,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		}
 		
 		case PE_CheckListExclusiveIndicator: {
-			QColor background = flags& Style_Selected ? cg.highlight() : cg.base();
+			TQColor background = flags& Style_Selected ? cg.highlight() : cg.base();
 			p->drawPixmap(r.left()+3, r.top()+1, tintImage(qembed_findImage("checkListExclusiveIndicator"), alphaBlendColors(cg.text(), background, 127)));
 
 			if(flags&Style_On)
@@ -4327,24 +4327,24 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 		
 		case PE_SizeGrip: {
 			
-			bool parentBgPix = cg.brush(QColorGroup::Background).pixmap();
-			QString trans = parentBgPix ? "1" : "0";
-			QPixmap* grip;
-			if(!(grip = QPixmapCache::find(QString::number(cg.background().pixel(), 16)+"sizeGrip"+trans))) {
+			bool parentBgPix = cg.brush(TQColorGroup::Background).pixmap();
+			TQString trans = parentBgPix ? "1" : "0";
+			TQPixmap* grip;
+			if(!(grip = TQPixmapCache::find(TQString::number(cg.background().pixel(), 16)+"sizeGrip"+trans))) {
 				if(parentBgPix)
-					grip = new QPixmap(qembed_findImage("sizeGrip"));
+					grip = new TQPixmap(qembed_findImage("sizeGrip"));
 				else {
-					grip = new QPixmap(4, 4);
+					grip = new TQPixmap(4, 4);
 					grip->fill(cg.background());
-					QPixmap tmpPix = qembed_findImage("sizeGrip");
-					bitBlt(grip, 0, 0, &tmpPix, 0, 0, -1, -1, Qt::CopyROP);
+					TQPixmap tmpPix = qembed_findImage("sizeGrip");
+					bitBlt(grip, 0, 0, &tmpPix, 0, 0, -1, -1, TQt::CopyROP);
 				}
-				QPixmapCache::insert(QString::number(cg.background().pixel(), 16)+"sizeGrip"+trans, grip);
+				TQPixmapCache::insert(TQString::number(cg.background().pixel(), 16)+"sizeGrip"+trans, grip);
 			}
 			
-			bitBlt(p->device(), r.width()-(QApplication::reverseLayout() ? 12 : 6), r.height()-12, grip, 0, 0, -1, -1, Qt::CopyROP);
-			bitBlt(p->device(), r.width()-6, r.height()-6, grip, 0, 0, -1, -1, Qt::CopyROP);
-			bitBlt(p->device(), r.width()-12, r.height()-6, grip, 0, 0, -1, -1, Qt::CopyROP);
+			bitBlt(p->device(), r.width()-(TQApplication::reverseLayout() ? 12 : 6), r.height()-12, grip, 0, 0, -1, -1, TQt::CopyROP);
+			bitBlt(p->device(), r.width()-6, r.height()-6, grip, 0, 0, -1, -1, TQt::CopyROP);
+			bitBlt(p->device(), r.width()-12, r.height()-6, grip, 0, 0, -1, -1, TQt::CopyROP);
 			break;
 		}
 		
@@ -4360,7 +4360,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 #endif
 				if(rubberBandType == LineRubber) {
 					p->save();
-					p->setPen(QPen(black, 1, Qt::SolidLine));
+					p->setPen(TQPen(black, 1, TQt::SolidLine));
 					p->drawRect(r);
 					p->restore();
 				}
@@ -4373,7 +4373,7 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			
 			
 			bool normalized = r.width() < 0 || r.height() < 0;
-			QRect re = normalized? r.normalize(): r;
+			TQRect re = normalized? r.normalize(): r;
 			
 			if(re.y() < 0)
 				re.setY(-3);
@@ -4385,21 +4385,21 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 				break;
 			}
 
-			QColor fg = alphaBlendColors(_argbRubberBandColor, black, 127);
-			const QWidget* w = dynamic_cast<QWidget*>(p->device());
+			TQColor fg = alphaBlendColors(_argbRubberBandColor, black, 127);
+			const TQWidget* w = dynamic_cast<TQWidget*>(p->device());
 			if(!w)
 				w = rubberViewPort;
 			
-			QPoint po = w->mapToGlobal(QPoint(0,0));
-			QRect gr = QRect(po.x(), po.y(), w->width(), w->height());
+			TQPoint po = w->mapToGlobal(TQPoint(0,0));
+			TQRect gr = TQRect(po.x(), po.y(), w->width(), w->height());
 			
-			QRegion mask(re.x()+1, re.y(), re.width()-2, re.height());
-			mask += QRegion(re.x(), re.y()+1, re.width(), re.height()-2);
+			TQRegion mask(re.x()+1, re.y(), re.width()-2, re.height());
+			mask += TQRegion(re.x(), re.y()+1, re.width(), re.height()-2);
 			
 			rubber->create(gr, mask);
 			
 			
-			GC gc2 = XCreateGC(qt_xdisplay(), rubber->window, 0, 0);
+			GC gc2 = XCreateGC(tqt_xdisplay(), rubber->window, 0, 0);
 			
 			/////// erasing
 			XRectangle xrect;
@@ -4437,39 +4437,39 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			}
 			
 			for(int i = 0; i<num; i++)
-				XClearArea(qt_xdisplay(), rubber->window, outline[i].x, outline[i].y, outline[i].width, outline[i].height, false);
+				XClearArea(tqt_xdisplay(), rubber->window, outline[i].x, outline[i].y, outline[i].width, outline[i].height, false);
 			
 			xrect.x = oldRubberRect.x()+1;
 			xrect.y = oldRubberRect.y()+1;
 			xrect.width = 2;
 			xrect.height = 2;
-			XClearArea(qt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
+			XClearArea(tqt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
 			
 			xrect.x = oldRubberRect.x()+1;
 			xrect.y = oldRubberRect.y()+oldRubberRect.height()-3;
 			xrect.width = 2;
 			xrect.height = 2;
-			XClearArea(qt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
+			XClearArea(tqt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
 			
 			xrect.x = oldRubberRect.x()+oldRubberRect.width()-3;
 			xrect.y = oldRubberRect.y()+1;
 			xrect.width = 2;
 			xrect.height = 2;
-			XClearArea(qt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
+			XClearArea(tqt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
 			
 			xrect.x = oldRubberRect.x()+oldRubberRect.width()-3;
 			xrect.y = oldRubberRect.y()+oldRubberRect.height()-3;
 			xrect.width = 2;
 			xrect.height = 2;
-			XClearArea(qt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
+			XClearArea(tqt_xdisplay(), rubber->window, xrect.x, xrect.y, xrect.width, xrect.height, false);
 			
 			
 			rubber->updateMask(mask);
 			
 			///////////// painting
 			
-			XSetForeground(qt_xdisplay(), gc2, preMultiplyColor(qRgba(fg.red(), fg.green(), fg.blue(),153)));
-			XDrawRectangle(qt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
+			XSetForeground(tqt_xdisplay(), gc2, preMultiplyColor(tqRgba(fg.red(), fg.green(), fg.blue(),153)));
+			XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
 			
 			// inside
 			XRectangle xrects[8];
@@ -4514,10 +4514,10 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			xrects[7].width = 1;
 			xrects[7].height = 1;
 			
-			QColor blendc = qRgba(fg.red(), fg.green(), fg.blue(), 36);
-			XSetForeground(qt_xdisplay(), gc2, preMultiplyColor(blendColors(_argbRubberBandColor, blendc).rgb()));
-			XSetClipRectangles(qt_xdisplay(), gc2, 0, 0, xrects, 8, Unsorted);
-			XDrawRectangle(qt_xdisplay(), rubber->window, gc2, re.x()+1, re.y()+1, re.width()-3, re.height()-3);
+			TQColor blendc = tqRgba(fg.red(), fg.green(), fg.blue(), 36);
+			XSetForeground(tqt_xdisplay(), gc2, preMultiplyColor(blendColors(_argbRubberBandColor, blendc).rgb()));
+			XSetClipRectangles(tqt_xdisplay(), gc2, 0, 0, xrects, 8, Unsorted);
+			XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x()+1, re.y()+1, re.width()-3, re.height()-3);
 			
 			XRectangle xrects2[8];
 			// top left
@@ -4582,10 +4582,10 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			xrects2[11].height = 1;
 			
 			
-			XSetForeground(qt_xdisplay(), gc2, preMultiplyColor(qRgba(fg.red(), fg.green(), fg.blue(), 121)));
-			XSetClipRectangles(qt_xdisplay(), gc2, 0, 0, xrects2, 12, Unsorted);
-			XDrawRectangle(qt_xdisplay(), rubber->window, gc2, re.x()+1, re.y()+1, re.width()-3, re.height()-3);
-			XDrawRectangle(qt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
+			XSetForeground(tqt_xdisplay(), gc2, preMultiplyColor(tqRgba(fg.red(), fg.green(), fg.blue(), 121)));
+			XSetClipRectangles(tqt_xdisplay(), gc2, 0, 0, xrects2, 12, Unsorted);
+			XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x()+1, re.y()+1, re.width()-3, re.height()-3);
+			XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
 			
 			// outermost pixels
 			XRectangle xrects3[8];
@@ -4630,12 +4630,12 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 			xrects3[7].width = 1;
 			xrects3[7].height = 1;
 			
-			XSetForeground(qt_xdisplay(), gc2, preMultiplyColor(qRgba(fg.red(), fg.green(), fg.blue(), 37)));
-			XSetClipRectangles(qt_xdisplay(), gc2, 0, 0, xrects3, 8, Unsorted);
-			XDrawRectangle(qt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
+			XSetForeground(tqt_xdisplay(), gc2, preMultiplyColor(tqRgba(fg.red(), fg.green(), fg.blue(), 37)));
+			XSetClipRectangles(tqt_xdisplay(), gc2, 0, 0, xrects3, 8, Unsorted);
+			XDrawRectangle(tqt_xdisplay(), rubber->window, gc2, re.x(), re.y(), re.width()-1, re.height()-1);
 			
-			XFlush(qt_xdisplay());
-			XFreeGC(qt_xdisplay(),gc2);
+			XFlush(tqt_xdisplay());
+			XFreeGC(tqt_xdisplay(),gc2);
 			oldRubberRect = re;
 			
 			break;
@@ -4648,12 +4648,12 @@ void DominoStyle::drawPrimitive(PrimitiveElement pe,
 }
 
 void DominoStyle::drawControl(ControlElement element,
-							  QPainter *p,
-							  const QWidget *widget,
-							  const QRect &r,
-							  const QColorGroup &cg,
+							  TQPainter *p,
+							  const TQWidget *widget,
+							  const TQRect &r,
+							  const TQColorGroup &cg,
 							  SFlags flags,
-							  const QStyleOption& opt) const
+							  const TQStyleOption& opt) const
 {
 	
 	const bool enabled = (flags & Style_Enabled);
@@ -4667,33 +4667,33 @@ void DominoStyle::drawControl(ControlElement element,
 			if(widget->isA("KToolBarButton")) {
 				DominoKToolBarButton* tb= (DominoKToolBarButton *) widget;
 	
-				QStyle::SFlags flags   = QStyle::Style_Default;
-				QStyle::SCFlags active = QStyle::SC_None;
+				TQStyle::SFlags flags   = TQStyle::Style_Default;
+				TQStyle::SCFlags active = TQStyle::SC_None;
 	
 				if (tb->isDown()) {
-					flags  |= QStyle::Style_Down;
-					active |= QStyle::SC_ToolButton;
+					flags  |= TQStyle::Style_Down;
+					active |= TQStyle::SC_ToolButton;
 				}
-				if (tb->isEnabled()) 	flags |= QStyle::Style_Enabled;
-				if (tb->isOn()) 		flags |= QStyle::Style_On;
-				if (tb->isEnabled() && tb->hasMouse())	flags |= QStyle::Style_Raised;
-				if (tb->hasFocus())	flags |= QStyle::Style_HasFocus;
+				if (tb->isEnabled()) 	flags |= TQStyle::Style_Enabled;
+				if (tb->isOn()) 		flags |= TQStyle::Style_On;
+				if (tb->isEnabled() && tb->hasMouse())	flags |= TQStyle::Style_Raised;
+				if (tb->hasFocus())	flags |= TQStyle::Style_HasFocus;
 				
 				int dx, dy;
-				QFont tmp_font(KGlobalSettings::toolBarFont());
-				QFontMetrics fm(tmp_font);
-				QRect textRect;
+				TQFont tmp_font(KGlobalSettings::toolBarFont());
+				TQFontMetrics fm(tmp_font);
+				TQRect textRect;
 				int textFlags = 0;
 				
 				
-				QPixmap pixmap;
+				TQPixmap pixmap;
 				if (tb->iconTextMode() != KToolBar::TextOnly) {
-					pixmap =tb->iconSet().pixmap( QIconSet::Automatic,
-						tb->isEnabled() ? (tb->isActive() ? QIconSet::Active : QIconSet::Normal) :
-								QIconSet::Disabled,
-						tb->isOn() ? QIconSet::On : QIconSet::Off );
+					pixmap =tb->iconSet().pixmap( TQIconSet::Automatic,
+						tb->isEnabled() ? (tb->isActive() ? TQIconSet::Active : TQIconSet::Normal) :
+								TQIconSet::Disabled,
+						tb->isOn() ? TQIconSet::On : TQIconSet::Off );
 					
-					QImage img = pixmap.convertToImage();
+					TQImage img = pixmap.convertToImage();
 					if((_toolBtnAsBtn || tb->isToggleButton()) && (tb->isDown() || tb->isOn()))
 						pixmap = KImageEffect::fade(img, 0.10, black);
 					else if(tb->isDown() || tb->isOn())
@@ -4703,9 +4703,9 @@ void DominoStyle::drawControl(ControlElement element,
 					
 				}
 				
-				QPixmap outlinePixmap = 0;
+				TQPixmap outlinePixmap = 0;
 				bool drawOutlinePixmap = false;
-				if(flags &QStyle::Style_HasFocus && focusIndicatorSettings.indicateFocus && !pixmap.isNull()) {
+				if(flags &TQStyle::Style_HasFocus && focusIndicatorSettings.indicateFocus && !pixmap.isNull()) {
 					outlinePixmap = renderOutlineIcon(&pixmap);
 					drawOutlinePixmap = true;
 				}
@@ -4748,7 +4748,7 @@ void DominoStyle::drawControl(ControlElement element,
 							dx = 4;
 						dy = 0;
 	
-						textRect = QRect(dx, dy, tb->width()-dx, tb->height()-1);
+						textRect = TQRect(dx, dy, tb->width()-dx, tb->height()-1);
 					}
 				}
 				else if (tb->iconTextMode() == KToolBar::TextOnly)
@@ -4759,7 +4759,7 @@ void DominoStyle::drawControl(ControlElement element,
 						dx = (tb->width() - fm.width(tb->textLabel())) / 2;
 						dy = (tb->height()-1 - fm.lineSpacing()) / 2;
 	
-						textRect = QRect( dx, dy, fm.width(tb->textLabel()), fm.lineSpacing() );
+						textRect = TQRect( dx, dy, fm.width(tb->textLabel()), fm.lineSpacing() );
 					}
 				}
 				else if (tb->iconTextMode() == KToolBar::IconTextBottom)
@@ -4782,13 +4782,13 @@ void DominoStyle::drawControl(ControlElement element,
 						dx = (tb->width() - fm.width(tb->textLabel())) / 2;
 						dy = tb->height()-1 - fm.lineSpacing() - 4;
 	
-						textRect = QRect( dx, dy, fm.width(tb->textLabel()), fm.lineSpacing() );
+						textRect = TQRect( dx, dy, fm.width(tb->textLabel()), fm.lineSpacing() );
 					}
 				}
 				if (!tb->textLabel().isNull() && !textRect.isNull())
 				{
 					p->setFont(KGlobalSettings::toolBarFont());
-					QColor pencolor;
+					TQColor pencolor;
 					if (!tb->isEnabled())
 						pencolor = tb->palette().disabled().dark();
 					// replaced through icon highlights
@@ -4800,52 +4800,52 @@ void DominoStyle::drawControl(ControlElement element,
 					dominoDrawItem( p, textRect, textFlags, cg, enabled, 0, tb->textLabel(), -1, &pencolor, textEffectSettings.mode > 0 ? 1 : 0);
 				}
 			}
-			else { // QToolButton - bye bye win95 iconset mode :)
+			else { // TQToolButton - bye bye win95 iconset mode :)
 				
-				const QToolButton *toolbutton = (const QToolButton *) widget;
-				QRect rect = r;
-				Qt::ArrowType arrowType = opt.isDefault() ? Qt::DownArrow : opt.arrowType();
+				const TQToolButton *toolbutton = (const TQToolButton *) widget;
+				TQRect rect = r;
+				TQt::ArrowType arrowType = opt.isDefault() ? TQt::DownArrow : opt.arrowType();
 				
 				if (!opt.isDefault()) {
 					PrimitiveElement pe;
 					switch (arrowType) {
-						case Qt::LeftArrow:  pe = PE_ArrowLeft;  break;
-						case Qt::RightArrow: pe = PE_ArrowRight; break;
-						case Qt::UpArrow:    pe = PE_ArrowUp;    break;
+						case TQt::LeftArrow:  pe = PE_ArrowLeft;  break;
+						case TQt::RightArrow: pe = PE_ArrowRight; break;
+						case TQt::UpArrow:    pe = PE_ArrowUp;    break;
 						default:
-						case Qt::DownArrow:  pe = PE_ArrowDown;  break;
+						case TQt::DownArrow:  pe = PE_ArrowDown;  break;
 					}
 					
 					drawPrimitive(pe, p, rect, cg, flags, opt);
 				}
 				else {
 					
-					QColor btext = toolbutton->paletteForegroundColor();
+					TQColor btext = toolbutton->paletteForegroundColor();
 
 					if (toolbutton->iconSet().isNull() && ! toolbutton->text().isNull() && ! toolbutton->usesTextLabel()) {
 						int alignment = AlignCenter | ShowPrefix;
-						if (!styleHint(SH_UnderlineAccelerator, widget, QStyleOption::Default, 0))
+						if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
 							alignment |= NoAccel;
 						dominoDrawItem( p, rect, alignment, cg, enabled, 0, toolbutton->text(), toolbutton->text().length(), &btext, textEffectSettings.mode > 0 ? 1 : 0);
 					}
 					else {
-						QPixmap pm;
-						QIconSet::Size size = toolbutton->usesBigPixmap() ? QIconSet::Large : QIconSet::Small;
-						QIconSet::State state = toolbutton->isOn() ? QIconSet::On : QIconSet::Off;
-						QIconSet::Mode mode;
+						TQPixmap pm;
+						TQIconSet::Size size = toolbutton->usesBigPixmap() ? TQIconSet::Large : TQIconSet::Small;
+						TQIconSet::State state = toolbutton->isOn() ? TQIconSet::On : TQIconSet::Off;
+						TQIconSet::Mode mode;
 /*						if (!toolbutton->isEnabled())
-							mode = QIconSet::Disabled;
+							mode = TQIconSet::Disabled;
 						else*/ if (flags & (Style_Down | Style_On) || (flags & Style_Raised) && (flags & Style_AutoRaise))
-							mode = QIconSet::Active;
+							mode = TQIconSet::Active;
 						else
-							mode = QIconSet::Normal;
+							mode = TQIconSet::Normal;
 						
 						pm = toolbutton->iconSet().pixmap( size, mode, state );
 						
 						if(!toolbutton->isEnabled())
 							pm = disableIcon(&pm);
 						
-						QImage img = pm.convertToImage();
+						TQImage img = pm.convertToImage();
 						if((_toolBtnAsBtn || toolbutton->isToggleButton()) && (toolbutton->isDown() || toolbutton->isOn()))
 							pm = KImageEffect::fade(img, 0.10, black);
 						else if(toolbutton->isDown() || toolbutton->isOn())
@@ -4853,47 +4853,47 @@ void DominoStyle::drawControl(ControlElement element,
 						else if(_highlightToolBtnIcon && toolbutton->hasMouse() && toolbutton->isEnabled())
 							pm = KImageEffect::fade(img, 0.25, white);
 						
-						QPixmap outlinePixmap = 0;
+						TQPixmap outlinePixmap = 0;
 						bool drawOutlinePixmap = false;
-						if(flags &QStyle::Style_HasFocus && focusIndicatorSettings.indicateFocus) {
+						if(flags &TQStyle::Style_HasFocus && focusIndicatorSettings.indicateFocus) {
 							outlinePixmap = renderOutlineIcon(&pm);
 							drawOutlinePixmap = true;
 						}
 						
 						if ( toolbutton->usesTextLabel() ) {
 							p->setFont( toolbutton->font() );
-							QRect pr = rect, tr = rect;
+							TQRect pr = rect, tr = rect;
 							int alignment = ShowPrefix;
-							if (!styleHint(SH_UnderlineAccelerator, widget, QStyleOption::Default, 0))
+							if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
 								alignment |= NoAccel;
 
-							if ( toolbutton->textPosition() == QToolButton::Under ) {
+							if ( toolbutton->textPosition() == TQToolButton::Under ) {
 								int fh = p->fontMetrics().height();
 								pr.addCoords( 0, 1, 0, -fh-3 );
 								tr.addCoords( 0, pr.bottom(), 0, -3 );
 								
 								if(drawOutlinePixmap)
-									drawItem( p, pr, AlignCenter, cg, TRUE, &outlinePixmap, QString::null );
+									drawItem( p, pr, AlignCenter, cg, TRUE, &outlinePixmap, TQString::null );
 								
-								drawItem( p, pr, AlignCenter, cg, TRUE, &pm, QString::null );
+								drawItem( p, pr, AlignCenter, cg, TRUE, &pm, TQString::null );
 								alignment |= AlignCenter;
 							} else {
 								pr.setWidth( pm.width() + 8 );
 								tr.addCoords( pr.right(), 0, 0, 0 );
 								
 								if(drawOutlinePixmap)
-									drawItem( p, pr, AlignCenter, cg, TRUE, &outlinePixmap, QString::null );
+									drawItem( p, pr, AlignCenter, cg, TRUE, &outlinePixmap, TQString::null );
 								
-								drawItem( p, pr, AlignCenter, cg, TRUE, &pm, QString::null );
+								drawItem( p, pr, AlignCenter, cg, TRUE, &pm, TQString::null );
 								alignment |= AlignLeft | AlignVCenter;
 							}
 							dominoDrawItem( p, tr, alignment, cg, enabled, 0, toolbutton->textLabel(), toolbutton->textLabel().length(), &btext, textEffectSettings.mode > 0 ? 1 : 0);
 						}
 						else {
 							if(drawOutlinePixmap)
-								drawItem( p, rect, AlignCenter, cg, TRUE, &outlinePixmap, QString::null );
+								drawItem( p, rect, AlignCenter, cg, TRUE, &outlinePixmap, TQString::null );
 							
-							drawItem( p, rect, AlignCenter, cg, TRUE, &pm, QString::null );
+							drawItem( p, rect, AlignCenter, cg, TRUE, &pm, TQString::null );
 						}
 					}
 				}
@@ -4910,14 +4910,14 @@ void DominoStyle::drawControl(ControlElement element,
 
 		case CE_ProgressBarContents: {
 			
-			const QProgressBar *pb = dynamic_cast<const QProgressBar*>(widget);
+			const TQProgressBar *pb = dynamic_cast<const TQProgressBar*>(widget);
 			int steps = pb->totalSteps();
 			
-			const QColor bg = enabled? cg.base(): cg.background(); // background
-			const QColor fg = cg.background();
-			bool reverseLayout = QApplication::reverseLayout();
+			const TQColor bg = enabled? cg.base(): cg.background(); // background
+			const TQColor fg = cg.background();
+			bool reverseLayout = TQApplication::reverseLayout();
 			
-			QPixmap* prBgShadow;
+			TQPixmap* prBgShadow;
 			
 			int h, s, v, bv;
 			bg.getHsv(&h, &s, &v);
@@ -4925,19 +4925,19 @@ void DominoStyle::drawControl(ControlElement element,
 			int diff = KMAX(v-bv, 0);
 			
 			// if we don't adjust the shadow to the background, it will look strange
-			QColor tintColor = alphaBlendColors(Qt::black, bg, diff+30);
+			TQColor tintColor = alphaBlendColors(TQt::black, bg, diff+30);
 			
-			if(!(prBgShadow = QPixmapCache::find(QString::number(bg.pixel(), 16)+QString::number(cg.background().pixel(), 16)+"prBgShadow"))) {
-				prBgShadow = new QPixmap(4,4);
+			if(!(prBgShadow = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(cg.background().pixel(), 16)+"prBgShadow"))) {
+				prBgShadow = new TQPixmap(4,4);
 				prBgShadow->fill(bg);
-				QPainter painter(prBgShadow);
+				TQPainter painter(prBgShadow);
 				painter.drawPixmap(0, 0, tintImage(qembed_findImage("progressShadow2"), tintColor));
-				QPixmapCache::insert(QString::number(bg.pixel(), 16)+QString::number(cg.background().pixel(), 16)+"prBgShadow", prBgShadow);
+				TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.background().pixel(), 16)+"prBgShadow", prBgShadow);
 			}
 			
-			QRect surface;
-			QRect rightBg;
-			QRect leftBg;
+			TQRect surface;
+			TQRect rightBg;
+			TQRect leftBg;
 			p->setClipRegion(r);
 			
 			
@@ -4949,13 +4949,13 @@ void DominoStyle::drawControl(ControlElement element,
 				if( progress > r.width()-barWidth )
 					progress = (r.width()-barWidth)-(progress-(r.width()-barWidth));
 				
-				surface  = QRect(reverseLayout? r.right()-progress+1: r.x()+progress+1, r.top(), barWidth-2, r.height());
-				rightBg = reverseLayout ? QRect(r.x(), r.y(), r.width()-(progress-1), r.height()) :
-						QRect(r.x()+progress+barWidth-1, r.y(), r.width()-(progress+barWidth-1), r.height());
+				surface  = TQRect(reverseLayout? r.right()-progress+1: r.x()+progress+1, r.top(), barWidth-2, r.height());
+				rightBg = reverseLayout ? TQRect(r.x(), r.y(), r.width()-(progress-1), r.height()) :
+						TQRect(r.x()+progress+barWidth-1, r.y(), r.width()-(progress+barWidth-1), r.height());
 				
 				if(rightBg.width()+surface.width() < r.width()) {
-					leftBg = reverseLayout ? QRect(rightBg.width()+surface.width(), r.y(), r.width()-(rightBg.width()+surface.width()-2), r.height()) :
-							QRect(r.x(), r.y(), r.x()+progress+1, r.height());
+					leftBg = reverseLayout ? TQRect(rightBg.width()+surface.width(), r.y(), r.width()-(rightBg.width()+surface.width()-2), r.height()) :
+							TQRect(r.x(), r.y(), r.x()+progress+1, r.height());
 				}
 			}
 			else {
@@ -4964,25 +4964,25 @@ void DominoStyle::drawControl(ControlElement element,
 				if(w < 0)
 					w = 0;
 				int w2 = r.width()-(r.width()-w);
-				rightBg = QRect(reverseLayout? r.left(): r.left()+w, r.top(), r.width()-w, r.height());
-				surface = QRect(reverseLayout? r.right()-w2+1: r.left(), r.top(), w2, r.height());
+				rightBg = TQRect(reverseLayout? r.left(): r.left()+w, r.top(), r.width()-w, r.height());
+				surface = TQRect(reverseLayout? r.right()-w2+1: r.left(), r.top(), w2, r.height());
 			}
 			
 			
 			
-			QPixmap* surfaceTile;
-			if(!(surfaceTile = QPixmapCache::find("prTile"+QString::number(surface.height())+QString::number(bg.pixel(), 16)))) {
-				surfaceTile = new QPixmap(20, surface.height());
-				QPainter tilePainter(surfaceTile);
+			TQPixmap* surfaceTile;
+			if(!(surfaceTile = TQPixmapCache::find("prTile"+TQString::number(surface.height())+TQString::number(bg.pixel(), 16)))) {
+				surfaceTile = new TQPixmap(20, surface.height());
+				TQPainter tilePainter(surfaceTile);
 				
 				flatMode=true;
-				renderSurface(&tilePainter, QRect(0, 0, 20, surface.height()), fg,  cg.background(), fg , Is_Button|Is_Horizontal);
+				renderSurface(&tilePainter, TQRect(0, 0, 20, surface.height()), fg,  cg.background(), fg , Is_Button|Is_Horizontal);
 				flatMode=false;
 				
-				QPixmap pix = qembed_findImage("progressTile");
+				TQPixmap pix = qembed_findImage("progressTile");
 				tilePainter.drawTiledPixmap(0,0, 20, surface.height(), pix);
 				
-				QPixmapCache::insert("prTile"+QString::number(surface.height())+QString::number(bg.pixel(), 16), surfaceTile);
+				TQPixmapCache::insert("prTile"+TQString::number(surface.height())+TQString::number(bg.pixel(), 16), surfaceTile);
 			}
 			
 			
@@ -4990,8 +4990,8 @@ void DominoStyle::drawControl(ControlElement element,
 			int animShift = 0;
 			
 			// find the animation Offset for the current Widget
-			QWidget* nonConstWidget = const_cast<QWidget*>(widget);
-			QMapConstIterator<QWidget*, int> iter = progAnimWidgets.find(nonConstWidget);
+			TQWidget* nonConstWidget = const_cast<TQWidget*>(widget);
+			TQMapConstIterator<TQWidget*, int> iter = progAnimWidgets.find(nonConstWidget);
 			if (iter != progAnimWidgets.end())
 				animShift = iter.data();
 			
@@ -5009,9 +5009,9 @@ void DominoStyle::drawControl(ControlElement element,
 			
 			// empty area
 			
-			QColor color_d = alphaBlendColors(tintColor, bg, 170);
-			QColor color_m = alphaBlendColors(tintColor, bg, 85);
-			QColor color_l = alphaBlendColors(tintColor, bg, 25);
+			TQColor color_d = alphaBlendColors(tintColor, bg, 170);
+			TQColor color_m = alphaBlendColors(tintColor, bg, 85);
+			TQColor color_l = alphaBlendColors(tintColor, bg, 25);
 			
 			if(leftBg.isValid()) {
 				p->setClipRegion(leftBg);
@@ -5074,8 +5074,8 @@ void DominoStyle::drawControl(ControlElement element,
 			break;
 		}
 		case CE_ProgressBarLabel: {
-			const QProgressBar *progressbar = (const QProgressBar *) widget;
-			QFont font = p->font();
+			const TQProgressBar *progressbar = (const TQProgressBar *) widget;
+			TQFont font = p->font();
 			font.setBold(false);
 			p->setFont(font);
 			p->setPen(cg.buttonText());
@@ -5086,28 +5086,28 @@ void DominoStyle::drawControl(ControlElement element,
 		
 		case CE_CheckBox: {
 			
-			QColorGroup g = cg;
+			TQColorGroup g = cg;
 			if(!khtmlWidgets.contains(widget))
-				g.setColor(QColorGroup::Button, qApp->palette().active().background());
+				g.setColor(TQColorGroup::Button, tqApp->palette().active().background());
 			
-			QPixmap insidePix = qembed_findImage("checkbox2inside");
-			QPainter painter(&insidePix);
-			renderSurface(&painter, QRect(3, 0, 14, 19), g.background(), g.button(), g.button(), Is_CheckItem);
+			TQPixmap insidePix = qembed_findImage("checkbox2inside");
+			TQPainter painter(&insidePix);
+			renderSurface(&painter, TQRect(3, 0, 14, 19), g.background(), g.button(), g.button(), Is_CheckItem);
 			painter.end();
-			QImage inside = insidePix.convertToImage();
+			TQImage inside = insidePix.convertToImage();
 			
-			QImage checkbox;
-			QImage shadow = qembed_findImage("checkbox2shadow");
-			QImage circle = tintImage(qembed_findImage("checkbox2rect"), buttonContour->contourColor(Contour_Default));
+			TQImage checkbox;
+			TQImage shadow = qembed_findImage("checkbox2shadow");
+			TQImage circle = tintImage(qembed_findImage("checkbox2rect"), buttonContour->contourColor(Contour_Default));
 			blend(shadow, inside, checkbox);
 			blend(circle, checkbox, checkbox);
 			
 			if(flags&Style_Down) {
-				QImage pressed = tintImage(qembed_findImage("checkbox2pressed"), buttonContour->contourColor(Contour_Pressed));
+				TQImage pressed = tintImage(qembed_findImage("checkbox2pressed"), buttonContour->contourColor(Contour_Pressed));
 				blend(pressed, checkbox, checkbox);
 			}
 			
-			QPixmap pix = QPixmap(checkbox);
+			TQPixmap pix = TQPixmap(checkbox);
 			if(flags&Style_On || flags&Style_NoChange) {
 				painter.begin(&pix);
 				drawPrimitive(PE_CheckMark, &painter, r, cg, flags);
@@ -5119,13 +5119,13 @@ void DominoStyle::drawControl(ControlElement element,
 		}
 		
 		case CE_CheckBoxLabel: {
-			const QCheckBox *cb = (const QCheckBox *) widget;
+			const TQCheckBox *cb = (const TQCheckBox *) widget;
 
-			int alignment = QApplication::reverseLayout() ? AlignRight : AlignLeft;
-			if (!styleHint(SH_UnderlineAccelerator, widget, QStyleOption::Default, 0))
+			int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
+			if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
 				alignment |= NoAccel;
 			
-			QRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_CheckBoxFocusRect, cb) : r;
+			TQRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_CheckBoxFocusRect, cb) : r;
 			
 			if (flags& Style_HasFocus && focusIndicatorSettings.indicateFocus)
 				drawFocusIndicator(p, re, alignment | AlignVCenter |ShowPrefix, cg, flags & Style_Enabled, cb->pixmap(), cb->text(), -1, focusIndicatorSettings.color, focusIndicatorSettings.drawUnderline);
@@ -5138,34 +5138,34 @@ void DominoStyle::drawControl(ControlElement element,
 	// RADIOBUTTONS
 	// ------------
 		case CE_RadioButton: {
-			QColorGroup g = cg;
+			TQColorGroup g = cg;
 			if(!khtmlWidgets.contains(widget))
-				g.setColor(QColorGroup::Button, qApp->palette().active().background());
+				g.setColor(TQColorGroup::Button, tqApp->palette().active().background());
 			
-			QString down = flags& Style_Down ? "1" : "0";
+			TQString down = flags& Style_Down ? "1" : "0";
 			
-			QPixmap* radio;
-			if((flags & Domino_noCache) || !(radio = QPixmapCache::find("tabEdges"+down))) {
-				QImage radioImg;
+			TQPixmap* radio;
+			if((flags & Domino_noCache) || !(radio = TQPixmapCache::find("tabEdges"+down))) {
+				TQImage radioImg;
 				
-				QPixmap insidePix = qembed_findImage("radio3inside");
-				QPainter painter(&insidePix);
-				renderSurface(&painter, QRect(r.left(), r.top(), r.width(), r.height()+1), g.background(), g.button(), g.background(), Is_CheckItem);
-				QImage inside = insidePix.convertToImage();
+				TQPixmap insidePix = qembed_findImage("radio3inside");
+				TQPainter painter(&insidePix);
+				renderSurface(&painter, TQRect(r.left(), r.top(), r.width(), r.height()+1), g.background(), g.button(), g.background(), Is_CheckItem);
+				TQImage inside = insidePix.convertToImage();
 				
-				QImage shadow = qembed_findImage("radio3shadow");
-				QImage circle = tintImage(qembed_findImage("radio3circle"), buttonContour->contourColor(Contour_Default));
+				TQImage shadow = qembed_findImage("radio3shadow");
+				TQImage circle = tintImage(qembed_findImage("radio3circle"), buttonContour->contourColor(Contour_Default));
 				blend(shadow, inside, inside);
 				blend(circle, inside, radioImg);
 				
 				if(flags&Style_Down) {
-					QImage pressed = tintImage(qembed_findImage("radio3pressed"), buttonContour->contourColor(Contour_Default));
+					TQImage pressed = tintImage(qembed_findImage("radio3pressed"), buttonContour->contourColor(Contour_Default));
 					blend(pressed, radioImg, radioImg);
 				}
 				
-				radio = new QPixmap(radioImg);
+				radio = new TQPixmap(radioImg);
 				if(!(flags & Domino_noCache))
-					QPixmapCache::insert("radio"+down, radio);
+					TQPixmapCache::insert("radio"+down, radio);
 			
 			}
 
@@ -5181,13 +5181,13 @@ void DominoStyle::drawControl(ControlElement element,
 		}
 		
 		case CE_RadioButtonLabel: {
-			const QRadioButton *radiobutton = (const QRadioButton *) widget;
+			const TQRadioButton *radiobutton = (const TQRadioButton *) widget;
 
-			int alignment = QApplication::reverseLayout() ? AlignRight : AlignLeft;
-			if (!styleHint(SH_UnderlineAccelerator, widget, QStyleOption::Default, 0))
+			int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
+			if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
 			alignment |= NoAccel;
 			
-			QRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_RadioButtonFocusRect, radiobutton) : r;
+			TQRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_RadioButtonFocusRect, radiobutton) : r;
 			
 			if (flags& Style_HasFocus && focusIndicatorSettings.indicateFocus)
 				drawFocusIndicator(p, re, alignment | AlignVCenter |ShowPrefix, cg, flags & Style_Enabled, radiobutton->pixmap(), radiobutton->text(), -1, focusIndicatorSettings.color, focusIndicatorSettings.drawUnderline);
@@ -5202,21 +5202,21 @@ void DominoStyle::drawControl(ControlElement element,
 	// ----
 		case CE_TabBarTab: {
 			
-			QTabBar * tb = (QTabBar *) widget;
+			TQTabBar * tb = (TQTabBar *) widget;
 			
 			bool konqTab = false;
 			bool kickoffTab = false;
 			if(tb->parentWidget()) {
-				const QWidget* w = tb->parentWidget();
+				const TQWidget* w = tb->parentWidget();
 				if(w->isA("KonqFrameTabs"))
 					konqTab = true;
 				else if(!strcmp(w->name(), "SUSE::Kickoff::KMenu"))
 					kickoffTab = true;
 			}
 
-			QTabBar::Shape tbs = tb->shape();
+			TQTabBar::Shape tbs = tb->shape();
 			bool selected = false;
-			bool reverseLayout = QApplication::reverseLayout();
+			bool reverseLayout = TQApplication::reverseLayout();
 			if (flags & Style_Selected) selected = true;
 			TabPosition pos;
 			if (tb->count() == 1) {
@@ -5230,32 +5230,32 @@ void DominoStyle::drawControl(ControlElement element,
 			}
 			
 			switch (tbs) {
-				case QTabBar::TriangularAbove:
+				case TQTabBar::TriangularAbove:
 					renderTab(p, r, cg, (flags & Style_MouseOver), selected, false, pos, true, false, konqTab);
 					break;
-				case QTabBar::RoundedAbove:
+				case TQTabBar::RoundedAbove:
 					renderTab(p, r, cg, (flags & Style_MouseOver), selected, false, pos, false, false, konqTab);
 					break;
-				case QTabBar::TriangularBelow:
+				case TQTabBar::TriangularBelow:
 					renderTab(p, r, cg, (flags & Style_MouseOver), selected, true, pos, true, false, konqTab);
 					break;
-				case QTabBar::RoundedBelow:
+				case TQTabBar::RoundedBelow:
 					renderTab(p, r, cg, (flags & Style_MouseOver), selected, true, pos, false, false, konqTab);
 					break;
 				default:
 					KStyle::drawControl(element, p, widget, r, cg, flags, opt);
 			}
 			
-			// Qt3 uses this painter to draw the iconSet between CE_TabBarTab and CE_TabBarLabel. If we clip the painter here
+			// TQt3 uses this painter to draw the iconSet between CE_TabBarTab and CE_TabBarLabel. If we clip the painter here
 			// we will have a clean area to draw the icon at the right position in CE_TabBarLabel.
 			if(!kickoffTab)
-				p->setClipRect(QRect());
+				p->setClipRect(TQRect());
 			break;
 		}
 
 		case CE_PushButton: {
 			
-			QPushButton *button = (QPushButton *)widget;
+			TQPushButton *button = (TQPushButton *)widget;
 			bool khtmlMode = khtmlWidgets.contains(button);
 			bool isDefault = enabled && button->isDefault();
 			bool isHoverWidget = enabled && button == hoverWidget;
@@ -5265,20 +5265,20 @@ void DominoStyle::drawControl(ControlElement element,
 			uint surfaceFlags = Is_Button|Is_Horizontal;
 			flatMode = button->isFlat();
 			
-			QColor bg;
+			TQColor bg;
 			if(!khtmlMode && !button->paletteBackgroundPixmap()) {
 				
-				if(dynamic_cast<QGroupBox*>(button->parentWidget())) {
+				if(dynamic_cast<TQGroupBox*>(button->parentWidget())) {
 					bg = button->parentWidget()->paletteBackgroundColor();
 				}
 				else {
 					bg = cg.background();
 				}
 				
-				p->fillRect(QRect(r.x(), r.y(), 6, 6), bg);
-				p->fillRect(QRect(r.width()-6, r.y(), 6, 6), bg);
-				p->fillRect(QRect(r.width()-6, r.height()-7, 6,7), bg);
-				p->fillRect(QRect(r.x(), r.height()-7, 6, 7), bg);
+				p->fillRect(TQRect(r.x(), r.y(), 6, 6), bg);
+				p->fillRect(TQRect(r.width()-6, r.y(), 6, 6), bg);
+				p->fillRect(TQRect(r.width()-6, r.height()-7, 6,7), bg);
+				p->fillRect(TQRect(r.x(), r.height()-7, 6, 7), bg);
 			}
 			else {
 				buttonContour->setAlphaMode();
@@ -5302,29 +5302,29 @@ void DominoStyle::drawControl(ControlElement element,
 				buttonContour->setState(Contour_DefaultButton);
 			
 			if(!flatMode) {
-				renderSurface(p, QRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.button(), surfaceFlags);
+				renderSurface(p, TQRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.button(), surfaceFlags);
 				
 				contourFlags |= Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight|Is_Button|Is_Horizontal;
  				renderContour(p, r, bg, cg.button(), contourFlags);
 				
 				if(isSunken) {
-					renderButtonShadow(p, QRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
+					renderButtonShadow(p, TQRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
 				}
 			}
 			else {
-				renderSurface(p, QRect(r.x()-3, r.y()-1, r.width()+6, r.height()+2), cg.background(), cg.button(), cg.button(), surfaceFlags);
+				renderSurface(p, TQRect(r.x()-3, r.y()-1, r.width()+6, r.height()+2), cg.background(), cg.button(), cg.button(), surfaceFlags);
 				
-				QColor contourColor = alphaBlendColors(buttonContour->contourColor(buttonContour->state), cg.background(), 179);
+				TQColor contourColor = alphaBlendColors(buttonContour->contourColor(buttonContour->state), cg.background(), 179);
 				p->setPen(contourColor);
 				if(dynamic_cast<KMultiTabBarTab*>(button)) {
 					
-					const QWidget* parent = button->parentWidget();
+					const TQWidget* parent = button->parentWidget();
 					bool horizontal = parent->width() >= parent->height();
 					
 					KMultiTabBar* tabBar = static_cast<KMultiTabBar*>(widget->parentWidget()->parentWidget()->parentWidget()->parentWidget());
 					
 					KMultiTabBarTab* tab;
-					QPtrList<KMultiTabBarTab>* list = tabBar->tabs();
+					TQPtrList<KMultiTabBarTab>* list = tabBar->tabs();
 					for(tab = list->first(); tab; tab = list->next()) {
 						if(horizontal && tab->x()+tab->width() == widget->x())
 							break;
@@ -5333,9 +5333,9 @@ void DominoStyle::drawControl(ControlElement element,
 					}
 					
 					if(tab) {
-						QPainter painter(tab);
+						TQPainter painter(tab);
 						painter.setPen(contourColor);
-						QRect re = tab->rect();
+						TQRect re = tab->rect();
 						if(horizontal)
 							painter.drawLine(re.right(), re.y(), re.right(), re.bottom()); // right lines
 						else
@@ -5358,7 +5358,7 @@ void DominoStyle::drawControl(ControlElement element,
 					
 // 					if(isSunken) {
 // 						contourFlags = Draw_Top|Draw_Left|Draw_Right|Draw_Bottom|Rectangular_UpperLeft|Rectangular_UpperRight|Rectangular_BottomLeft|Rectangular_BottomRight;
-// 						renderButtonShadow(p, QRect(r.x()-1, r.y()-1, r.width()+5, r.height()+2), contourFlags);
+// 						renderButtonShadow(p, TQRect(r.x()-1, r.y()-1, r.width()+5, r.height()+2), contourFlags);
 // 						renderButtonShadow(p, re), contourFlags);
 // 					}
 					
@@ -5380,7 +5380,7 @@ void DominoStyle::drawControl(ControlElement element,
 			int x, y, w, h;
 			r.rect( &x, &y, &w, &h );
 			
-			const QPushButton* button = static_cast<const QPushButton *>( widget );
+			const TQPushButton* button = static_cast<const TQPushButton *>( widget );
 			bool cornArrow = false;
 			bool hasFocus = button->hasFocus();
 
@@ -5391,13 +5391,13 @@ void DominoStyle::drawControl(ControlElement element,
 			{
 				int dx = pixelMetric( PM_MenuButtonIndicator, widget );
 				if ( button->iconSet() && !button->iconSet()->isNull()	&&
-					(dx + button->iconSet()->pixmap (QIconSet::Small, QIconSet::Normal, QIconSet::Off ).width()) >= w )
+					(dx + button->iconSet()->pixmap (TQIconSet::Small, TQIconSet::Normal, TQIconSet::Off ).width()) >= w )
 				{
 					cornArrow = true; //To little room. Draw the arrow in the corner, don't adjust the widget
 				}
 				else
 				{
-					drawPrimitive( PE_ArrowDown, p, visualRect( QRect(x + w - dx - 8, y + 3, dx, h - 3), r ), cg, flags, opt );
+					drawPrimitive( PE_ArrowDown, p, visualRect( TQRect(x + w - dx - 8, y + 3, dx, h - 3), r ), cg, flags, opt );
 					w -= dx;
 				}
 			}
@@ -5406,30 +5406,30 @@ void DominoStyle::drawControl(ControlElement element,
 			// Draw the icon if there is one
 			if ( button->iconSet() && !button->iconSet()->isNull() )
 			{
-				QIconSet::Mode	mode  = QIconSet::Disabled;
-				QIconSet::State state = QIconSet::Off;
+				TQIconSet::Mode	mode  = TQIconSet::Disabled;
+				TQIconSet::State state = TQIconSet::Off;
 				
 				if (button->isEnabled())
-					mode = button->hasFocus() ? QIconSet::Active : QIconSet::Normal;
+					mode = button->hasFocus() ? TQIconSet::Active : TQIconSet::Normal;
 				if (button->isToggleButton() && button->isOn())
-					state = QIconSet::On;
+					state = TQIconSet::On;
 				
-				QPixmap pixmap = button->iconSet()->pixmap( QIconSet::Small, mode, state );
+				TQPixmap pixmap = button->iconSet()->pixmap( TQIconSet::Small, mode, state );
 				bool focusIcon = hasFocus && focusIndicatorSettings.indicateFocus && !focusIndicatorSettings.drawUnderline;
 				int pw = pixmap.width();
 				
 				if(button->text().isEmpty()) {
 					int bpw = button->pixmap() ? button->pixmap()->width() : 0;
 					if(focusIcon) {
-						QPixmap outlinePixmap = renderOutlineIcon(&pixmap);
+						TQPixmap outlinePixmap = renderOutlineIcon(&pixmap);
 						p->drawPixmap( x + (w - bpw -outlinePixmap.width())/2, y + (h - outlinePixmap.height())/ 2, outlinePixmap );
 					}
 					p->drawPixmap( x + (w - bpw - pw)/2, y + (h- pixmap.height()) / 2, pixmap );
 				}
 				else {
-					int cw = p->fontMetrics().size(Qt::ShowPrefix, button->text()).width()+pw;
+					int cw = p->fontMetrics().size(TQt::ShowPrefix, button->text()).width()+pw;
 					if(focusIcon) {
-						QPixmap outlinePixmap = renderOutlineIcon(&pixmap);
+						TQPixmap outlinePixmap = renderOutlineIcon(&pixmap);
 						p->drawPixmap( x + (w - cw)/2 - 1 , y + (h - outlinePixmap.height())/ 2, outlinePixmap );
 					}
 					p->drawPixmap( x + (w - cw)/2 , y + (h - pixmap.height())/ 2, pixmap );
@@ -5437,25 +5437,25 @@ void DominoStyle::drawControl(ControlElement element,
 				}
 				
 				if (cornArrow) //Draw over the icon
-					drawPrimitive( PE_ArrowDown, p, visualRect( QRect(x + w - 6, x + h - 6, 7, 7), r ), cg, flags, opt );
+					drawPrimitive( PE_ArrowDown, p, visualRect( TQRect(x + w - 6, x + h - 6, 7, 7), r ), cg, flags, opt );
 				
 				x += pw + 4;
 				w -= pw + 4;
 			}
 			
-			QRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_PushButtonFocusRect, button) : QRect(x, y, w, h);
+			TQRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_PushButtonFocusRect, button) : TQRect(x, y, w, h);
 			
 			if(hasFocus && focusIndicatorSettings.indicateFocus && !button->text().isNull())
 				drawFocusIndicator(p, re, AlignCenter|ShowPrefix, cg, button->isEnabled(), 0, button->text(), -1, focusIndicatorSettings.buttonColor, focusIndicatorSettings.drawUnderline, true);
 			
-			QPixmap buttonPixmap;
+			TQPixmap buttonPixmap;
 			if(button->pixmap()) {
 				if(!enabled)
 					buttonPixmap = disableIcon(button->pixmap());
 				else
 					buttonPixmap = *button->pixmap();
 			}
-			dominoDrawItem( p, QRect(x, y, w, h), AlignCenter|ShowPrefix, button->colorGroup(),
+			dominoDrawItem( p, TQRect(x, y, w, h), AlignCenter|ShowPrefix, button->colorGroup(),
 					enabled, button->pixmap() ? &buttonPixmap : 0, button->text(), -1, &button->colorGroup().buttonText(), textEffectSettings.mode > 0 ? 1 : 0 );
 
 			break;
@@ -5465,18 +5465,18 @@ void DominoStyle::drawControl(ControlElement element,
 			
 			if ( opt.isDefault() )
 				break;
-			const QTabBar * tb = (const QTabBar *) widget;
-			QTab * t = opt.tab();
+			const TQTabBar * tb = (const TQTabBar *) widget;
+			TQTab * t = opt.tab();
 			bool konqTab = false;
 			bool kickoffTab = false;
 			int shift, cshift;
 			
 			switch (tb->shape()) {
-				case QTabBar::RoundedAbove:
+				case TQTabBar::RoundedAbove:
 					shift = 4;
 					cshift = 3;
 					break;
-				case QTabBar::RoundedBelow:
+				case TQTabBar::RoundedBelow:
 					if((konqTab = tb->parentWidget() && tb->parentWidget()->isA("KonqFrameTabs")) ||
 							(kickoffTab = tb->parentWidget() && !strcmp(tb->parentWidget()->name(), "SUSE::Kickoff::KMenu"))) {
 						shift = 0;
@@ -5487,11 +5487,11 @@ void DominoStyle::drawControl(ControlElement element,
 						cshift = -1;
 					}
 					break;
-				case QTabBar::TriangularAbove:
+				case TQTabBar::TriangularAbove:
 					shift = 4;
 					cshift = 3;
 					break;
-				case QTabBar::TriangularBelow:
+				case TQTabBar::TriangularBelow:
 					shift = -5;
 					cshift = -3;
 					break;
@@ -5500,7 +5500,7 @@ void DominoStyle::drawControl(ControlElement element,
 					cshift = 0;
 			}
 
-			QRect tr = r;
+			TQRect tr = r;
 			bool currentTab =  t->identifier() == tb->currentTab();
 			if (!currentTab)
 				tr.setTop( tr.top() +shift );
@@ -5510,38 +5510,38 @@ void DominoStyle::drawControl(ControlElement element,
 			int alignment = AlignCenter | ShowPrefix;
 			
 			if (flags& Style_HasFocus && focusIndicatorSettings.indicateFocus && !t->text().isEmpty())
-				drawFocusIndicator(p, QRect(tr.x(), tr.y(), tr.width(), tr.height()), alignment, cg, flags & Style_Enabled, 0, t->text(), -1, focusIndicatorSettings.buttonColor, focusIndicatorSettings.drawUnderline, true);
+				drawFocusIndicator(p, TQRect(tr.x(), tr.y(), tr.width(), tr.height()), alignment, cg, flags & Style_Enabled, 0, t->text(), -1, focusIndicatorSettings.buttonColor, focusIndicatorSettings.drawUnderline, true);
 			
 			if(t->iconSet() && !tb->isA("KickoffTabBar")) {
 				bool enabled = t->isEnabled() && tb->isEnabled();
-				QPixmap pixmap;
+				TQPixmap pixmap;
 				
 				if(!KApplicationMode) {
-					QIconSet::Mode mode = (t->identifier() && tb->keyboardFocusTab()) ? QIconSet::Active : QIconSet::Normal;
-					pixmap = t->iconSet()->pixmap( QIconSet::Small, mode );
+					TQIconSet::Mode mode = (t->identifier() && tb->keyboardFocusTab()) ? TQIconSet::Active : TQIconSet::Normal;
+					pixmap = t->iconSet()->pixmap( TQIconSet::Small, mode );
 					if(!enabled)
 						pixmap = disableIcon(&pixmap);
 				}
 				else {
-					QIconSet::Mode mode = enabled ? QIconSet::Normal : QIconSet::Disabled;
-					if ( mode == QIconSet::Normal && (t->identifier() && tb->keyboardFocusTab()) )
-						mode = QIconSet::Active;
-					pixmap = t->iconSet()->pixmap( QIconSet::Small, mode );
+					TQIconSet::Mode mode = enabled ? TQIconSet::Normal : TQIconSet::Disabled;
+					if ( mode == TQIconSet::Normal && (t->identifier() && tb->keyboardFocusTab()) )
+						mode = TQIconSet::Active;
+					pixmap = t->iconSet()->pixmap( TQIconSet::Small, mode );
 				}
 				
 				int pixw = pixmap.width();
 				int pixh = pixmap.height();
-				QRect ir = r;
+				TQRect ir = r;
 				ir.setLeft( tr.left() - pixw - 4 );
 				ir.setRight( tr.right() - 2 );
 				int yoff = 0;
 				if(!currentTab) {
-					yoff = pixelMetric(QStyle::PM_TabBarTabShiftVertical, tb);
+					yoff = pixelMetric(TQStyle::PM_TabBarTabShiftVertical, tb);
 				}
 				
 				switch(tb->shape()) {
-					case QTabBar::RoundedAbove:
-					case QTabBar::TriangularAbove:
+					case TQTabBar::RoundedAbove:
+					case TQTabBar::TriangularAbove:
 						ir.setHeight(ir.height()+4);
 						break;
 					default:
@@ -5552,7 +5552,7 @@ void DominoStyle::drawControl(ControlElement element,
 				p->drawPixmap( ir.left() + 2, ir.center().y()-pixh/2+ yoff, pixmap );
 			}
 			
-			QColor textColor = cg.foreground();
+			TQColor textColor = cg.foreground();
 			if(konqTab)
 				textColor = cg.foreground() != tb->palette().active().foreground() ? cg.foreground() : tb->palette().active().foreground();
 			else if(konsoleMode)
@@ -5573,13 +5573,13 @@ void DominoStyle::drawControl(ControlElement element,
 				if(!macStyleBar)
 					p->fillRect(r, cg.background()); // gtk-qt engine fix
 				
-				QColor c = down ? dGetColor(cg.background(), 15) : dGetColor(cg.background(), 25);
+				TQColor c = down ? dGetColor(cg.background(), 15) : dGetColor(cg.background(), 25);
 				
-				p->fillRect(QRect(r.left()+3,r.y()+1, r.width()-7, r.height()), c);
-				p->fillRect(QRect(r.left(),r.top()+4, 3, r.height()-7), c);
-				p->fillRect(QRect(r.right()-3, r.y()+4, 3, r.height()-7), c);
+				p->fillRect(TQRect(r.left()+3,r.y()+1, r.width()-7, r.height()), c);
+				p->fillRect(TQRect(r.left(),r.top()+4, 3, r.height()-7), c);
+				p->fillRect(TQRect(r.right()-3, r.y()+4, 3, r.height()-7), c);
 		
-				QPixmap pix = tintImage(qembed_findImage("menuItem"), c);
+				TQPixmap pix = tintImage(qembed_findImage("menuItem"), c);
 				p->drawPixmap(r.left(),r.y()+1, pix, 0, 0, 3, 3);
 				p->drawPixmap(r.left(),r.bottom()-2, pix, 0, 3, 3, 3);
 				p->drawPixmap(r.right()-3,r.y()+1, pix, 3, 0, 3, 3);
@@ -5596,8 +5596,8 @@ void DominoStyle::drawControl(ControlElement element,
 	// ------------------------------------------
 		case CE_PopupMenuItem: {
 			
-			const QPopupMenu *popupmenu = static_cast< const QPopupMenu * >( widget );
-			QMenuItem *mi = opt.menuItem();
+			const TQPopupMenu *popupmenu = static_cast< const TQPopupMenu * >( widget );
+			TQMenuItem *mi = opt.menuItem();
 			
 			if ( !mi )
 				break;
@@ -5610,17 +5610,17 @@ void DominoStyle::drawControl(ControlElement element,
 				maxpmw += cmwidth-1;
 			bool enabled = mi->isEnabled();
 			bool active = flags & Style_Active;
-			bool reverse = QApplication::reverseLayout();
+			bool reverse = TQApplication::reverseLayout();
 			bool separator = mi->isSeparator();
 			
 			
-			QColor color;
+			TQColor color;
 			if(separator || (active && enabled)) {
 				
 				color = separator ? dGetColor(_popupMenuColor, 20) : _selMenuItemColor;
 				float val = 0;
 				int ph = popupmenu->rect().height()/2;
-				int part = separator ? QMAX(1, ph/r.y()+r.height()) : QMAX(1, ph/r.height());
+				int part = separator ? TQMAX(1, ph/r.y()+r.height()) : TQMAX(1, ph/r.height());
 					
 				if(_drawPopupMenuGradient) {
 					if(r.y()+r.height()/2 < ph) {
@@ -5643,16 +5643,16 @@ void DominoStyle::drawControl(ControlElement element,
 			// Draw the menu item background
 			if (active) {
 				if (enabled) {
-					QColor c = color;
-					p->fillRect(QRect(r.x()+3, r.y(), r.width()-6, r.height()), c);
-					p->fillRect(QRect(r.x(), r.y()+3, 3, r.height()-6), c);
-					p->fillRect(QRect(r.x()+r.width()-3, r.y()+3, 3, r.height()-6), c);
+					TQColor c = color;
+					p->fillRect(TQRect(r.x()+3, r.y(), r.width()-6, r.height()), c);
+					p->fillRect(TQRect(r.x(), r.y()+3, 3, r.height()-6), c);
+					p->fillRect(TQRect(r.x()+r.width()-3, r.y()+3, 3, r.height()-6), c);
 					
-					QPixmap pix = tintImage(qembed_findImage("menuItem"), c);
-					bitBlt(p->device(), r.x(), r.y(), &pix, 0, 0, 3, 3, Qt::CopyROP);
-					bitBlt(p->device(), r.x(), r.bottom()-2, &pix, 0, 3, 3, 3, Qt::CopyROP);
-					bitBlt(p->device(), r.x()+r.width()-3, r.y(), &pix, 3, 0, 3, 3, Qt::CopyROP);
-					bitBlt(p->device(), r.x()+r.width()-3, r.bottom()-2, &pix, 3, 3, 3, 3, Qt::CopyROP);
+					TQPixmap pix = tintImage(qembed_findImage("menuItem"), c);
+					bitBlt(p->device(), r.x(), r.y(), &pix, 0, 0, 3, 3, TQt::CopyROP);
+					bitBlt(p->device(), r.x(), r.bottom()-2, &pix, 0, 3, 3, 3, TQt::CopyROP);
+					bitBlt(p->device(), r.x()+r.width()-3, r.y(), &pix, 3, 0, 3, 3, TQt::CopyROP);
+					bitBlt(p->device(), r.x()+r.width()-3, r.bottom()-2, &pix, 3, 3, 3, 3, TQt::CopyROP);
 					
 				}
 			}
@@ -5667,7 +5667,7 @@ void DominoStyle::drawControl(ControlElement element,
 			if(checked) {
 				// We only have to draw the background if the menu item is inactive -
 				// if it's active the "pressed" background is already drawn
-				QRect cmr = visualRect( QRect( r.x()+itemFrame , r.y() + 1, QMIN(QMAX(maxpmw, cmwidth), r.height() - 2), r.height() - 2 ), r );
+				TQRect cmr = visualRect( TQRect( r.x()+itemFrame , r.y() + 1, TQMIN(TQMAX(maxpmw, cmwidth), r.height() - 2), r.height() - 2 ), r );
 				
 				// Draw the checkmark
 				SFlags cflags = Style_On;
@@ -5675,30 +5675,30 @@ void DominoStyle::drawControl(ControlElement element,
 					cflags |= Style_Enabled;
 				
 				if(reverse && _indentPopupMenuItems)
-					drawPrimitive( PE_CheckMark, p, QRect(cmr.x() + (maxpmw ? (maxpmw-16)/2-4 : -1), cmr.y(), cmr.width(), cmr.height()), cg, cflags );
+					drawPrimitive( PE_CheckMark, p, TQRect(cmr.x() + (maxpmw ? (maxpmw-16)/2-4 : -1), cmr.y(), cmr.width(), cmr.height()), cg, cflags );
 				else if(_indentPopupMenuItems)
-					drawPrimitive( PE_CheckMark, p, QRect(cmr.x() + (maxpmw ? (maxpmw-16)/2-3 : -6), cmr.y(), cmr.width(), cmr.height()), cg, cflags );
+					drawPrimitive( PE_CheckMark, p, TQRect(cmr.x() + (maxpmw ? (maxpmw-16)/2-3 : -6), cmr.y(), cmr.width(), cmr.height()), cg, cflags );
 				else
-					drawPrimitive( PE_CheckMark, p, QRect(reverse ? cmr.x()+cmr.width()-15 : cmr.x()-3, cmr.y(), cmr.width(), cmr.height()), cg, cflags );
+					drawPrimitive( PE_CheckMark, p, TQRect(reverse ? cmr.x()+cmr.width()-15 : cmr.x()-3, cmr.y(), cmr.width(), cmr.height()), cg, cflags );
 				
 				
 				
 			}
 			if(!(_indentPopupMenuItems && checked) && mi->iconSet()) {
-				QRect cr = visualRect( QRect( (reverse ? r.x()-2 : r.x()) + itemFrame, r.y() + 1, maxpmw -1 , r.height() - 2 ), r );
-				QIconSet::Mode mode;
+				TQRect cr = visualRect( TQRect( (reverse ? r.x()-2 : r.x()) + itemFrame, r.y() + 1, maxpmw -1 , r.height() - 2 ), r );
+				TQIconSet::Mode mode;
 
 				// Select the correct icon from the iconset
-				QPixmap pixmap;
+				TQPixmap pixmap;
 				if(KApplicationMode) {
 					if (active)
-						mode = enabled ? QIconSet::Active : QIconSet::Disabled;
+						mode = enabled ? TQIconSet::Active : TQIconSet::Disabled;
 					else
-						mode = enabled ? QIconSet::Normal : QIconSet::Disabled;
-					pixmap = mi->iconSet()->pixmap(QIconSet::Small, mode);
+						mode = enabled ? TQIconSet::Normal : TQIconSet::Disabled;
+					pixmap = mi->iconSet()->pixmap(TQIconSet::Small, mode);
 				}
 				else {
-					pixmap = mi->iconSet()->pixmap(QIconSet::Small, active ? QIconSet::Active : QIconSet::Normal);
+					pixmap = mi->iconSet()->pixmap(TQIconSet::Small, active ? TQIconSet::Active : TQIconSet::Normal);
 					if(!enabled)
 						pixmap = disableIcon(&pixmap);
 				}
@@ -5727,7 +5727,7 @@ void DominoStyle::drawControl(ControlElement element,
 
 			// This color will be used instead of the above if the menu item
 			// is active and disabled at the same time. (etched text)
-			QColor discol = cg.mid();
+			TQColor discol = cg.mid();
 
 			// Does the menu item draw it's own label?
 			if(mi->custom()) {
@@ -5738,7 +5738,7 @@ void DominoStyle::drawControl(ControlElement element,
 			}
 			else {
 				// The menu item doesn't draw it's own label
-				QString s = mi->text();
+				TQString s = mi->text();
 				// Does the menu item have a text label?
 				if ( !s.isNull() ) {
 					int t = s.find( '\t' );
@@ -5746,7 +5746,7 @@ void DominoStyle::drawControl(ControlElement element,
 					int text_flags = AlignVCenter | ShowPrefix | DontClip | SingleLine;
 					text_flags |= reverse ? AlignRight : AlignLeft;
 
-					QColor draw = (active && enabled) ? cg.highlightedText() : cg.foreground();
+					TQColor draw = (active && enabled) ? cg.highlightedText() : cg.foreground();
 					p->setPen(draw);
 
 					// Does the menu item have a tabstop? (for the accelerator text)
@@ -5758,21 +5758,21 @@ void DominoStyle::drawControl(ControlElement element,
 
 						// Draw the right part of the label (accelerator text)
 						//p->drawText( tabx, r.y()+m, tab, r.height()-2*m, text_flags, s.mid( t+1 ) );
-						dominoDrawItem( p, QRect(tabx, r.y()+m, tab, r.height()-2*m), text_flags, cg, flags & Style_Enabled, 0, s.mid( t+1 ), -1, &draw);
+						dominoDrawItem( p, TQRect(tabx, r.y()+m, tab, r.height()-2*m), text_flags, cg, flags & Style_Enabled, 0, s.mid( t+1 ), -1, &draw);
 						s = s.left( t );
 					}
 
 					// Draw the left part of the label (or the whole label
 					// if there's no accelerator)
 					//p->drawText( xp, r.y()+m, tw, r.height()-2*m, text_flags, s, t );
-					dominoDrawItem( p, QRect(xp, r.y()+m, tw, r.height()-2*m), text_flags, cg, flags & Style_Enabled, 0, s, t, &draw);
+					dominoDrawItem( p, TQRect(xp, r.y()+m, tw, r.height()-2*m), text_flags, cg, flags & Style_Enabled, 0, s, t, &draw);
 					p->setPen(cg.text());
 				}
 
 				// The menu item doesn't have a text label
 				// Check if it has a pixmap instead
 				else if ( mi->pixmap() ) {
-					QPixmap *pixmap = mi->pixmap();
+					TQPixmap *pixmap = mi->pixmap();
 
 					// Draw the pixmap
 					if ( pixmap->depth() == 1 )
@@ -5792,7 +5792,7 @@ void DominoStyle::drawControl(ControlElement element,
 				PrimitiveElement arrow = reverse ? PE_ArrowLeft : PE_ArrowRight;
 				
 				int dim = pixelMetric(PM_MenuButtonIndicator) - 1;
-				QRect vr = visualRect( QRect( r.x() + r.width() - 5 - 1 - dim,
+				TQRect vr = visualRect( TQRect( r.x() + r.width() - 5 - 1 - dim,
 							r.y() + r.height() / 2 - dim / 2, dim, dim), r );
 
 				TextEffect textEffectMode_save = textEffectSettings.mode;
@@ -5813,22 +5813,22 @@ void DominoStyle::drawControl(ControlElement element,
 
 		case CE_ToolBoxTab: {
 			
-			bool selected= (flags & Style_Selected && ((QToolBox*)widget)->currentItem());
+			bool selected= (flags & Style_Selected && ((TQToolBox*)widget)->currentItem());
 			
-			QPixmap pix(widget->size());
-			QPainter painter(&pix);
+			TQPixmap pix(widget->size());
+			TQPainter painter(&pix);
 			
-			QColor background = (flags&Style_Down && !selected) ? darkenColor(cg.background(), 15) : cg.background();
+			TQColor background = (flags&Style_Down && !selected) ? darkenColor(cg.background(), 15) : cg.background();
 			
-			painter.fillRect(QRect(5, 0, r.width()-10, r.height()), background);
-			renderGradient(&painter, QRect(r.x(), r.y(), 5, r.height()), background.light(120), background, false);
-			renderGradient(&painter, QRect(r.width()-5, r.y(), 5, r.height()), background, background.light(115), false);
+			painter.fillRect(TQRect(5, 0, r.width()-10, r.height()), background);
+			renderGradient(&painter, TQRect(r.x(), r.y(), 5, r.height()), background.light(120), background, false);
+			renderGradient(&painter, TQRect(r.width()-5, r.y(), 5, r.height()), background, background.light(115), false);
 			painter.setPen(cg.background().dark(120));
 			painter.drawLine(r.x(), r.bottom(), r.width(), r.bottom());
 			painter.setPen((hoveredToolBoxTab && !selected) ? dGetColor(cg.background(), 95) : dGetColor(cg.background(), 45));
 			
 			PrimitiveElement arrow;
-			QRect re = QRect(r.x()+6,r.y(),r.x()+10,r.height());
+			TQRect re = TQRect(r.x()+6,r.y(),r.x()+10,r.height());
 			if(selected) {
 				arrow = PE_ArrowDown;
 				re.setY(re.y()+1);
@@ -5844,24 +5844,24 @@ void DominoStyle::drawControl(ControlElement element,
 		
 		case CE_HeaderLabel:
 		{
-			QRect rect = r;
-			const QHeader* header = (const QHeader *) widget;
+			TQRect rect = r;
+			const TQHeader* header = (const TQHeader *) widget;
 			int section = opt.headerSection();
 
-			QIconSet* icon = header->iconSet( section );
+			TQIconSet* icon = header->iconSet( section );
 			if ( icon ) {
-				QPixmap pixmap = icon->pixmap( QIconSet::Small,
+				TQPixmap pixmap = icon->pixmap( TQIconSet::Small,
 						flags & Style_Enabled ?
-								QIconSet::Normal : QIconSet::Disabled );
+								TQIconSet::Normal : TQIconSet::Disabled );
 				int pixw = pixmap.width();
 				int pixh = pixmap.height();
 				// "pixh - 1" because of tricky integer division
 
-				QRect pixRect = rect;
+				TQRect pixRect = rect;
 				pixRect.setY( rect.center().y() - (pixh - 1) / 2 );
 				drawItem ( p, pixRect, AlignVCenter, cg, flags & Style_Enabled,
-					   &pixmap, QString::null );
-				if (QApplication::reverseLayout())
+					   &pixmap, TQString::null );
+				if (TQApplication::reverseLayout())
 					rect.setRight(rect.right() - pixw - 2);
 				else
 					rect.setLeft(rect.left() + pixw + 2);
@@ -5878,10 +5878,10 @@ void DominoStyle::drawControl(ControlElement element,
 }
 
 void DominoStyle::drawControlMask(ControlElement element,
-								  QPainter *p,
-								  const QWidget *w,
-								  const QRect &r,
-								  const QStyleOption &opt) const
+								  TQPainter *p,
+								  const TQWidget *w,
+								  const TQRect &r,
+								  const TQStyleOption &opt) const
 {
 
 	switch (element) {
@@ -5904,16 +5904,16 @@ void DominoStyle::drawControlMask(ControlElement element,
 }
 
 void DominoStyle::drawComplexControl(ComplexControl control,
-									 QPainter *p,
-									 const QWidget *widget,
-									 const QRect &r,
-									 const QColorGroup &cg,
+									 TQPainter *p,
+									 const TQWidget *widget,
+									 const TQRect &r,
+									 const TQColorGroup &cg,
 									 SFlags flags,
 									 SCFlags controls,
 									 SCFlags active,
-									 const QStyleOption& opt) const
+									 const TQStyleOption& opt) const
 {
-	const bool reverseLayout = QApplication::reverseLayout();
+	const bool reverseLayout = TQApplication::reverseLayout();
 
 	const bool enabled = (flags & Style_Enabled);
 
@@ -5926,12 +5926,12 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 		case CC_ComboBox: {
 
 			static const unsigned int handleWidth = 15;
-			const QComboBox *cb = dynamic_cast<const QComboBox*>(widget);
+			const TQComboBox *cb = dynamic_cast<const TQComboBox*>(widget);
 			bool editable = cb && cb->editable();
 			bool isDown = cb && cb->listBox() && cb->listBox()->isVisible();
 			bool hasFocus =(flags&Style_HasFocus);
-			const QColor inputColor = enabled ? (editable ? cg.base() : cg.button()) : cg.background();
-			const QColor bg = (cb && cb->parentWidget()) ?  cb->parentWidget()->paletteBackgroundColor() : cg.background();
+			const TQColor inputColor = enabled ? (editable ? cg.base() : cg.button()) : cg.background();
+			const TQColor bg = (cb && cb->parentWidget()) ?  cb->parentWidget()->paletteBackgroundColor() : cg.background();
 			bool hasPixmap = cb && cb->count() > 0 && cb->pixmap(cb->currentItem());
 			uint contourFlags = 0;
 			bool isKhtmlWidget = khtmlWidgets.contains(cb);
@@ -5941,15 +5941,15 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				buttonContour->setAlphaMode();
 			}
 			else {
-				p->fillRect(QRect(r.x(), r.y(), 6, r.height()), bg);
-				p->fillRect(QRect(r.width()-6, r.y(), 6, r.height()), bg);
+				p->fillRect(TQRect(r.x(), r.y(), 6, r.height()), bg);
+				p->fillRect(TQRect(r.width()-6, r.y(), 6, r.height()), bg);
 			}
 			
 			if(hasPixmap && editable && r.width() > 40) {
 				int x = reverseLayout ? handleWidth+3 : 6;
-				QRegion mask(x, 0, 17, r.height());
+				TQRegion mask(x, 0, 17, r.height());
 				if(!reverseLayout)
-					mask += QRegion(x-2, 4, 2, r.height()-9);
+					mask += TQRegion(x-2, 4, 2, r.height()-9);
 				p->setClipRegion(mask);
 			}
 			
@@ -5960,7 +5960,7 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				surfaceFlags |= Is_Down;
 				contourFlags |= Is_Down;
 			}
-			renderSurface(p, QRect(r.left()+2, r.top()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.background(), surfaceFlags);
+			renderSurface(p, TQRect(r.left()+2, r.top()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.background(), surfaceFlags);
 			
 			if(isDown)
 				buttonContour->setState(Contour_Pressed);
@@ -5970,33 +5970,33 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 			
 			
 			if(editable) {
-				QColor lineEditColor = enabled ? cg.base() : cg.background();
-				QString isEnabled = enabled ? "1" : "0";
-				QPixmap* lineEditBtnEdges; // shared with spinwidget
-				if(!(lineEditBtnEdges = QPixmapCache::find(QString::number(cg.button().pixel(), 16)+QString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled))) { // + buttoncolor
+				TQColor lineEditColor = enabled ? cg.base() : cg.background();
+				TQString isEnabled = enabled ? "1" : "0";
+				TQPixmap* lineEditBtnEdges; // shared with spinwidget
+				if(!(lineEditBtnEdges = TQPixmapCache::find(TQString::number(cg.button().pixel(), 16)+TQString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled))) { // + buttoncolor
 					
 					// To not make the button contour appear thicker with dark button gradiens, we need a tad smaller rounding for the lineEdit edges.
-					QPixmap pixmap(1, r.height());
-					QPainter painter(&pixmap);
+					TQPixmap pixmap(1, r.height());
+					TQPainter painter(&pixmap);
 					flatMode = true;
-					renderSurface(&painter, QRect(0, 0, 1, r.height()), cg.background(), cg.button(), cg.background(), surfaceFlags);
+					renderSurface(&painter, TQRect(0, 0, 1, r.height()), cg.background(), cg.button(), cg.background(), surfaceFlags);
 					flatMode = false;
-					QImage img = pixmap.convertToImage();
+					TQImage img = pixmap.convertToImage();
 					
 					// Test, if we have a dark button. Not accurate, but...
-					QColor c1 = QColor(img.pixel(0, r.y()+4));
-					QColor c2 = QColor(img.pixel(0, r.height()-6));
+					TQColor c1 = TQColor(img.pixel(0, r.y()+4));
+					TQColor c2 = TQColor(img.pixel(0, r.height()-6));
 					int v, v1, v2;
 					c1.getHsv(&v, &v ,&v1);
 					c2.getHsv(&v, &v ,&v2);
-					QImage edges = tintImage(qembed_findImage( (v1+v2)/2 < 200 ? "lineEditBtnEdges-d" : "lineEditBtnEdges"), lineEditColor);
+					TQImage edges = tintImage(qembed_findImage( (v1+v2)/2 < 200 ? "lineEditBtnEdges-d" : "lineEditBtnEdges"), lineEditColor);
 					
 					if(enabled) {
-						QImage shadow = qembed_findImage("lineEditBtnShadow");
+						TQImage shadow = qembed_findImage("lineEditBtnShadow");
 						blend(shadow, edges, edges);
 					}
-					lineEditBtnEdges = new QPixmap(edges);
-					QPixmapCache::insert(QString::number(cg.button().pixel(), 16)+QString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled, lineEditBtnEdges);
+					lineEditBtnEdges = new TQPixmap(edges);
+					TQPixmapCache::insert(TQString::number(cg.button().pixel(), 16)+TQString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled, lineEditBtnEdges);
 				}
 				
 				if(reverseLayout) {
@@ -6010,9 +6010,9 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 			}
 			
 			
-			QRect ar(reverseLayout ? r.left()+3 : r.width()-handleWidth-1, r.height()/2-2, handleWidth, 6);
+			TQRect ar(reverseLayout ? r.left()+3 : r.width()-handleWidth-1, r.height()/2-2, handleWidth, 6);
 			if(hasFocus && focusIndicatorSettings.indicateFocus && enabled && cb) {
-				QRect editField = querySubControlMetrics(control, widget, SC_ComboBoxEditField);
+				TQRect editField = querySubControlMetrics(control, widget, SC_ComboBoxEditField);
 				int pw = hasPixmap ? (cb->pixmap(cb->currentItem()))->width()+2 : 0;
 				
 				if(!editable) {
@@ -6021,29 +6021,29 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 						editField.addCoords(pw+17, editField.height()/2-fmheight/2-1,0 , 0);
 					else
 						editField.addCoords(2+pw, editField.height()/2-fmheight/2-1,0 , 0);
-					QRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_ComboBoxFocusRect, cb) : editField;
+					TQRect re = focusIndicatorSettings.drawUnderline ? subRect(SR_ComboBoxFocusRect, cb) : editField;
 					drawFocusIndicator(p, re, AlignLeft, cg, true, 0, cb->currentText(), -1, focusIndicatorSettings.buttonColor, focusIndicatorSettings.drawUnderline, true);
 				}
 			}
 			
 			if(isDown) {
 				uint shadowFlags = Draw_Top|Draw_Right|Draw_Bottom|Draw_Left;
-				QRect sr;
+				TQRect sr;
 				if(editable) {
 					shadowFlags |= reverseLayout? Round_UpperLeft|Round_BottomLeft|Rectangular_UpperRight|Rectangular_BottomRight :
 							Rectangular_UpperLeft|Rectangular_BottomLeft|Round_UpperRight|Round_BottomRight;
-					sr = QRect(reverseLayout ? r.left()+2 : r.width()-handleWidth-3, r.y()+2, handleWidth+3, r.height()-3);
+					sr = TQRect(reverseLayout ? r.left()+2 : r.width()-handleWidth-3, r.y()+2, handleWidth+3, r.height()-3);
 				}
 				else {
 					shadowFlags |= Round_UpperLeft|Round_BottomLeft|Round_UpperRight|Round_BottomRight;
-					sr = QRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3);
+					sr = TQRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3);
 				}
 				
 				renderButtonShadow(p, sr, shadowFlags);
 			}
 			buttonContour->reset();
 			
-			p->setPen(cb ? cb->palette().active().buttonText() : qApp->palette().active().buttonText());
+			p->setPen(cb ? cb->palette().active().buttonText() : tqApp->palette().active().buttonText());
 			uint aflags = Style_Default|Style_Raised;
 			if(enabled)
 				aflags |= Style_Enabled;
@@ -6057,23 +6057,23 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 	// ----------
 		case CC_ToolButton: {
 			
-			QToolButton *tb = (QToolButton *) widget;
+			TQToolButton *tb = (TQToolButton *) widget;
 			
-			if(_toolBtnAsBtn && ::qt_cast<KToolBarButton*>(tb)) {
+			if(_toolBtnAsBtn && ::tqt_cast<KToolBarButton*>(tb)) {
 				
-				const bool reverse = QApplication::reverseLayout();
+				const bool reverse = TQApplication::reverseLayout();
 				KToolBar *bar = dynamic_cast<KToolBar*>(tb->parentWidget());
 				if(!bar) break;
-				KToolBarButton* btn = ::qt_cast<KToolBarButton*>(tb);
+				KToolBarButton* btn = ::tqt_cast<KToolBarButton*>(tb);
 				KToolBarButton* prevBtn = 0;
 				KToolBarButton* nextBtn = 0;
 				bool prevBtnIsOn = false;
 				bool nextBtnIsOn = false;
 				bool isOn = flags &Style_On || flags &Style_Down;
 				bool isDown = flags &Style_Down;
-				const bool horizontal = bar->orientation() == Qt::Horizontal;
+				const bool horizontal = bar->orientation() == TQt::Horizontal;
 				
-				QRect cr = r , sr = r, bsr = r;
+				TQRect cr = r , sr = r, bsr = r;
 				int index = bar->itemIndex(btn->id());
 				
 				if(bar->getButton(bar->idAt(index-1))) {
@@ -6109,15 +6109,15 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 					contourFlags |= Is_Down;
 				}
 				
-				QPixmap buffer(btn->size());
-				QPainter painter(&buffer);
+				TQPixmap buffer(btn->size());
+				TQPainter painter(&buffer);
 				
 				if(tb->parentWidget() && tb->parentWidget()->paletteBackgroundPixmap()) {
 					painter.drawTiledPixmap(0, 0,  tb->width(), tb->height(), *tb->parentWidget()->paletteBackgroundPixmap(), tb->geometry().x(), tb->geometry().y());
 					contourFlags |= Draw_AlphaBlend;
 				}
 				else
-					painter.fillRect(buffer.rect(), cg.brush(QColorGroup::Background));
+					painter.fillRect(buffer.rect(), cg.brush(TQColorGroup::Background));
 
 				
 				if(prevBtn) {
@@ -6220,45 +6220,45 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				/////////////////////////////////////////// drop down indicator
 				
 				if(tb->popup()) {
-					QString isEnabled = enabled ? "1" : "0";
-					QPixmap* arrow;
-					QColor color = btn->palette().active().buttonText();
-					if(!(arrow = QPixmapCache::find(QString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
-						QImage ar = tintImage(qembed_findImage("arrow_down"), color);
+					TQString isEnabled = enabled ? "1" : "0";
+					TQPixmap* arrow;
+					TQColor color = btn->palette().active().buttonText();
+					if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
+						TQImage ar = tintImage(qembed_findImage("arrow_down"), color);
 						if(!isEnabled) {
 							ar = setImageOpacity(ar, 25);
 						}
-						arrow = new QPixmap(ar);
-						QPixmapCache::insert(QString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
+						arrow = new TQPixmap(ar);
+						TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
 					}
 					
-					QPoint point;
+					TQPoint point;
 					if(prevBtn)
 						if(nextBtn)
 							if(horizontal)
-								point = QPoint(cr.width()-19, cr.bottom()-8);
+								point = TQPoint(cr.width()-19, cr.bottom()-8);
 							else
-								point = QPoint(cr.width()-8, cr.bottom()-12);
+								point = TQPoint(cr.width()-8, cr.bottom()-12);
 						else
 							if(!horizontal)
-								point = QPoint(cr.width()-8, cr.bottom()-8);
+								point = TQPoint(cr.width()-8, cr.bottom()-8);
 							else if(!reverse)
-								point = QPoint(cr.width()-15, cr.bottom()-8);
+								point = TQPoint(cr.width()-15, cr.bottom()-8);
 							else // reverse
-								point = QPoint(cr.width()-13, cr.bottom()-8);
+								point = TQPoint(cr.width()-13, cr.bottom()-8);
 					else
 						if(nextBtn)
 							if(!horizontal)
-								point = QPoint(cr.width()-8, cr.bottom()-12);
+								point = TQPoint(cr.width()-8, cr.bottom()-12);
 							else if(!reverse)
-								point = QPoint(cr.width()-13, cr.bottom()-8);
+								point = TQPoint(cr.width()-13, cr.bottom()-8);
 							else //reverse
-								point = QPoint(cr.width()-15, cr.bottom()-8);
+								point = TQPoint(cr.width()-15, cr.bottom()-8);
 						else
 							if(horizontal)
-								point = QPoint(cr.width()-9, cr.bottom()-8);
+								point = TQPoint(cr.width()-9, cr.bottom()-8);
 							else
-								point = QPoint(cr.width()-8, cr.bottom()-8);
+								point = TQPoint(cr.width()-8, cr.bottom()-8);
 							
 					bitBlt(&buffer, point.x(), point.y(), arrow);
 					
@@ -6387,24 +6387,24 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				if(kickerMode && !(flags&(Style_Raised)))
 					break;
 				
-				const QRect br = querySubControlMetrics(control, widget, SC_ToolButton, opt);
+				const TQRect br = querySubControlMetrics(control, widget, SC_ToolButton, opt);
 				if(br.width() < 16 || br.height()< 16)
 					break;
 				
-				QColorGroup g = widget->colorGroup();
-				QColor bg;
+				TQColorGroup g = widget->colorGroup();
+				TQColor bg;
 				if(widget->parentWidget() && widget->paletteBackgroundColor() != widget->parentWidget()->paletteBackgroundColor()) {
 					bg = widget->parentWidget()->paletteBackgroundColor();
-					g.setColor(QColorGroup::Background, bg);
+					g.setColor(TQColorGroup::Background, bg);
 				}
 				else
 					bg = widget->paletteBackgroundColor();
 				
 				if(!widget->paletteBackgroundPixmap()) {
-					p->fillRect(QRect(br.x(), br.y(), 6, 6), bg);
-					p->fillRect(QRect(br.width()-6, br.y(), 6, 6), bg);
-					p->fillRect(QRect(br.width()-6, br.height()-7, 6, 7), bg);
-					p->fillRect(QRect(br.x(), br.height()-7, 6, 7), bg);
+					p->fillRect(TQRect(br.x(), br.y(), 6, 6), bg);
+					p->fillRect(TQRect(br.width()-6, br.y(), 6, 6), bg);
+					p->fillRect(TQRect(br.width()-6, br.height()-7, 6, 7), bg);
+					p->fillRect(TQRect(br.x(), br.height()-7, 6, 7), bg);
 				}
 				else {
 					buttonContour->setAlphaMode();
@@ -6422,16 +6422,16 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				
 				
 				if(tb->popup()) {
-					QString isEnabled = enabled ? "1" : "0";
-					QPixmap* arrow;
-					QColor color = tb->palette().active().buttonText();
-					if(!(arrow = QPixmapCache::find(QString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
-						QImage ar = tintImage(qembed_findImage("arrow_down"), color);
+					TQString isEnabled = enabled ? "1" : "0";
+					TQPixmap* arrow;
+					TQColor color = tb->palette().active().buttonText();
+					if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
+						TQImage ar = tintImage(qembed_findImage("arrow_down"), color);
 						if(!isEnabled) {
 							ar = setImageOpacity(ar, 25);
 						}
-						arrow = new QPixmap(ar);
-						QPixmapCache::insert(QString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
+						arrow = new TQPixmap(ar);
+						TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
 					}
 					bitBlt(p->device(), r.width()-8, r.bottom()-8, arrow);
 				}
@@ -6439,11 +6439,11 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 			}
 			else {
 				
-				bool isKbtn = ::qt_cast<KToolBarButton*>(tb);
-				QPixmap buffer(tb->size());
-				QPainter painter(&buffer);
+				bool isKbtn = ::tqt_cast<KToolBarButton*>(tb);
+				TQPixmap buffer(tb->size());
+				TQPainter painter(&buffer);
 				
-				QColor bg = cg.background();
+				TQColor bg = cg.background();
 				
 				if(tb->parentWidget() && tb->parentWidget()->paletteBackgroundPixmap()) {
 					painter.drawTiledPixmap(0, 0,  tb->width(), tb->height(), *tb->parentWidget()->paletteBackgroundPixmap(), tb->geometry().x(), tb->geometry().y());
@@ -6453,14 +6453,14 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 					painter.fillRect(buffer.rect(), bg);
 				}
 				else
-					painter.fillRect(buffer.rect(), cg.brush(QColorGroup::Background));
+					painter.fillRect(buffer.rect(), cg.brush(TQColorGroup::Background));
 				
 				
-				QRect fr = QRect(1, 1, r.width()-2, r.height()-2);
+				TQRect fr = TQRect(1, 1, r.width()-2, r.height()-2);
 				bool isOn = flags &Style_On;
 				if(isOn) {
-					QRegion reg(fr.x()+2, fr.y()+1, fr.width()-4, fr.height()-2);
-					reg += QRegion(fr.x()+1, fr.y()+2, fr.width()-2, fr.height()-4);
+					TQRegion reg(fr.x()+2, fr.y()+1, fr.width()-4, fr.height()-2);
+					reg += TQRegion(fr.x()+1, fr.y()+2, fr.width()-2, fr.height()-4);
 					painter.setClipRegion(reg);
 					painter.fillRect(r, alphaBlendColors(black, bg, 15));
 					painter.setClipping(false);
@@ -6469,11 +6469,11 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 					drawControl(CE_ToolButtonLabel, &painter, widget, r, cg, flags,opt);
 				
 				if(isOn) {
-					QColor color = buttonContour->contourColor(Contour_Default);
-					QPixmap* frame;
-					if(!(frame = QPixmapCache::find(QString::number(color.pixel(), 16)+"toolBtnFrameThin"))) {
-						frame = new QPixmap(tintImage(qembed_findImage("toolBtnFrameThin"), color));
-						QPixmapCache::insert(QString::number(color.pixel(), 16)+"toolBtnFrameThin", frame);
+					TQColor color = buttonContour->contourColor(Contour_Default);
+					TQPixmap* frame;
+					if(!(frame = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"toolBtnFrameThin"))) {
+						frame = new TQPixmap(tintImage(qembed_findImage("toolBtnFrameThin"), color));
+						TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"toolBtnFrameThin", frame);
 					}
 					
 					bitBlt(&buffer, fr.x(), fr.y(), frame, 0, 0, 4, 4);
@@ -6489,16 +6489,16 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				}
 				
 				if(tb->popup() && (!tb->iconSet().isNull() || tb->text() || tb->pixmap())) {
-					QString isEnabled = enabled ? "1" : "0";
-					QPixmap* arrow;
-					QColor color = tb->palette().active().buttonText();
-					if(!(arrow = QPixmapCache::find(QString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
-						QImage ar = tintImage(qembed_findImage("arrow_down"), color);
+					TQString isEnabled = enabled ? "1" : "0";
+					TQPixmap* arrow;
+					TQColor color = tb->palette().active().buttonText();
+					if(!(arrow = TQPixmapCache::find(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled))) {
+						TQImage ar = tintImage(qembed_findImage("arrow_down"), color);
 						if(!isEnabled) {
 							ar = setImageOpacity(ar, 25);
 						}
-						arrow = new QPixmap(ar);
-						QPixmapCache::insert(QString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
+						arrow = new TQPixmap(ar);
+						TQPixmapCache::insert(TQString::number(color.pixel(), 16)+"arrow_down"+isEnabled, arrow);
 					}
 					bitBlt(&buffer, r.width()-8, r.bottom()-4, arrow);
 				}
@@ -6525,20 +6525,20 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				break;
 			
 			static const unsigned int handleWidth = 15;
-			const QSpinWidget *sw = dynamic_cast<const QSpinWidget *>(widget);
-			const QColor bg = cg.background();
+			const TQSpinWidget *sw = dynamic_cast<const TQSpinWidget *>(widget);
+			const TQColor bg = cg.background();
 			SFlags sflags = flags;
 			PrimitiveElement pe;
 			bool enabled = sw && sw->isEnabled();
-			const QColor buttonColor = enabled ? cg.button() : cg.background();
+			const TQColor buttonColor = enabled ? cg.button() : cg.background();
 			
 			uint contourFlags = Round_UpperLeft|Round_BottomLeft|Round_UpperRight|Round_BottomRight|Draw_Right|Draw_Top|
 					Draw_Bottom|Draw_Left|Is_Button|Is_Horizontal;
 			
 			// fill edges
 			if(sw && !sw->paletteBackgroundPixmap()) {
-				p->fillRect(QRect(r.x(), r.y(), 6, r.height()), bg);
-				p->fillRect(QRect(r.width()-6, r.y(), 6, r.height()), bg);
+				p->fillRect(TQRect(r.x(), r.y(), 6, r.height()), bg);
+				p->fillRect(TQRect(r.width()-6, r.y(), 6, r.height()), bg);
 			}
 			else {
 				contourFlags |= Draw_AlphaBlend;
@@ -6550,7 +6550,7 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				surfaceFlags |= Is_Down;
 				contourFlags |= Is_Down;
 			}
-			renderSurface(p, QRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.button(), surfaceFlags);
+			renderSurface(p, TQRect(r.x()+2, r.y()+2, r.width()-4, r.height()-5), cg.background(), cg.button(), cg.button(), surfaceFlags);
 			
 			if(flags & Style_Down)
 				buttonContour->setState(Contour_Pressed);
@@ -6559,41 +6559,41 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 			renderContour(p, r, cg.background(), cg.button(), contourFlags);
 			
 			if(flags & Style_Down)
-				renderButtonShadow(p, QRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
+				renderButtonShadow(p, TQRect(r.x()+2, r.y()+2, r.width()-2, r.height()-3), contourFlags);
 			buttonContour->reset();
 			
 			
-// 			QColor lineEditColor = enabled ? cg.base() : cg.background();
-			QColor lineEditColor = enabled ? cg.base() : dynamic_cast<QSpinBox*>(sw->parentWidget()) ?
-					((DominoQSpinBox*)sw->parentWidget())->editor()->palette().active().background(): qApp->palette().active().background();
-			QString isEnabled = enabled ? "1" : "0";
-			QPixmap* lineEditBtnEdges;
+// 			TQColor lineEditColor = enabled ? cg.base() : cg.background();
+			TQColor lineEditColor = enabled ? cg.base() : dynamic_cast<TQSpinBox*>(sw->parentWidget()) ?
+					((DominoTQSpinBox*)sw->parentWidget())->editor()->palette().active().background(): tqApp->palette().active().background();
+			TQString isEnabled = enabled ? "1" : "0";
+			TQPixmap* lineEditBtnEdges;
 			
-			if(!(lineEditBtnEdges = QPixmapCache::find(QString::number(cg.button().pixel(), 16)+QString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled))) {
+			if(!(lineEditBtnEdges = TQPixmapCache::find(TQString::number(cg.button().pixel(), 16)+TQString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled))) {
 				
 				// To not make the button contour appear thicker with dark button gradiens, we need a tad smaller rounding for the lineEdit edges.
-				QPixmap pixmap(1, r.height());
-				QPainter painter(&pixmap);
+				TQPixmap pixmap(1, r.height());
+				TQPainter painter(&pixmap);
 				flatMode = true;
-				renderSurface(&painter, QRect(0, 0, 1, r.height()), cg.background(), cg.button(), cg.button(), surfaceFlags);
+				renderSurface(&painter, TQRect(0, 0, 1, r.height()), cg.background(), cg.button(), cg.button(), surfaceFlags);
 				flatMode = false;
-				QImage img = pixmap.convertToImage();
+				TQImage img = pixmap.convertToImage();
 				
 				// Test, if we have a dark button. Not accurate, but...
-				QColor c1 = QColor(img.pixel(0, r.y()+4));
-				QColor c2 = QColor(img.pixel(0, r.height()-6));
+				TQColor c1 = TQColor(img.pixel(0, r.y()+4));
+				TQColor c2 = TQColor(img.pixel(0, r.height()-6));
 				int v, v1, v2;
 				c1.getHsv(&v, &v ,&v1);
 				c2.getHsv(&v, &v ,&v2);
 				
-				QImage edges = tintImage(qembed_findImage( (v1+v2)/2 < 127 ? "lineEditBtnEdges-d" : "lineEditBtnEdges"), lineEditColor);
+				TQImage edges = tintImage(qembed_findImage( (v1+v2)/2 < 127 ? "lineEditBtnEdges-d" : "lineEditBtnEdges"), lineEditColor);
 				
 				if(enabled) {
-					QImage shadow = qembed_findImage("lineEditBtnShadow");
+					TQImage shadow = qembed_findImage("lineEditBtnShadow");
 					blend(shadow, edges, edges);
 				}
-				lineEditBtnEdges = new QPixmap(edges);
-				QPixmapCache::insert(QString::number(cg.button().pixel(), 16)+QString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled, lineEditBtnEdges);
+				lineEditBtnEdges = new TQPixmap(edges);
+				TQPixmapCache::insert(TQString::number(cg.button().pixel(), 16)+TQString::number(lineEditColor.pixel(), 16)+"lineEditBtnEdges"+isEnabled, lineEditBtnEdges);
 			}
 			
 			if(reverseLayout) {
@@ -6606,11 +6606,11 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 			}
 			
 			
-			QRect upRect = QRect(reverseLayout ? r.left()+2 : r.right()-handleWidth-1, r.height()/2-7, handleWidth, 6);
-			QRect downRect = QRect(reverseLayout ? r.left()+2 : r.right()-handleWidth-1, r.height()/2+1, handleWidth, 6);
+			TQRect upRect = TQRect(reverseLayout ? r.left()+2 : r.right()-handleWidth-1, r.height()/2-7, handleWidth, 6);
+			TQRect downRect = TQRect(reverseLayout ? r.left()+2 : r.right()-handleWidth-1, r.height()/2+1, handleWidth, 6);
 			// icons...
 			//p->setPen(cg.foreground());
-			p->setPen(sw ? sw->palette().active().buttonText() : qApp->palette().active().buttonText());
+			p->setPen(sw ? sw->palette().active().buttonText() : tqApp->palette().active().buttonText());
 			
 			sflags = Style_Default;
 			if(enabled)
@@ -6621,7 +6621,7 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 			} else
 				sflags |= Style_Raised;
 				
-			if (sw->buttonSymbols() == QSpinWidget::PlusMinus) {
+			if (sw->buttonSymbols() == TQSpinWidget::PlusMinus) {
 				pe = PE_SpinWidgetPlus;
 				upRect.moveTop(upRect.y()+1);
 			}
@@ -6637,7 +6637,7 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 				sflags |= Style_Sunken;
 			} else
 				sflags |= Style_Raised;
-			if (sw->buttonSymbols() == QSpinWidget::PlusMinus)
+			if (sw->buttonSymbols() == TQSpinWidget::PlusMinus)
 				pe = PE_SpinWidgetMinus;
 			else
 				pe = PE_SpinWidgetDown;
@@ -6648,13 +6648,13 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 
 		case CC_ScrollBar: { // TODO: find a way to draw pressed buttons
 			
-			const QScrollBar *sb = (const QScrollBar*)widget;
+			const TQScrollBar *sb = (const TQScrollBar*)widget;
 			bool   maxedOut   = (sb->minValue()    == sb->maxValue());
-			bool   horizontal = (sb->orientation() == Qt::Horizontal);
+			bool   horizontal = (sb->orientation() == TQt::Horizontal);
 			SFlags sflags     = ((horizontal ? Style_Horizontal : Style_Default) |
 					(maxedOut   ? Style_Default : Style_Enabled));
 
-			QRect  addline, subline, subline2, addpage, subpage, slider, first, last;
+			TQRect  addline, subline, subline2, addpage, subpage, slider, first, last;
 			subline = querySubControlMetrics(control, widget, SC_ScrollBarSubLine, opt);
 			addline = querySubControlMetrics(control, widget, SC_ScrollBarAddLine, opt);
 			subpage = querySubControlMetrics(control, widget, SC_ScrollBarSubPage, opt);
@@ -6683,7 +6683,7 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 					subline2.moveBy(0, -addline.height());
 				
 				if (subline2.isValid())
-					drawPrimitive((QStyle::PrimitiveElement)PE_ScrollBarSubLine2, p, subline2, cg,
+					drawPrimitive((TQStyle::PrimitiveElement)PE_ScrollBarSubLine2, p, subline2, cg,
 						sflags | (active == SC_ScrollBarSubLine ?
 								Style_Down : Style_Default));
 			}
@@ -6725,16 +6725,16 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 		
 		case CC_TitleBar: {
 			
-			QRect ir;
+			TQRect ir;
 			bool down;
-			QColorGroup g = widget->colorGroup();
+			TQColorGroup g = widget->colorGroup();
 			
 			if ( controls & SC_TitleBarLabel ) {
-				QPixmap pix(10, r.height());
+				TQPixmap pix(10, r.height());
 				pix.fill(g.background());
 				
-				QPainter painter(&pix);
-				renderGradient(&painter, QRect(0, 0, 10, r.height()/2), g.background().light(120), g.background(), true);
+				TQPainter painter(&pix);
+				renderGradient(&painter, TQRect(0, 0, 10, r.height()/2), g.background().light(120), g.background(), true);
 				painter.setPen(g.background().dark(105));
 				painter.drawLine(0, r.bottom(), 10, r.bottom());
 				p->drawTiledPixmap(0,0, r.width(), r.height(), pix);
@@ -6766,7 +6766,7 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 			if ( controls & SC_TitleBarSysMenu ) {
 				if ( widget->icon() ) {
 					ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarSysMenu ), widget );
-					drawItem( p, ir, AlignCenter, widget->colorGroup(), TRUE, widget->icon(), QString::null );
+					drawItem( p, ir, AlignCenter, widget->colorGroup(), TRUE, widget->icon(), TQString::null );
 				}
 			}
 			
@@ -6780,20 +6780,20 @@ void DominoStyle::drawComplexControl(ComplexControl control,
 	}
 }
 
-QRect DominoStyle::subRect(SubRect r, const QWidget *widget) const
+TQRect DominoStyle::subRect(SubRect r, const TQWidget *widget) const
 {
 	switch (r) {
 		case SR_PushButtonContents: {
-			const QPushButton* btn = static_cast<const QPushButton*>(widget);
-			QRect rw = widget->rect();
+			const TQPushButton* btn = static_cast<const TQPushButton*>(widget);
+			TQRect rw = widget->rect();
 			if(btn->text().isEmpty())
-				return QRect(rw.left()+2, rw.top()+2, rw.width()-4, rw.height()-4);
-			return QRect(rw.left()+2, rw.top()+3, rw.width()-4, rw.height()-7);
+				return TQRect(rw.left()+2, rw.top()+2, rw.width()-4, rw.height()-4);
+			return TQRect(rw.left()+2, rw.top()+3, rw.width()-4, rw.height()-7);
 		}
 		case SR_PushButtonFocusRect:
 		{
-			QRect rect, wrect(widget->rect());
-			const QPushButton *button = (const QPushButton *) widget;
+			TQRect rect, wrect(widget->rect());
+			const TQPushButton *button = (const TQPushButton *) widget;
 			int dbw1 = 0, dbw2 = 0;
 			if (button->isDefault() || button->autoDefault()) {
 				dbw1 = pixelMetric(PM_ButtonDefaultIndicator, widget);
@@ -6810,13 +6810,13 @@ QRect DominoStyle::subRect(SubRect r, const QWidget *widget) const
 			return rect;
 		}
 		case SR_ComboBoxFocusRect: {
-			return QRect(4, 3, widget->width()-8, widget->height()-7);
+			return TQRect(4, 3, widget->width()-8, widget->height()-7);
 // 			return querySubControlMetrics( CC_ComboBox, widget, SC_ComboBoxEditField );
 		}
 		case SR_CheckBoxFocusRect:
 		{
-			QRect cr = subRect(SR_CheckBoxContents, widget);
-	    		QRect fr = KStyle::subRect(r, widget);
+			TQRect cr = subRect(SR_CheckBoxContents, widget);
+	    		TQRect fr = KStyle::subRect(r, widget);
 			if(cr.width() <= 0) // no text
 				fr.setHeight(fr.height()+2);
 			else
@@ -6825,8 +6825,8 @@ QRect DominoStyle::subRect(SubRect r, const QWidget *widget) const
 		}
 		case SR_RadioButtonFocusRect:
 		{
-			QRect cr = subRect(SR_CheckBoxContents, widget);
-			QRect fr = KStyle::subRect(r, widget);
+			TQRect cr = subRect(SR_CheckBoxContents, widget);
+			TQRect fr = KStyle::subRect(r, widget);
 			if(cr.width() <= 0) // no text
 				fr.setHeight(fr.height()+2);
 			else
@@ -6834,16 +6834,16 @@ QRect DominoStyle::subRect(SubRect r, const QWidget *widget) const
 			return fr;
 		}
 		case SR_ProgressBarGroove: {
-			return QRect(widget->rect());
+			return TQRect(widget->rect());
 		}
 		case SR_ProgressBarContents:
 		case SR_ProgressBarLabel: {
-			QRect rw = widget->rect();
-			return QRect(rw.left()+2, rw.top()+2, rw.width()-4, rw.height()-4 );
+			TQRect rw = widget->rect();
+			return TQRect(rw.left()+2, rw.top()+2, rw.width()-4, rw.height()-4 );
 		}
 		case SR_ToolBoxTabContents: {
-			QRect rw = widget->rect();
-			return QRect(rw.left()+18, rw.top(), rw.width()-18, rw.height());
+			TQRect rw = widget->rect();
+			return TQRect(rw.left()+18, rw.top(), rw.width()-18, rw.height());
 		}
 		default: {
 			return KStyle::subRect(r, widget);
@@ -6853,27 +6853,27 @@ QRect DominoStyle::subRect(SubRect r, const QWidget *widget) const
 
 
 
-QRect DominoStyle::querySubControlMetrics(ComplexControl control,
-										  const QWidget *widget,
+TQRect DominoStyle::querySubControlMetrics(ComplexControl control,
+										  const TQWidget *widget,
 										  SubControl subcontrol,
-										  const QStyleOption &opt) const
+										  const TQStyleOption &opt) const
 {
 	if (!widget) {
-		return QRect();
+		return TQRect();
 	}
 
-	QRect r(widget->rect());
+	TQRect r(widget->rect());
 	switch (control) {
 		case CC_ComboBox: {
 			switch (subcontrol) {
 				case SC_ComboBoxEditField: {
-					const QComboBox* cb = dynamic_cast<const QComboBox *>(widget);
+					const TQComboBox* cb = dynamic_cast<const TQComboBox *>(widget);
 					if(!cb) // maybe kdevelop's KComboView
-						return QRect(r.left()+4, r.top()+3, r.width()-4-15-3, r.height()-7);
+						return TQRect(r.left()+4, r.top()+3, r.width()-4-15-3, r.height()-7);
 					if(!cb->editable())
-						return QRect(r.left()+3, r.top()+3, r.width()-4-15-2, r.height()-6);
+						return TQRect(r.left()+3, r.top()+3, r.width()-4-15-2, r.height()-6);
 					
-					return QRect(r.left()+3, r.top()+3, r.width()-4-15-2, r.height()-7);
+					return TQRect(r.left()+3, r.top()+3, r.width()-4-15-2, r.height()-7);
 				}
 				default: {
 					return KStyle::querySubControlMetrics(control, widget, subcontrol, opt);
@@ -6889,23 +6889,23 @@ QRect DominoStyle::querySubControlMetrics(ComplexControl control,
 			const int buttonsLeft = r.right()-buttonsWidth+1-fw;
 			switch (subcontrol) {
 				case SC_SpinWidgetUp: { // rect without 2px frame
-					return QRect(buttonsLeft, r.top()+3, buttonsWidth+1, r.height()/2-3 );
+					return TQRect(buttonsLeft, r.top()+3, buttonsWidth+1, r.height()/2-3 );
 				}
 				case SC_SpinWidgetDown: {
 					if(heightDividable) {
-						return QRect(buttonsLeft, r.top()+r.height()/2+1, buttonsWidth+1, r.height()/2-3);
+						return TQRect(buttonsLeft, r.top()+r.height()/2+1, buttonsWidth+1, r.height()/2-3);
 					} else {
-						return QRect(buttonsLeft, r.top()+r.height()/2+1, buttonsWidth+1, r.height()/2-2);
+						return TQRect(buttonsLeft, r.top()+r.height()/2+1, buttonsWidth+1, r.height()/2-2);
 					}
 				}
 				case SC_SpinWidgetFrame: {
-					return QRect(r.left(), r.top(), r.width(), r.height() );
+					return TQRect(r.left(), r.top(), r.width(), r.height() );
 				}
 				case SC_SpinWidgetEditField: {
-					return QRect(r.left()+1+fw, r.top()+1+fw, r.width()-(buttonsWidth+2+fw*2), r.height()-3-fw*2);
+					return TQRect(r.left()+1+fw, r.top()+1+fw, r.width()-(buttonsWidth+2+fw*2), r.height()-3-fw*2);
 				}
 				case SC_SpinWidgetButtonField: {
-					return QRect(buttonsLeft, r.top()+2, buttonsWidth, r.height()-5);
+					return TQRect(buttonsLeft, r.top()+2, buttonsWidth, r.height()-5);
 				}
 				default: {
 					return KStyle::querySubControlMetrics(control, widget, subcontrol, opt);
@@ -6916,12 +6916,12 @@ QRect DominoStyle::querySubControlMetrics(ComplexControl control,
 
 		case CC_ScrollBar: {
 			
-			const QScrollBar *scrollbar = (const QScrollBar *) widget;
+			const TQScrollBar *scrollbar = (const TQScrollBar *) widget;
 			int sliderstart = scrollbar->sliderStart();
 			const int buttonw = 15 /*- (fw * 2)*/;
 			const int buttonh = 15 /*- (fw * 2)*/;
 
-			int maxlen = ((scrollbar->orientation() == Qt::Horizontal) ?
+			int maxlen = ((scrollbar->orientation() == TQt::Horizontal) ?
 					scrollbar->width() : scrollbar->height()) - buttonh * 3;
 
 			// calculate slider length
@@ -6940,34 +6940,34 @@ QRect DominoStyle::querySubControlMetrics(ComplexControl control,
 			
 			switch(subcontrol) {
 				case SC_ScrollBarAddLine: { // bottom/right button
-					if (scrollbar->orientation() == Qt::Horizontal) {
-						return QRect(scrollbar->width() - buttonw , 0, buttonw, buttonh);
+					if (scrollbar->orientation() == TQt::Horizontal) {
+						return TQRect(scrollbar->width() - buttonw , 0, buttonw, buttonh);
 					} else {
-						return QRect(0, scrollbar->height() - buttonh, buttonw, buttonh);
+						return TQRect(0, scrollbar->height() - buttonh, buttonw, buttonh);
 					}
 				}
 				case SC_ScrollBarSubLine: { // top/left button
-					return QRect(0, 0, buttonw, buttonh);
+					return TQRect(0, 0, buttonw, buttonh);
 				}
 				case SC_ScrollBarSubPage: // top/left
-					if (scrollbar->orientation() == Qt::Horizontal)
-						return QRect(buttonw, 0, sliderstart-buttonw+1, buttonw);
-					return QRect(0, buttonh, buttonw, sliderstart-buttonw+1);
+					if (scrollbar->orientation() == TQt::Horizontal)
+						return TQRect(buttonw, 0, sliderstart-buttonw+1, buttonw);
+					return TQRect(0, buttonh, buttonw, sliderstart-buttonw+1);
 
 				case SC_ScrollBarAddPage: // bottom/left
-					if (scrollbar->orientation() == Qt::Horizontal)
-						return QRect(sliderstart + sliderlen-1, 0, maxlen - sliderstart - sliderlen + buttonw+1, buttonw);
-					return QRect(0, sliderstart + sliderlen-1, buttonw, maxlen - sliderstart - sliderlen + buttonw+1);
+					if (scrollbar->orientation() == TQt::Horizontal)
+						return TQRect(sliderstart + sliderlen-1, 0, maxlen - sliderstart - sliderlen + buttonw+1, buttonw);
+					return TQRect(0, sliderstart + sliderlen-1, buttonw, maxlen - sliderstart - sliderlen + buttonw+1);
 
 				case SC_ScrollBarGroove:
-					if (scrollbar->orientation() == Qt::Horizontal)
-						return QRect(buttonw , 0, maxlen, buttonw);
-					return QRect(0, buttonw, buttonw, maxlen);
+					if (scrollbar->orientation() == TQt::Horizontal)
+						return TQRect(buttonw , 0, maxlen, buttonw);
+					return TQRect(0, buttonw, buttonw, maxlen);
 
 				case SC_ScrollBarSlider:
-					if (scrollbar->orientation() == Qt::Horizontal)
-						return QRect(sliderstart, 0, sliderlen, buttonw);
-					return QRect(0, sliderstart, buttonw, sliderlen);
+					if (scrollbar->orientation() == TQt::Horizontal)
+						return TQRect(sliderstart, 0, sliderlen, buttonw);
+					return TQRect(0, sliderstart, buttonw, sliderlen);
 				default:
 					break;
 			}
@@ -6978,7 +6978,7 @@ QRect DominoStyle::querySubControlMetrics(ComplexControl control,
 	}
 }
 
-int DominoStyle::pixelMetric(PixelMetric m, const QWidget *widget) const
+int DominoStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 {
 	//return KStyle::pixelMetric(m, widget);
 	
@@ -6988,11 +6988,11 @@ int DominoStyle::pixelMetric(PixelMetric m, const QWidget *widget) const
 		case PM_DefaultFrameWidth: {
 			
 			if(widget) {
-				if(dynamic_cast<const QPopupMenu*>(widget))
+				if(dynamic_cast<const TQPopupMenu*>(widget))
 					return 3;
 				
 				// stolen from baghira
-				if (dynamic_cast<QTabWidget*>(widget->parentWidget()) && widget->parentWidget()->parentWidget() && (widget->parentWidget()->parentWidget()->isA("KonqMainWindow") || widget->parentWidget()->parentWidget()->isA("KonqFrameContainer")))
+				if (dynamic_cast<TQTabWidget*>(widget->parentWidget()) && widget->parentWidget()->parentWidget() && (widget->parentWidget()->parentWidget()->isA("KonqMainWindow") || widget->parentWidget()->parentWidget()->isA("KonqFrameContainer")))
 					return 0;
 			
 			}
@@ -7017,11 +7017,11 @@ int DominoStyle::pixelMetric(PixelMetric m, const QWidget *widget) const
 	// TABS
 	// ----
 		case PM_TabBarTabVSpace: {
-			const QTabBar * tb = (const QTabBar *) widget;
+			const TQTabBar * tb = (const TQTabBar *) widget;
 			
 			switch(tb->shape()) {
-				case QTabBar::RoundedAbove:
-				case QTabBar::RoundedBelow:
+				case TQTabBar::RoundedAbove:
+				case TQTabBar::RoundedBelow:
 					return 12;
 				default:
 					return 4;
@@ -7030,11 +7030,11 @@ int DominoStyle::pixelMetric(PixelMetric m, const QWidget *widget) const
 		}
 		case PM_TabBarTabShiftVertical: {
 			
-			const QTabBar * tb = (const QTabBar *) widget;
+			const TQTabBar * tb = (const TQTabBar *) widget;
 			switch (tb->shape()) {
-				case QTabBar::RoundedAbove:
+				case TQTabBar::RoundedAbove:
 					return 1;
-				case QTabBar::RoundedBelow:
+				case TQTabBar::RoundedBelow:
 					return (tb->parentWidget() && tb->parentWidget()->isA("KonqFrameTabs"))? 0 : -1;
 				default:
 					return 0;
@@ -7047,19 +7047,19 @@ int DominoStyle::pixelMetric(PixelMetric m, const QWidget *widget) const
 			return 1;
 		}
 		case PM_TabBarBaseOverlap: {
-			const QTabWidget * tw = (const QTabWidget *) widget;
-			if(((DominoQTabWidget*)tw)->tabBar()->isHidden() || tw->isA("KonqFrameTabs"))
+			const TQTabWidget * tw = (const TQTabWidget *) widget;
+			if(((DominoTQTabWidget*)tw)->tabBar()->isHidden() || tw->isA("KonqFrameTabs"))
 				return 0;
-			return (tw->tabPosition() == QTabWidget::Top) ? -3 : -4;
+			return (tw->tabPosition() == TQTabWidget::Top) ? -3 : -4;
 		}
-#if (QT_VERSION >= 0x030300) // requires Qt 3.3
+#if (TQT_VERSION >= 0x030300) // requires TQt 3.3
 	// extra space between menubar items
 		case PM_MenuBarItemSpacing: {
 			return 6;
 		}
 #endif
 
-// #if (QT_VERSION >= 0x030300) // requires Qt 3.3
+// #if (TQT_VERSION >= 0x030300) // requires TQt 3.3
 //	   // extra space between toolbar items
 //		   case PM_ToolBarItemSpacing: {
 //			   return 4;
@@ -7128,10 +7128,10 @@ int DominoStyle::pixelMetric(PixelMetric m, const QWidget *widget) const
 }
 
 
-QSize DominoStyle::sizeFromContents(ContentsType t,
-									const QWidget *widget,
-									const QSize &s,
-									const QStyleOption &opt) const
+TQSize DominoStyle::sizeFromContents(ContentsType t,
+									const TQWidget *widget,
+									const TQSize &s,
+									const TQStyleOption &opt) const
 {
 	//return KStyle::sizeFromContents (t, widget, s, opt);
 	
@@ -7139,21 +7139,21 @@ QSize DominoStyle::sizeFromContents(ContentsType t,
 
 		case CT_PushButton:
 		{
-			const QPushButton* btn = static_cast<const QPushButton*>(widget);
+			const TQPushButton* btn = static_cast<const TQPushButton*>(widget);
 
 			int w = s.width();
 			int h = s.height();
 			if ( btn->text().isEmpty() && s.width() < 32 ) {
 				w += pixelMetric(PM_ButtonMargin, widget)*2;
 				h += pixelMetric(PM_ButtonMargin, widget)*2;
-				return QSize(w, h);
+				return TQSize(w, h);
 			}
 			
 			int bm = pixelMetric(PM_ButtonMargin, widget);
 			int fw = pixelMetric(PM_DefaultFrameWidth, widget) * 2;
 			w += bm + fw + 22;
 			h += bm + fw;
-			return QSize(w, h < 26 ? 26+_buttonHeightAdjustment : h+4 );
+			return TQSize(w, h < 26 ? 26+_buttonHeightAdjustment : h+4 );
 		}
 		case CT_ComboBox: {
 			int bm = pixelMetric(PM_ButtonMargin, widget);
@@ -7162,7 +7162,7 @@ QSize DominoStyle::sizeFromContents(ContentsType t,
 			int h = s.height();
 			w += bm + fw + 22;
 			h += bm + fw-3;
-			return QSize(w, h < 26 ? 26+_buttonHeightAdjustment : h+4 );
+			return TQSize(w, h < 26 ? 26+_buttonHeightAdjustment : h+4 );
 		}
 		
 		case CT_TabBarTab: {
@@ -7170,64 +7170,64 @@ QSize DominoStyle::sizeFromContents(ContentsType t,
 			// other = tab control
 			// this is total crap but it helps to reduce the flicker in konqi.
 			/////////////////////
-			QTabBar* tb = 0;
-			if(::qt_cast<QTabBar*>(widget))
-				tb = ::qt_cast<QTabBar*>(widget);
+			TQTabBar* tb = 0;
+			if(::tqt_cast<TQTabBar*>(widget))
+				tb = ::tqt_cast<TQTabBar*>(widget);
 			else
-				return QSize(s.width(), s.height());
+				return TQSize(s.width(), s.height());
 				
 			if(!strcmp(widget->name(), "tabbar") && widget->parentWidget()->isA("KonqFrameTabs")) {
 				
-				QTab* tab = opt.tab();
+				TQTab* tab = opt.tab();
 				int count = tb->count();
 
 				int fm = tb->fontMetrics().width("about:blank");
 				if(tb->parentWidget()->width() <= opt.tab()->rect().x()+44+fm)
-					return QSize(s.width(), s.height());
+					return TQSize(s.width(), s.height());
 
 				int dots = tb->fontMetrics().width(".");
 				if((dots*minTabLength+44)*count >= tb->width())  //  44 = frame+iconwidth
-					return QSize(s.width(), s.height());
+					return TQSize(s.width(), s.height());
 
-				QSize sz = KStyle::sizeFromContents( t, widget, s, opt );
+				TQSize sz = KStyle::sizeFromContents( t, widget, s, opt );
 	
-				QString str;
+				TQString str;
 				str.fill(' ', minTabLength);
 				if( tab->text().isEmpty() || tab->text() == str) {
 					tab->setText("about:blank");
-					//return QSize(  fm+44, 26 );
-					return QSize(  fm+44, s.height());
+					//return TQSize(  fm+44, 26 );
+					return TQSize(  fm+44, s.height());
 				}
-				return QSize(s.width(), s.height());
+				return TQSize(s.width(), s.height());
 			}
 			else {
 				switch (tb->shape()) {
-					case QTabBar::RoundedAbove:
-					case QTabBar::RoundedBelow:
-						return QSize( s.width(), s.height()-2 );
+					case TQTabBar::RoundedAbove:
+					case TQTabBar::RoundedBelow:
+						return TQSize( s.width(), s.height()-2 );
 					default:
-						return QSize( s.width(), s.height() ); // triangular
+						return TQSize( s.width(), s.height() ); // triangular
 				}
 			}
 		}
 		
 		case CT_ToolButton: {
-			if(dynamic_cast<const QToolButton*>(widget)) {
-				if(dynamic_cast<QTabWidget*>(widget->parentWidget())) // smaller cornerWidget
-					return QSize( s.width()+9, s.height()+7 );
-				return QSize( s.width()+11, s.height()+7 );
+			if(dynamic_cast<const TQToolButton*>(widget)) {
+				if(dynamic_cast<TQTabWidget*>(widget->parentWidget())) // smaller cornerWidget
+					return TQSize( s.width()+9, s.height()+7 );
+				return TQSize( s.width()+11, s.height()+7 );
 			}
 			return KStyle::sizeFromContents (t, widget, s, opt); // KMultiTabBar buttons
 		}
 		case CT_SpinBox: {
-			QSize sz = KStyle::sizeFromContents( t, widget, s, opt );
+			TQSize sz = KStyle::sizeFromContents( t, widget, s, opt );
 			int h = sz.height()%2 != 0 ? sz.height()+1 : sz.height();
-			return ( QSize( sz.width(), h < 24 ? 24 : h) );
+			return ( TQSize( sz.width(), h < 24 ? 24 : h) );
 		}
 		
 		case CT_Header: {
-			QSize sz = KStyle::sizeFromContents( t, widget, s, opt );
-			return QSize(sz.width(), sz.height()-2);
+			TQSize sz = KStyle::sizeFromContents( t, widget, s, opt );
+			return TQSize(sz.width(), sz.height()-2);
 		}
 		
 		case CT_PopupMenuItem: {
@@ -7237,8 +7237,8 @@ QSize DominoStyle::sizeFromContents(ContentsType t,
 // 			static const int itemFrame = 7;
 // 			static const int arrowHMargin = 6;
 			
-			const QPopupMenu *popup = dynamic_cast<const QPopupMenu *>(widget);
-			QMenuItem *mi = opt.menuItem();
+			const TQPopupMenu *popup = dynamic_cast<const TQPopupMenu *>(widget);
+			TQMenuItem *mi = opt.menuItem();
 			int maxpmw = opt.maxIconWidth();
 			int w = s.width(), h = s.height(); // includes pixmap width
 			int cmwidth = 16;
@@ -7256,14 +7256,14 @@ QSize DominoStyle::sizeFromContents(ContentsType t,
 				h = 5;
 			} else {
 				if (mi->pixmap()) {
-					h = QMAX(h, mi->pixmap()->height() + 2);
+					h = TQMAX(h, mi->pixmap()->height() + 2);
 				} else {
-					h = QMAX(h, 16 + 2 );
-					h = QMAX(h, popup->fontMetrics().height() + 4 );
+					h = TQMAX(h, 16 + 2 );
+					h = TQMAX(h, popup->fontMetrics().height() + 4 );
 				}
 
 				if (mi->iconSet()) {
-					h = QMAX(h, mi->iconSet()->pixmap(QIconSet::Small, QIconSet::Normal).height() + 2);
+					h = TQMAX(h, mi->iconSet()->pixmap(TQIconSet::Small, TQIconSet::Normal).height() + 2);
 				}
 			}
 			
@@ -7289,7 +7289,7 @@ QSize DominoStyle::sizeFromContents(ContentsType t,
 			else
 				w += cmwidth;
 			
-			return QSize(w, h);
+			return TQSize(w, h);
 		}
 		default:
 			return KStyle::sizeFromContents (t, widget, s, opt);
@@ -7299,22 +7299,22 @@ QSize DominoStyle::sizeFromContents(ContentsType t,
 }
 
 int DominoStyle::styleHint( StyleHint stylehint,
-								   const QWidget *widget,
-								   const QStyleOption &option,
-								   QStyleHintReturn* returnData ) const
+								   const TQWidget *widget,
+								   const TQStyleOption &option,
+								   TQStyleHintReturn* returnData ) const
 {
 	switch (stylehint) {
 		case SH_PopupMenu_SubMenuPopupDelay:
 			//return 96; // Motif-like delay...
 			return 250;
 		case SH_GroupBox_TextLabelVerticalAlignment: {
-			return Qt::AlignTop;
+			return TQt::AlignTop;
 		}
 		case SH_ScrollBar_BackgroundMode: {
-			return Qt::PaletteBackground;
+			return TQt::PaletteBackground;
 		}
 		case SH_ScrollBar_ScrollWhenPointerLeavesControl:
-			// if set to false (the default) it will also scroll when the subPage button is pressed, so no choice here (Qt 3.6)
+			// if set to false (the default) it will also scroll when the subPage button is pressed, so no choice here (TQt 3.6)
 			return true;
 		case SH_TabBar_Alignment: {
 			return _centerTabs ? AlignHCenter : AlignLeft;
@@ -7325,10 +7325,10 @@ int DominoStyle::styleHint( StyleHint stylehint,
 		case SH_LineEdit_PasswordCharacter:
 		{
 			if (widget) {
-				const QFontMetrics &fm = widget->fontMetrics();
-				if (fm.inFont(QChar(0x25CF))) {
+				const TQFontMetrics &fm = widget->fontMetrics();
+				if (fm.inFont(TQChar(0x25CF))) {
 					return 0x25CF;
-				} else if (fm.inFont(QChar(0x2022))) {
+				} else if (fm.inFont(TQChar(0x2022))) {
 					return 0x2022;
 				}
 			}
@@ -7339,28 +7339,28 @@ int DominoStyle::styleHint( StyleHint stylehint,
 	}
 }
 
-QPixmap DominoStyle::stylePixmap(StylePixmap stylepixmap, const QWidget* widget, const QStyleOption& opt) const {
+TQPixmap DominoStyle::stylePixmap(StylePixmap stylepixmap, const TQWidget* widget, const TQStyleOption& opt) const {
 	
 	switch (stylepixmap) {
 		case SP_DockWindowCloseButton:
 		case SP_TitleBarCloseButton:
-			return QPixmap(qembed_findImage("DockCloseButton").copy(0,0,12,12));
+			return TQPixmap(qembed_findImage("DockCloseButton").copy(0,0,12,12));
 		case SP_TitleBarMinButton:
-			return QPixmap(qembed_findImage("DockbackButton").copy(0,0,12,12));
+			return TQPixmap(qembed_findImage("DockbackButton").copy(0,0,12,12));
 		case SP_TitleBarMaxButton:
-			return QPixmap(qembed_findImage("OverlapButton").copy(0,0,12,12));
+			return TQPixmap(qembed_findImage("OverlapButton").copy(0,0,12,12));
 		case SP_TitleBarNormalButton:
-			return QPixmap(qembed_findImage("ToDesktopButton").copy(0,0,12,12));
+			return TQPixmap(qembed_findImage("ToDesktopButton").copy(0,0,12,12));
 		default:
 			return KStyle::stylePixmap(stylepixmap, widget, opt);
 	}
 }
 
 
-QColor DominoStyle::lightenColor(const QColor &color, const int value) const
+TQColor DominoStyle::lightenColor(const TQColor &color, const int value) const
 {
 	if(value < 0)
-		return darkenColor(color, QABS(value));
+		return darkenColor(color, TQABS(value));
 	int r, g, b;
 	color.getRgb(&r, &g, &b);
 	r += value;
@@ -7372,13 +7372,13 @@ QColor DominoStyle::lightenColor(const QColor &color, const int value) const
 	b += value;
 	if(b > 255)
 		b =255;
-	return QColor(r, g, b);
+	return TQColor(r, g, b);
 }
 
-QColor DominoStyle::darkenColor(const QColor &color, const int value) const
+TQColor DominoStyle::darkenColor(const TQColor &color, const int value) const
 {
 	if(value < 0)
-		return lightenColor(color, QABS(value));
+		return lightenColor(color, TQABS(value));
 	int r, g, b;
 	color.getRgb(&r, &g, &b);
 	r -= value;
@@ -7390,10 +7390,10 @@ QColor DominoStyle::darkenColor(const QColor &color, const int value) const
 	b -= value;
 	if(b < 0)
 		b = 0;
-	return QColor(r, g, b);
+	return TQColor(r, g, b);
 }
 
-QColor DominoStyle::dGetColor(const QColor &color, const int value) const
+TQColor DominoStyle::dGetColor(const TQColor &color, const int value) const
 {
 	int h, s, v;
 	color.getHsv(&h, &s, &v);
@@ -7401,7 +7401,7 @@ QColor DominoStyle::dGetColor(const QColor &color, const int value) const
 }
 
 
-QPixmap* DominoStyle::renderLineEditShadow(QWidget* widget, QRect r, QColor bg, uint flags, bool /*reverse*/) {
+TQPixmap* DominoStyle::renderLineEditShadow(TQWidget* widget, TQRect r, TQColor bg, uint flags, bool /*reverse*/) {
 	
 	bool drawLeft = flags& Draw_Left;
 	bool drawRight = flags& Draw_Right;
@@ -7414,35 +7414,35 @@ QPixmap* DominoStyle::renderLineEditShadow(QWidget* widget, QRect r, QColor bg,
 	}
 	else if(!drawRight)
 		w += 3;
-	QRect rect(x, y, w, h);
+	TQRect rect(x, y, w, h);
 	
 	
-	QColor tintColor;
-	QString enabled = widget->isEnabled() ? "1" : "0";
+	TQColor tintColor;
+	TQString enabled = widget->isEnabled() ? "1" : "0";
 	if(!widget->isEnabled())
 		tintColor =bg;
 	else
-		tintColor = alphaBlendColors(Qt::black, bg, 30+35);
+		tintColor = alphaBlendColors(TQt::black, bg, 30+35);
 	
-	QPixmap* prBgShadow;
-	if(!(prBgShadow = QPixmapCache::find(QString::number(bg.pixel(), 16)+QString::number(qApp->palette().active().background().pixel(), 16)+"leBgShadow"+enabled))) {
-		prBgShadow = new QPixmap(4,4);
+	TQPixmap* prBgShadow;
+	if(!(prBgShadow = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(tqApp->palette().active().background().pixel(), 16)+"leBgShadow"+enabled))) {
+		prBgShadow = new TQPixmap(4,4);
 		prBgShadow->fill(bg);
-		QPixmap pix = tintImage(qembed_findImage("progressShadow2"), tintColor);
+		TQPixmap pix = tintImage(qembed_findImage("progressShadow2"), tintColor);
 		bitBlt(prBgShadow, 0, 0, &pix);
-		QPixmapCache::insert(QString::number(bg.pixel(), 16)+QString::number(qApp->palette().active().background().pixel(), 16)+"leBgShadow"+enabled, prBgShadow);
+		TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(tqApp->palette().active().background().pixel(), 16)+"leBgShadow"+enabled, prBgShadow);
 	}
 	
 	
-	QPixmap* pix = new QPixmap(rect.size());
+	TQPixmap* pix = new TQPixmap(rect.size());
 	pix->fill(bg);
 	
 	if(widget->isEnabled()) {
-		QPainter p(pix);
+		TQPainter p(pix);
 		
-		QColor color_d = alphaBlendColors(tintColor, bg, 170);
-		QColor color_m = alphaBlendColors(tintColor, bg, 85);
-		QColor color_l = alphaBlendColors(tintColor, bg, 25);
+		TQColor color_d = alphaBlendColors(tintColor, bg, 170);
+		TQColor color_m = alphaBlendColors(tintColor, bg, 85);
+		TQColor color_l = alphaBlendColors(tintColor, bg, 25);
 		
 		p.setPen(color_d);
 		p.drawLine(rect.x()+2, rect.y(), rect.right()-2, rect.y());
@@ -7460,35 +7460,35 @@ QPixmap* DominoStyle::renderLineEditShadow(QWidget* widget, QRect r, QColor bg,
 		p.drawLine(rect.x(), rect.y()+3, rect.x(), rect.bottom()-1); // l
 		p.drawLine(rect.right(), rect.y()+3, rect.right(), rect.bottom()-1); // r
 		
-		bitBlt(pix, rect.right()-1, rect.y(), prBgShadow, 2, 0, 2, 3, Qt::CopyROP);
-		bitBlt(pix, rect.x(), rect.y(), prBgShadow, 0, 0, 2, 3, Qt::CopyROP);
-		bitBlt(pix, rect.right()-1, rect.bottom(), prBgShadow, 2, 3, 2, 1, Qt::CopyROP);
-		bitBlt(pix, rect.x(), rect.bottom(), prBgShadow, 0, 3, 2, 1, Qt::CopyROP);
+		bitBlt(pix, rect.right()-1, rect.y(), prBgShadow, 2, 0, 2, 3, TQt::CopyROP);
+		bitBlt(pix, rect.x(), rect.y(), prBgShadow, 0, 0, 2, 3, TQt::CopyROP);
+		bitBlt(pix, rect.right()-1, rect.bottom(), prBgShadow, 2, 3, 2, 1, TQt::CopyROP);
+		bitBlt(pix, rect.x(), rect.bottom(), prBgShadow, 0, 3, 2, 1, TQt::CopyROP);
 		
 		p.end();
 	}
 	return pix;
 }
 
-QColor DominoStyle::getGroupBoxColor(const QWidget* w) const {
-	QWidget* parent = w->parentWidget();
+TQColor DominoStyle::getGroupBoxColor(const TQWidget* w) const {
+	TQWidget* parent = w->parentWidget();
 	int tint = groupBoxSettings.customColor ? 0 : groupBoxSettings.brightness;
-	while(dynamic_cast<QGroupBox*>(parent)) {
+	while(dynamic_cast<TQGroupBox*>(parent)) {
 		parent = parent->parentWidget();
 		tint += groupBoxSettings.brightness;
 	}
 	
-	return QColor(darkenColor(groupBoxSettings.customColor ? groupBoxSettings.color :
-			qApp->palette().active().background(), tint));
+	return TQColor(darkenColor(groupBoxSettings.customColor ? groupBoxSettings.color :
+			tqApp->palette().active().background(), tint));
 	
 }
 
-QPixmap* DominoStyle::createCheckMark(const QColor color) const {
+TQPixmap* DominoStyle::createCheckMark(const TQColor color) const {
 	
-	QImage checkMark_enabled = qembed_findImage("checkmark");
-	QImage checkMark_disabled =  setImageOpacity(checkMark_enabled, 25);
+	TQImage checkMark_enabled = qembed_findImage("checkmark");
+	TQImage checkMark_disabled =  setImageOpacity(checkMark_enabled, 25);
 	
-	QImage img(32, 17, 32); // left enabled, right disabled
+	TQImage img(32, 17, 32); // left enabled, right disabled
 	img.setAlphaBuffer(true);
 	for(int x=0; x < checkMark_enabled.width(); ++x) {
 		for(int y=0; y < checkMark_enabled.height(); ++y) {
@@ -7501,17 +7501,17 @@ QPixmap* DominoStyle::createCheckMark(const QColor color) const {
 		}
 	}
 	
-	return new QPixmap(tintImage(img, color));
+	return new TQPixmap(tintImage(img, color));
 }
 
-QPixmap* DominoStyle::createRadioIndicator(const QColor color) const {
+TQPixmap* DominoStyle::createRadioIndicator(const TQColor color) const {
 	
-	QImage dot_enabled = tintImage(qembed_findImage("rb-dot"),color);
+	TQImage dot_enabled = tintImage(qembed_findImage("rb-dot"),color);
 	
 	blend(qembed_findImage("rb-dot-shadow"), dot_enabled, dot_enabled);
-	QImage dot_disabled = setImageOpacity(dot_enabled, 25);
+	TQImage dot_disabled = setImageOpacity(dot_enabled, 25);
 
-	QImage img(10, 5, 32);
+	TQImage img(10, 5, 32);
 	img.setAlphaBuffer(true);
 	for(int x=0; x < dot_enabled.width(); ++x) {
 		for(int y=0; y < dot_enabled.height(); ++y) {
@@ -7524,44 +7524,44 @@ QPixmap* DominoStyle::createRadioIndicator(const QColor color) const {
 		}
 	}
 	
-	return new QPixmap(img);
+	return new TQPixmap(img);
 }
 
 
-void DominoStyle::drawFocusIndicator(QPainter *p, const QRect &r, int flags, const QColorGroup cg, bool /*enabled*/,
-			const QPixmap* /*pixmap*/, const QString & text, int /*len = -1*/, const QColor& highlight, bool drawLine, bool isButton) const
+void DominoStyle::drawFocusIndicator(TQPainter *p, const TQRect &r, int flags, const TQColorGroup cg, bool /*enabled*/,
+			const TQPixmap* /*pixmap*/, const TQString & text, int /*len = -1*/, const TQColor& highlight, bool drawLine, bool isButton) const
 {
 
 	if(drawLine) {
 // 		p->setPen(cg.foreground());
-// 		QPixmap edges = tintImage(qembed_findImage("indicatorEdges"), cg.foreground());
-// 		bitBlt(p->device(), r.x(), r.bottom()-1, &edges, 0, 0, 2, 1, Qt::CopyROP);
-// 		bitBlt(p->device(), r.right()-2, r.bottom()-1, &edges, 2, 0, 2, 1, Qt::CopyROP);
+// 		TQPixmap edges = tintImage(qembed_findImage("indicatorEdges"), cg.foreground());
+// 		bitBlt(p->device(), r.x(), r.bottom()-1, &edges, 0, 0, 2, 1, TQt::CopyROP);
+// 		bitBlt(p->device(), r.right()-2, r.bottom()-1, &edges, 2, 0, 2, 1, TQt::CopyROP);
 // 		p->drawLine(r.x()+2, r.bottom()-1, r.right()-3, r.bottom()-1);
-		QFont font = p->font();
+		TQFont font = p->font();
 		font.setUnderline(true);
 		p->setFont(font);
 	}
 	else {
-		QRect br = p->fontMetrics().boundingRect(r.x(), r.y(), r.width(), r.height(), flags, text);
-		QPainter pixPainter;
-		QPixmap textPixmap(br.width()+2, br.height()+2);
-		textPixmap.fill(QColor(0,0,0));
+		TQRect br = p->fontMetrics().boundingRect(r.x(), r.y(), r.width(), r.height(), flags, text);
+		TQPainter pixPainter;
+		TQPixmap textPixmap(br.width()+2, br.height()+2);
+		textPixmap.fill(TQColor(0,0,0));
 		pixPainter.begin(&textPixmap);
 		pixPainter.setPen(white);
 		pixPainter.setFont(p->font());
-		pixPainter.drawText( QRect(1, 1, br.width()-1, br.height()-1), flags, text );
+		pixPainter.drawText( TQRect(1, 1, br.width()-1, br.height()-1), flags, text );
 		pixPainter.end();
 		
 		
-		DominoQPixmap* pixm = (DominoQPixmap*)&textPixmap;
+		DominoTQPixmap* pixm = (DominoTQPixmap*)&textPixmap;
 		
 		uint height = pixm->height();
 		uint width = pixm->width();
 		
-		pixm->data->alphapm = new QPixmap;
+		pixm->data->alphapm = new TQPixmap;
 		
-		DominoQPixmap* alphapm = (DominoQPixmap*)pixm->data->alphapm;
+		DominoTQPixmap* alphapm = (DominoTQPixmap*)pixm->data->alphapm;
 		
 		alphapm->data->w = width;
 		alphapm->data->h = height;
@@ -7572,7 +7572,7 @@ void DominoStyle::drawFocusIndicator(QPainter *p, const QRect &r, int flags, con
 		XImage *axi = XCreateImage(alphapm->x11Display(), (Visual *) alphapm->x11Visual(), 8, ZPixmap, 0, 0, width, height, 8, 0);
 		axi->data = (char *) malloc((unsigned) axi->bytes_per_line * height);
 		
-		XImage* xi = XGetImage( qt_xdisplay(), pixm->handle(), 0, 0, width, height, AllPlanes, ZPixmap );
+		XImage* xi = XGetImage( tqt_xdisplay(), pixm->handle(), 0, 0, width, height, AllPlanes, ZPixmap );
 		
 		register int alpha;
 		register float AXIS_FACTOR = 2.0;
@@ -7583,18 +7583,18 @@ void DominoStyle::drawFocusIndicator(QPainter *p, const QRect &r, int flags, con
 		for(register uint x = 1; x < width-1; ++x) {
 			for(register uint y = 1; y < height-1; ++y) {
 				
-				alphaShadow = (qBlue(XGetPixel(xi,x-1,y-1)) * DIAGONAL_FACTOR +
-						qBlue(XGetPixel(xi,x-1,y  )) * AXIS_FACTOR +
-						qBlue(XGetPixel(xi,x-1,y+1)) * DIAGONAL_FACTOR +
-						qBlue(XGetPixel(xi,x ,y-1)) * AXIS_FACTOR +
+				alphaShadow = (tqBlue(XGetPixel(xi,x-1,y-1)) * DIAGONAL_FACTOR +
+						tqBlue(XGetPixel(xi,x-1,y  )) * AXIS_FACTOR +
+						tqBlue(XGetPixel(xi,x-1,y+1)) * DIAGONAL_FACTOR +
+						tqBlue(XGetPixel(xi,x ,y-1)) * AXIS_FACTOR +
 						0                         +
-						qBlue(XGetPixel(xi,x ,y+1)) * AXIS_FACTOR +
-						qBlue(XGetPixel(xi,x+1,y-1)) * DIAGONAL_FACTOR +
-						qBlue(XGetPixel(xi,x+1,y  )) * AXIS_FACTOR +
-						qBlue(XGetPixel(xi,x+1,y+1)) * DIAGONAL_FACTOR) / 2.0; // / multiplicationFactor
+						tqBlue(XGetPixel(xi,x ,y+1)) * AXIS_FACTOR +
+						tqBlue(XGetPixel(xi,x+1,y-1)) * DIAGONAL_FACTOR +
+						tqBlue(XGetPixel(xi,x+1,y  )) * AXIS_FACTOR +
+						tqBlue(XGetPixel(xi,x+1,y+1)) * DIAGONAL_FACTOR) / 2.0; // / multiplicationFactor
 					
 				alpha = (int)alphaShadow;
-				XPutPixel(axi, x, y, QMIN(255, alpha) *customalpha >> 8);
+				XPutPixel(axi, x, y, TQMIN(255, alpha) *customalpha >> 8);
 			}
 		}
 			
@@ -7603,7 +7603,7 @@ void DominoStyle::drawFocusIndicator(QPainter *p, const QRect &r, int flags, con
 		
 		textPixmap.fill(highlight);
 		
-		QRect fr = QRect(br.x(), br.y(), QMIN((int)width-2, r.width()) , QMIN((int)height-2, r.height()));
+		TQRect fr = TQRect(br.x(), br.y(), TQMIN((int)width-2, r.width()) , TQMIN((int)height-2, r.height()));
 		if(fr.x() < r.x()) {
 			p->setClipRegion(r);
 			fr.setWidth(fr.width()+abs(fr.x())+2);
@@ -7623,10 +7623,10 @@ void DominoStyle::drawFocusIndicator(QPainter *p, const QRect &r, int flags, con
 	}
 }
 
-QPixmap DominoStyle::renderOutlineIcon(const QPixmap* icon) const
+TQPixmap DominoStyle::renderOutlineIcon(const TQPixmap* icon) const
 {
-	QImage img = icon->convertToImage();
-	QImage outlineIcon(img.width()+2, img.height()+2, 32);
+	TQImage img = icon->convertToImage();
+	TQImage outlineIcon(img.width()+2, img.height()+2, 32);
 	outlineIcon.setAlphaBuffer(true);
 	
 	register unsigned int *outlineIconData = (unsigned int*) outlineIcon.bits();
@@ -7646,27 +7646,27 @@ QPixmap DominoStyle::renderOutlineIcon(const QPixmap* icon) const
 	
 	register uint customalpha = focusIndicatorSettings.buttonOpacity;
 	for (register uint current = 0 ; current < total ; ++current ) {
-		outlineIconData[ current ] = qRgba( focusIndicatorSettings.buttonColor.red(), focusIndicatorSettings.buttonColor.green(), focusIndicatorSettings.buttonColor.blue(), qAlpha(outlineIconData[ current ]) * customalpha >> 8);
+		outlineIconData[ current ] = tqRgba( focusIndicatorSettings.buttonColor.red(), focusIndicatorSettings.buttonColor.green(), focusIndicatorSettings.buttonColor.blue(), tqAlpha(outlineIconData[ current ]) * customalpha >> 8);
 	}
 	
-	return QPixmap(outlineIcon);
+	return TQPixmap(outlineIcon);
 }
 
 
 
 
-void DominoStyle::drawItem( QPainter *p, const QRect &r,
-			    int flags, const QColorGroup &g, bool enabled,
-			    const QPixmap *pixmap, const QString& text, int len,
-			    const QColor* penColor ) const
+void DominoStyle::drawItem( TQPainter *p, const TQRect &r,
+			    int flags, const TQColorGroup &g, bool enabled,
+			    const TQPixmap *pixmap, const TQString& text, int len,
+			    const TQColor* penColor ) const
 {
 	dominoDrawItem(p, r, flags, g, enabled, pixmap, text, len, penColor, false);
 }
 
-void DominoStyle::dominoDrawItem( QPainter *p, const QRect &r,
-		       int flags, const QColorGroup &g, bool enabled,
-		       const QPixmap *pixmap, const QString& text, int len,
-		       const QColor* penColor, bool buttonTextEffect ) const
+void DominoStyle::dominoDrawItem( TQPainter *p, const TQRect &r,
+		       int flags, const TQColorGroup &g, bool enabled,
+		       const TQPixmap *pixmap, const TQString& text, int len,
+		       const TQColor* penColor, bool buttonTextEffect ) const
 {
 	
 	int x = r.x();
@@ -7676,28 +7676,28 @@ void DominoStyle::dominoDrawItem( QPainter *p, const QRect &r,
 
 	p->setPen( penColor?*penColor:g.foreground() );
 	if ( pixmap ) {
-		QPixmap  pm( *pixmap );
-		bool clip = (flags & Qt::DontClip) == 0;
+		TQPixmap  pm( *pixmap );
+		bool clip = (flags & TQt::DontClip) == 0;
 		if ( clip ) {
 			if ( pm.width() < w && pm.height() < h ) {
 				clip = FALSE;
 			} else {
 				p->save();
-				QRegion cr = QRect(x, y, w, h);
+				TQRegion cr = TQRect(x, y, w, h);
 				if (p->hasClipping())
-					cr &= p->clipRegion(QPainter::CoordPainter);
+					cr &= p->clipRegion(TQPainter::CoordPainter);
 				p->setClipRegion(cr);
 			}
 		}
-		if ( (flags & Qt::AlignVCenter) == Qt::AlignVCenter )
+		if ( (flags & TQt::AlignVCenter) == TQt::AlignVCenter )
 			y += h/2 - pm.height()/2;
-		else if ( (flags & Qt::AlignBottom) == Qt::AlignBottom)
+		else if ( (flags & TQt::AlignBottom) == TQt::AlignBottom)
 			y += h - pm.height();
-		if ( (flags & Qt::AlignRight) == Qt::AlignRight )
+		if ( (flags & TQt::AlignRight) == TQt::AlignRight )
 			x += w - pm.width();
-		else if ( (flags & Qt::AlignHCenter) == Qt::AlignHCenter )
+		else if ( (flags & TQt::AlignHCenter) == TQt::AlignHCenter )
 			x += w/2 - pm.width()/2;
-		else if ( ((flags & Qt::AlignLeft) != Qt::AlignLeft) && QApplication::reverseLayout() ) // AlignAuto && rightToLeft
+		else if ( ((flags & TQt::AlignLeft) != TQt::AlignLeft) && TQApplication::reverseLayout() ) // AlignAuto && rightToLeft
 			x += w - pm.width();
 
 		p->drawPixmap( x, y, pm );
@@ -7709,24 +7709,24 @@ void DominoStyle::dominoDrawItem( QPainter *p, const QRect &r,
 
 		if(textEffectSettings.mode > 1 || buttonTextEffect) { // 0=none, 1=only buttons, 2=everywhere
 			
-			QRect br = p->fontMetrics().boundingRect(x, y, w, h, flags, text);
-			QPainter pixPainter;
-			QPixmap textPixmap(br.width(), br.height());
-			textPixmap.fill(QColor(0,0,0));
+			TQRect br = p->fontMetrics().boundingRect(x, y, w, h, flags, text);
+			TQPainter pixPainter;
+			TQPixmap textPixmap(br.width(), br.height());
+			textPixmap.fill(TQColor(0,0,0));
 			pixPainter.begin(&textPixmap);
 			pixPainter.setPen(white);
 			pixPainter.setFont(p->font());
-			pixPainter.drawText( QRect(0,0,br.width(), br.height()), flags, text );
+			pixPainter.drawText( TQRect(0,0,br.width(), br.height()), flags, text );
 			pixPainter.end();
 			
-			DominoQPixmap* pixm = (DominoQPixmap*)&textPixmap;
+			DominoTQPixmap* pixm = (DominoTQPixmap*)&textPixmap;
 			
 			uint height = pixm->height();
 			uint width = pixm->width();
 			
-			pixm->data->alphapm = new QPixmap;
+			pixm->data->alphapm = new TQPixmap;
 			
-			DominoQPixmap* alphapm = (DominoQPixmap*)pixm->data->alphapm;
+			DominoTQPixmap* alphapm = (DominoTQPixmap*)pixm->data->alphapm;
 			
 			alphapm->data->w = width;
 			alphapm->data->h = height;
@@ -7736,7 +7736,7 @@ void DominoStyle::dominoDrawItem( QPainter *p, const QRect &r,
 			
 			XImage *axi = XCreateImage(alphapm->x11Display(), (Visual *) alphapm->x11Visual(), 8, ZPixmap, 0, 0, width, height, 8, 0);
 			axi->data = (char *) malloc((unsigned) axi->bytes_per_line * height);
-			XImage* xi = XGetImage( qt_xdisplay(), pixm->handle(), 0, 0, width, height, AllPlanes, ZPixmap );
+			XImage* xi = XGetImage( tqt_xdisplay(), pixm->handle(), 0, 0, width, height, AllPlanes, ZPixmap );
 			
 			register int alpha;
 			register int customalpha = buttonTextEffect ? textEffectSettings.buttonOpacity : textEffectSettings.opacity;
@@ -7754,7 +7754,7 @@ void DominoStyle::dominoDrawItem( QPainter *p, const QRect &r,
 			if(buttonTextEffect) {
 				textPixmap.fill(textEffectSettings.buttonColor);
 				
-				QRect tr = QRect(br.x()+textEffectSettings.buttonPos.x(), br.y()+textEffectSettings.buttonPos.y(), r.width(), r.height());
+				TQRect tr = TQRect(br.x()+textEffectSettings.buttonPos.x(), br.y()+textEffectSettings.buttonPos.y(), r.width(), r.height());
 				if(tr.x() < r.x()) {
 					p->setClipRegion(r);
 					tr.setWidth(tr.width()+r.x()+abs(tr.x()));
@@ -7766,7 +7766,7 @@ void DominoStyle::dominoDrawItem( QPainter *p, const QRect &r,
 			else {
 				textPixmap.fill(textEffectSettings.color);
 				
-				QRect tr = QRect(br.x()+textEffectSettings.pos.x(), br.y()+textEffectSettings.pos.y(), r.width(), r.height());
+				TQRect tr = TQRect(br.x()+textEffectSettings.pos.x(), br.y()+textEffectSettings.pos.y(), r.width(), r.height());
 				if(tr.x() < r.x()) {
 					p->setClipRegion(r);
 					tr.setWidth(tr.width()+r.x()+abs(tr.x()));
@@ -7792,24 +7792,24 @@ void DominoStyle::dominoDrawItem( QPainter *p, const QRect &r,
 }
 
 
-QWidget::BackgroundOrigin DominoStyle::setPixmapOrigin(QWidget::BackgroundOrigin origin)
+TQWidget::BackgroundOrigin DominoStyle::setPixmapOrigin(TQWidget::BackgroundOrigin origin)
 {
 		switch(origin) {
-			case QWidget::WidgetOrigin:
-				return QWidget::ParentOrigin;
-			case QWidget::ParentOrigin:
-				return QWidget::AncestorOrigin;
+			case TQWidget::WidgetOrigin:
+				return TQWidget::ParentOrigin;
+			case TQWidget::ParentOrigin:
+				return TQWidget::AncestorOrigin;
 			default:
 				return origin;
 				break;
 		}
 }
 
-void DominoStyle::setDominoButtonPalette(QWidget* widget, PaletteTyp type) {
-	QPalette pal;
+void DominoStyle::setDominoButtonPalette(TQWidget* widget, PaletteTyp type) {
+	TQPalette pal;
 	switch(type) {
 		case Palette_Application:
-			pal = qApp->palette();
+			pal = tqApp->palette();
 			break;
 		case Palette_Parent:
 			pal = widget->parentWidget()->palette();
@@ -7822,8 +7822,8 @@ void DominoStyle::setDominoButtonPalette(QWidget* widget, PaletteTyp type) {
 	
 	int h, s, v;
 	pal.active().buttonText().hsv(&h, &s, &v);
-	QColor disabledColor = alphaBlendColors(pal.active().buttonText(), v < 127 ? white : black, 150);
-	pal.setColor(QPalette::Disabled, QColorGroup::Text, disabledColor);
+	TQColor disabledColor = alphaBlendColors(pal.active().buttonText(), v < 127 ? white : black, 150);
+	pal.setColor(TQPalette::Disabled, TQColorGroup::Text, disabledColor);
 	
 	widget->setPalette(pal);
 }
@@ -7831,39 +7831,39 @@ void DominoStyle::setDominoButtonPalette(QWidget* widget, PaletteTyp type) {
 
 void DominoStyle::updateTabWidgetFrame() {
 	
-	QTabWidget* tw = dynamic_cast<QTabWidget*>(sender()->parent());
-	QWidget* w = tw ? tw->currentPage() : 0;
+	TQTabWidget* tw = dynamic_cast<TQTabWidget*>(sender()->parent());
+	TQWidget* w = tw ? tw->currentPage() : 0;
 	if(!w)
 		    return;
-	QFrame* f = dynamic_cast<QFrame*>(w->parentWidget());
+	TQFrame* f = dynamic_cast<TQFrame*>(w->parentWidget());
 	if(f) {
-		QRect r = f->rect();
-		if(tw->tabPosition() == QTabWidget::Top)
-			r= QRect(r.x(), r.y(), r.width(), 3);
+		TQRect r = f->rect();
+		if(tw->tabPosition() == TQTabWidget::Top)
+			r= TQRect(r.x(), r.y(), r.width(), 3);
 		else
-			r= QRect(r.x(), r.y()+r.height()-4, r.width(), 2);
+			r= TQRect(r.x(), r.y()+r.height()-4, r.width(), 2);
 		f->repaint(r, false);
 	}
 }
 
-QPixmap DominoStyle::disableIcon(const QPixmap* icon) const {
+TQPixmap DominoStyle::disableIcon(const TQPixmap* icon) const {
 	
-	QImage img = icon->convertToImage();
+	TQImage img = icon->convertToImage();
 	register uint pixels = img.depth() > 8 ? img.width()*img.height() :  img.numColors();
 	register uint *data = img.depth() > 8 ? (unsigned int *)img.bits() : (unsigned int *)img.colorTable();
 	register uint val, i;
 	for(i=0; i < pixels; ++i){
-		val = qGray(data[i]);
-		data[i] = qRgba(val, val, val, qAlpha(data[i]));
+		val = tqGray(data[i]);
+		data[i] = tqRgba(val, val, val, tqAlpha(data[i]));
 	}
 	img = setImageOpacity(img, 50);
 	
-	return QPixmap(img);
+	return TQPixmap(img);
 }
 
 
 // same as in renderSurface() but with darker colors
-void DominoStyle::renderTabSeparator(QPainter *p, const QRect &r, const QColor buttonColor, bool tabAbove) const {
+void DominoStyle::renderTabSeparator(TQPainter *p, const TQRect &r, const TQColor buttonColor, bool tabAbove) const {
 	
 	const DSurface* ds = tabAbove ? &tabTopSurface : &tabBottomSurface;
 	
@@ -7872,13 +7872,13 @@ void DominoStyle::renderTabSeparator(QPainter *p, const QRect &r, const QColor b
 	int top2 = r.y()+r.height()*ds->g2Top/100;
 	int bottom2 = r.height()*ds->g2Bottom/100-top2;
 	
-	QColor c1;
-	QColor c2;
-	QColor c3;
-	QColor c4;
-	QColor bg;
+	TQColor c1;
+	TQColor c2;
+	TQColor c3;
+	TQColor c4;
+	TQColor bg;
 	
-	if(buttonColor != qApp->palette().active().button()) {
+	if(buttonColor != tqApp->palette().active().button()) {
 		c1 = alphaBlendColors(buttonColor, ds->g1Color1, 127);
 		c2 = alphaBlendColors(buttonColor, ds->g1Color2, 127);
 		c3 = alphaBlendColors(buttonColor, ds->g2Color1, 127);
@@ -7894,82 +7894,82 @@ void DominoStyle::renderTabSeparator(QPainter *p, const QRect &r, const QColor b
 	}
 	
 	const int alpha = 35; // 55, 25
-	p->fillRect(r, alphaBlendColors(QColor(0,0,0),bg , alpha));
+	p->fillRect(r, alphaBlendColors(TQColor(0,0,0),bg , alpha));
 	switch(ds->numGradients) {
 		case 1: {
-			c1 = alphaBlendColors(QColor(0,0,0), c1, alpha);
-			c2 = alphaBlendColors(QColor(0,0,0), c2, alpha);
-			renderGradient(p, QRect(r.x(), top, r.width(), bottom), c1, c2, true);
+			c1 = alphaBlendColors(TQColor(0,0,0), c1, alpha);
+			c2 = alphaBlendColors(TQColor(0,0,0), c2, alpha);
+			renderGradient(p, TQRect(r.x(), top, r.width(), bottom), c1, c2, true);
 			break;
 		}
 		case 2: {
-			c1 = alphaBlendColors(QColor(0,0,0), c1, alpha);
-			c2 = alphaBlendColors(QColor(0,0,0), c2, alpha);
-			c3 = alphaBlendColors(QColor(0,0,0), c3, alpha);
-			c4 = alphaBlendColors(QColor(0,0,0), c4, alpha);
-			renderGradient(p, QRect(r.x(), top, r.width(), bottom), c1, c2, true);
-			renderGradient(p, QRect(r.x(), top2, r.width(), bottom2), c3, c4, true);
+			c1 = alphaBlendColors(TQColor(0,0,0), c1, alpha);
+			c2 = alphaBlendColors(TQColor(0,0,0), c2, alpha);
+			c3 = alphaBlendColors(TQColor(0,0,0), c3, alpha);
+			c4 = alphaBlendColors(TQColor(0,0,0), c4, alpha);
+			renderGradient(p, TQRect(r.x(), top, r.width(), bottom), c1, c2, true);
+			renderGradient(p, TQRect(r.x(), top2, r.width(), bottom2), c3, c4, true);
 		}
 		default:
 			break;
 	}
 }
 
-void DominoStyle::renderGroupBox(QObject *obj, QEvent *ev) {
+void DominoStyle::renderGroupBox(TQObject *obj, TQEvent *ev) {
 	
-	QGroupBox* gb = dynamic_cast<QGroupBox*>(obj);
-	bool paintEvent = ev->type() == QEvent::Paint;
-	QRect r = gb->rect();
+	TQGroupBox* gb = dynamic_cast<TQGroupBox*>(obj);
+	bool paintEvent = ev->type() == TQEvent::Paint;
+	TQRect r = gb->rect();
 	
 	if(gb->isFlat()) {
 		
-		QString title = gb->title();
+		TQString title = gb->title();
 		int titleHeight = gb->fontMetrics().height();
 		int titleWidth = gb->fontMetrics().width(title);
 		if(title.contains("&"))
 			titleWidth -= gb->fontMetrics().width("&");
-		QPainter p(gb);
-// 		p.setPen(qApp->palette().active().background().dark(120));
+		TQPainter p(gb);
+// 		p.setPen(tqApp->palette().active().background().dark(120));
 		p.setPen(alphaBlendColors(gb->paletteForegroundColor(), gb->paletteBackgroundColor(), 40));
 		p.drawLine(0, titleHeight/2-2, r.width()/2-titleWidth/2-4, titleHeight/2-2);
 		p.drawLine(r.width()/2+titleWidth/2+4, titleHeight/2-2, r.width(), titleHeight/2-2);
 		
-		QColorGroup cg = gb->parentWidget()->colorGroup();
-		dominoDrawItem(&p, QRect(r.width()/2-titleWidth/2, -1, r.width(), titleHeight), ShowPrefix, cg, Style_Enabled, 0, title, -1, &cg.foreground(), false);
+		TQColorGroup cg = gb->parentWidget()->colorGroup();
+		dominoDrawItem(&p, TQRect(r.width()/2-titleWidth/2, -1, r.width(), titleHeight), ShowPrefix, cg, Style_Enabled, 0, title, -1, &cg.foreground(), false);
 		p.setPen(cg.foreground());
-		((DominoQGroupBox*)gb)->drawContents(&p);
+		((DominoTQGroupBox*)gb)->drawContents(&p);
 	}
 	else {
-		QString title = gb->title();
+		TQString title = gb->title();
 		int titleHeight = gb->fontMetrics().height();
-		QColor outsideColor = gb->parentWidget() ? gb->parentWidget()->paletteBackgroundColor() : gb->paletteBackgroundColor();
-		QColor insideColor = groupBoxSettings.tintBackground ? getGroupBoxColor(gb) : gb->paletteBackgroundColor();
+		TQColor outsideColor = gb->parentWidget() ? gb->parentWidget()->paletteBackgroundColor() : gb->paletteBackgroundColor();
+		TQColor insideColor = groupBoxSettings.tintBackground ? getGroupBoxColor(gb) : gb->paletteBackgroundColor();
 		bool pixmapExists = groupBoxPixmaps.contains(gb);
 		
 		if(paintEvent && pixmapExists) {
-			QPainter p;
+			TQPainter p;
 			if(!title.isEmpty()) {
 				int titleWidth = gb->fontMetrics().width(title);
 				if(title.contains("&"))
 					titleWidth -= gb->fontMetrics().width("&");
 			
-				QPainter p(groupBoxPixmaps[gb]);
-				QRect titleRect = QRect((r.width()-titleWidth)/2, -1, r.width(), titleHeight);
+				TQPainter p(groupBoxPixmaps[gb]);
+				TQRect titleRect = TQRect((r.width()-titleWidth)/2, -1, r.width(), titleHeight);
 				p.fillRect(titleRect, outsideColor);
 				dominoDrawItem(&p, titleRect, ShowPrefix, gb->colorGroup(), true, 0, title, -1, &gb->foregroundColor(), false);
 				p.end();
 			}
 			// only needed for the case if a disabled groupbox gets disabled for a second time.
-			// Qt3 just changes the palette to disabled without checking if it already is (and removes here the "hidden" background pixmap)
+			// TQt3 just changes the palette to disabled without checking if it already is (and removes here the "hidden" background pixmap)
 			bitBlt(gb, 0, 0, groupBoxPixmaps[gb]);
 			p.begin(gb);
-			((DominoQGroupBox*)gb)->drawContents(&p);
+			((DominoTQGroupBox*)gb)->drawContents(&p);
 			return;
 		}
 		
 		bool isCheckable = gb->isCheckable();
 		int x = r.x();
-		int y = isCheckable ? r.y()+titleHeight+5 : (title.isNull() || title.isEmpty()) ? QMAX(r.y()-1, 0) : r.y()+titleHeight-1;
+		int y = isCheckable ? r.y()+titleHeight+5 : (title.isNull() || title.isEmpty()) ? TQMAX(r.y()-1, 0) : r.y()+titleHeight-1;
 		int w = r.width();
 		int h = r.height();
 		
@@ -7977,25 +7977,25 @@ void DominoStyle::renderGroupBox(QObject *obj, QEvent *ev) {
 // 			return;
 			
 		
-		QPixmap buffer(r.width(), r.height());
+		TQPixmap buffer(r.width(), r.height());
 		
-		QPainter p(&buffer);
-		p.fillRect(QRect(0, 0, w, y), outsideColor);
-		p.fillRect(QRect(x+3, y+3, w-6, h-6-y), insideColor);
+		TQPainter p(&buffer);
+		p.fillRect(TQRect(0, 0, w, y), outsideColor);
+		p.fillRect(TQRect(x+3, y+3, w-6, h-6-y), insideColor);
 		
-		QPixmap* gbPix = 0;
-		if(!(gbPix = QPixmapCache::find(QString::number(outsideColor.pixel(), 16)+QString::number(insideColor.pixel(), 16)+"groupbox"))) {
-			gbPix = new QPixmap(16, 16);
+		TQPixmap* gbPix = 0;
+		if(!(gbPix = TQPixmapCache::find(TQString::number(outsideColor.pixel(), 16)+TQString::number(insideColor.pixel(), 16)+"groupbox"))) {
+			gbPix = new TQPixmap(16, 16);
 			gbPix->fill(outsideColor);
 			
-			QPixmap groupBoxPixMask = qembed_findImage("groupBoxMask");
+			TQPixmap groupBoxPixMask = qembed_findImage("groupBoxMask");
 			groupBoxPixMask.fill(insideColor);
 			bitBlt(gbPix, 0, 0, &groupBoxPixMask);
 					
-			QPixmap groupBoxPix = qembed_findImage("groupBox");
+			TQPixmap groupBoxPix = qembed_findImage("groupBox");
 			bitBlt(gbPix, 0, 0, &groupBoxPix);
 			
-			QPixmapCache::insert(QString::number(outsideColor.pixel(), 16)+QString::number(insideColor.pixel(), 16)+"groupbox", gbPix);
+			TQPixmapCache::insert(TQString::number(outsideColor.pixel(), 16)+TQString::number(insideColor.pixel(), 16)+"groupbox", gbPix);
 		}
 				
 		bitBlt(&buffer, 0, y, gbPix, 0, 0, 8, 8);
@@ -8004,17 +8004,17 @@ void DominoStyle::renderGroupBox(QObject *obj, QEvent *ev) {
 		bitBlt(&buffer, w-8, h-8, gbPix, 8, 8, 8, 8 );
 		
 		// top
-		QColor c1 = alphaBlendColors(QColor(255,255,255), outsideColor, 25);
-		QColor c2 = alphaBlendColors(QColor(0,0,0), insideColor, 70);
-		QColor c3 = alphaBlendColors(QColor(0,0,0), insideColor, 30);
+		TQColor c1 = alphaBlendColors(TQColor(255,255,255), outsideColor, 25);
+		TQColor c2 = alphaBlendColors(TQColor(0,0,0), insideColor, 70);
+		TQColor c3 = alphaBlendColors(TQColor(0,0,0), insideColor, 30);
 		// left + right
-		QColor c4 = alphaBlendColors(QColor(255,255,255), outsideColor, 40);
-		QColor c5 = c3; //alphaBlendColors(QColor(0,0,0), insideColor, 30);
-		QColor c6 = alphaBlendColors(QColor(0,0,0), insideColor, 4);
+		TQColor c4 = alphaBlendColors(TQColor(255,255,255), outsideColor, 40);
+		TQColor c5 = c3; //alphaBlendColors(TQColor(0,0,0), insideColor, 30);
+		TQColor c6 = alphaBlendColors(TQColor(0,0,0), insideColor, 4);
 		// bottom
-		QColor c7 = alphaBlendColors(QColor(6,6,6), insideColor, 25);
-		QColor c8 = alphaBlendColors(QColor(255,255,255), outsideColor, 79);
-		QColor c9 = alphaBlendColors(QColor(255,255,255), outsideColor, 30);
+		TQColor c7 = alphaBlendColors(TQColor(6,6,6), insideColor, 25);
+		TQColor c8 = alphaBlendColors(TQColor(255,255,255), outsideColor, 79);
+		TQColor c9 = alphaBlendColors(TQColor(255,255,255), outsideColor, 30);
 		
 		
 		// top
@@ -8044,7 +8044,7 @@ void DominoStyle::renderGroupBox(QObject *obj, QEvent *ev) {
 		
 		p.end();
 		
-		if(ev->type() == QEvent::Resize)
+		if(ev->type() == TQEvent::Resize)
 			XSetWindowBackgroundPixmap( gb->x11Display(), gb->winId(), buffer.handle());
 		else if(paintEvent) {
 			if(!title.isEmpty()) {
@@ -8053,7 +8053,7 @@ void DominoStyle::renderGroupBox(QObject *obj, QEvent *ev) {
 					titleWidth -= gb->fontMetrics().width("&");
 				
 				p.begin(&buffer);
-				QRect titleRect = QRect((r.width()-titleWidth)/2, -1, r.width(), titleHeight);
+				TQRect titleRect = TQRect((r.width()-titleWidth)/2, -1, r.width(), titleHeight);
 				p.fillRect(titleRect, outsideColor);
 				dominoDrawItem(&p, titleRect, ShowPrefix, gb->colorGroup(), true, 0, title, -1, &gb->foregroundColor(), false);
 				p.end();
@@ -8061,31 +8061,31 @@ void DominoStyle::renderGroupBox(QObject *obj, QEvent *ev) {
 			bitBlt(gb, 0, 0, &buffer);
 			
 			p.begin(gb);
-			((DominoQGroupBox*)gb)->drawContents(&p);
+			((DominoTQGroupBox*)gb)->drawContents(&p);
 		}
 		
 		
 		if(pixmapExists)
 			delete groupBoxPixmaps[gb];
-		groupBoxPixmaps[gb] = new QPixmap(buffer);
+		groupBoxPixmaps[gb] = new TQPixmap(buffer);
 		
 	}
 }
 
 void DominoStyle::spinBoxValueChanged(int value) {
-	QSpinBox* sb = (QSpinBox*)sender();
+	TQSpinBox* sb = (TQSpinBox*)sender();
 	if(spinWidgetDown) {
 		spinWidgetDown = !(value == sb->maxValue() || value == sb->minValue());
 		if(!spinWidgetDown) {
 			// if we repaint directly, the last mousePressEvent wouldn't be down
-			QTimer::singleShot( 200, ((DominoQSpinBox*)sb)->editor()->parentWidget(), SLOT(repaint()) );
+			TQTimer::singleShot( 200, ((DominoTQSpinBox*)sb)->editor()->parentWidget(), SLOT(repaint()) );
 		}
 	}
 }
 
 uint DominoStyle::preMultiplyColor(const uint &c) const {
 	XRenderColor clr;
-	uint  color = c << 8 | qAlpha(c);
+	uint  color = c << 8 | tqAlpha(c);
 
 	uint red = (color >> 24) & 0xff;
 	uint green = (color >> 16) & 0xff;
@@ -8101,11 +8101,11 @@ uint DominoStyle::preMultiplyColor(const uint &c) const {
 	clr.blue = (blue << 8) + blue;
 	clr.alpha = (alpha << 8) + alpha;
 	
-	return qRgba(clr.red, clr.green, clr.blue, clr.alpha);
+	return tqRgba(clr.red, clr.green, clr.blue, clr.alpha);
 }
 
 void DominoStyle::toolPopupPressed() {
-	QToolButton* tb = (QToolButton*)sender();
+	TQToolButton* tb = (TQToolButton*)sender();
 	if(!tb )
 		return;
 	if(tb->popup() && tb->isEnabled() && tb->isDown()) {
diff --git a/domino/domino.h b/domino/domino.h
index 617f111..9142482 100644
--- a/domino/domino.h
+++ b/domino/domino.h
@@ -42,11 +42,11 @@
 #define __DOMINO_H
 
 #include <kstyle.h>
-#include <qintcache.h>
+#include <tqintcache.h>
 #include <ktoolbarbutton.h>
 #include "misc.h"
 #include "data.h"
-#include <qpixmapcache.h>
+#include <tqpixmapcache.h>
 
 
 // #include <X11/extensions/Xrender.h>
@@ -80,11 +80,11 @@ class Rubber;
 
 	struct DSurface {
 		int numGradients;
-		QColor g1Color1;
-		QColor g1Color2;
-		QColor g2Color1;
-		QColor g2Color2;
-		QColor background;
+		TQColor g1Color1;
+		TQColor g1Color2;
+		TQColor g2Color1;
+		TQColor g2Color2;
+		TQColor background;
 		int g1Top;
 		int g1Bottom;
 		int g2Top;
@@ -108,112 +108,112 @@ public:
 		Palette_Widget
 	};
 	
-	void polish(QApplication* app );
-	void polish(QWidget* widget );
-	void polish( QPalette &p );
-	void unPolish(QWidget* widget );
+	void polish(TQApplication* app );
+	void polish(TQWidget* widget );
+	void polish( TQPalette &p );
+	void unPolish(TQWidget* widget );
 	
 	void drawKStylePrimitive(KStylePrimitive kpe,
-				QPainter* p,
-				const QWidget* widget,
-				const QRect &r,
-				const QColorGroup &cg,
+				TQPainter* p,
+				const TQWidget* widget,
+				const TQRect &r,
+				const TQColorGroup &cg,
 				SFlags flags = Style_Default,
-				const QStyleOption& = QStyleOption::Default ) const;
+				const TQStyleOption& = TQStyleOption::Default ) const;
 
 	void drawPrimitive(PrimitiveElement pe,
-				QPainter *p,
-				const QRect &r,
-				const QColorGroup &cg,
+				TQPainter *p,
+				const TQRect &r,
+				const TQColorGroup &cg,
 				SFlags flags = Style_Default,
-				const QStyleOption &opt = QStyleOption::Default ) const;
+				const TQStyleOption &opt = TQStyleOption::Default ) const;
 
 	void drawControl(ControlElement element,
-				QPainter *p,
-				const QWidget *widget,
-				const QRect &r,
-				const QColorGroup &cg,
+				TQPainter *p,
+				const TQWidget *widget,
+				const TQRect &r,
+				const TQColorGroup &cg,
 				SFlags flags = Style_Default,
-				const QStyleOption& = QStyleOption::Default ) const;
+				const TQStyleOption& = TQStyleOption::Default ) const;
 
-	void drawControlMask( ControlElement, QPainter *, const QWidget *, const QRect &, const QStyleOption &) const;
+	void drawControlMask( ControlElement, TQPainter *, const TQWidget *, const TQRect &, const TQStyleOption &) const;
 
 	void drawComplexControl(ComplexControl control,
-				QPainter *p,
-				const QWidget *widget,
-				const QRect &r,
-				const QColorGroup &cg,
+				TQPainter *p,
+				const TQWidget *widget,
+				const TQRect &r,
+				const TQColorGroup &cg,
 				SFlags flags = Style_Default,
 				SCFlags controls = SC_All,
 				SCFlags active = SC_None,
-				const QStyleOption& = QStyleOption::Default ) const;
+				const TQStyleOption& = TQStyleOption::Default ) const;
 
 	int pixelMetric(PixelMetric m,
-				const QWidget *widget = 0 ) const;
+				const TQWidget *widget = 0 ) const;
 
-	QRect subRect(SubRect r,
-				const QWidget *widget ) const;
+	TQRect subRect(SubRect r,
+				const TQWidget *widget ) const;
 
-	QRect querySubControlMetrics(ComplexControl control,
-				const QWidget *widget,
+	TQRect querySubControlMetrics(ComplexControl control,
+				const TQWidget *widget,
 				SubControl subcontrol,
-				const QStyleOption &opt = QStyleOption::Default ) const;
+				const TQStyleOption &opt = TQStyleOption::Default ) const;
 
-	QSize sizeFromContents(QStyle::ContentsType t,
-				const QWidget *w,
-				const QSize &s,
-				const QStyleOption &o) const;
+	TQSize sizeFromContents(TQStyle::ContentsType t,
+				const TQWidget *w,
+				const TQSize &s,
+				const TQStyleOption &o) const;
 
-	int styleHint(StyleHint, const QWidget * = 0,
-				const QStyleOption & = QStyleOption::Default,
-				QStyleHintReturn * = 0 ) const;
+	int styleHint(StyleHint, const TQWidget * = 0,
+				const TQStyleOption & = TQStyleOption::Default,
+				TQStyleHintReturn * = 0 ) const;
 	
 	
-	QPixmap stylePixmap(StylePixmap stylepixmap, const QWidget* widget, const QStyleOption& opt) const;
+	TQPixmap stylePixmap(StylePixmap stylepixmap, const TQWidget* widget, const TQStyleOption& opt) const;
 	
-	void drawItem( QPainter *p, const QRect &r,
-		       int flags, const QColorGroup &g, bool enabled,
-		       const QPixmap *pixmap, const QString &text,
-		       int len = -1, const QColor *penColor = 0) const;
+	void drawItem( TQPainter *p, const TQRect &r,
+		       int flags, const TQColorGroup &g, bool enabled,
+		       const TQPixmap *pixmap, const TQString &text,
+		       int len = -1, const TQColor *penColor = 0) const;
 	
-	void dominoDrawItem( QPainter *p, const QRect &r,
-		       int flags, const QColorGroup &g, bool enabled,
-		       const QPixmap *pixmap, const QString &text,
-		       int len = -1, const QColor *penColor = 0, bool buttonTextEffect = 0 ) const;
+	void dominoDrawItem( TQPainter *p, const TQRect &r,
+		       int flags, const TQColorGroup &g, bool enabled,
+		       const TQPixmap *pixmap, const TQString &text,
+		       int len = -1, const TQColor *penColor = 0, bool buttonTextEffect = 0 ) const;
 	
-	void setDominoButtonPalette(QWidget* widget, PaletteTyp type);
+	void setDominoButtonPalette(TQWidget* widget, PaletteTyp type);
 	
-	virtual void drawFocusIndicator(QPainter *p,
-				const QRect &r,
+	virtual void drawFocusIndicator(TQPainter *p,
+				const TQRect &r,
 				int flags,
-				const QColorGroup cg,
+				const TQColorGroup cg,
 				bool /*enabled*/,
-				const QPixmap*  /*pixmap*/,
-				const QString & text,
+				const TQPixmap*  /*pixmap*/,
+				const TQString & text,
 				int /*len = -1*/,
-				const QColor& highlight = 0,
+				const TQColor& highlight = 0,
 				bool drawLine = true,
 				bool isButton = false) const;
 	
-	QPixmap renderOutlineIcon(const QPixmap* icon) const;
+	TQPixmap renderOutlineIcon(const TQPixmap* icon) const;
 	
-	void renderSurface(QPainter *p,
-			   const QRect &r,
-			   const QColor &backgroundColor,
-			   const QColor &buttonColor,
-			   const QColor &highlightColor,
+	void renderSurface(TQPainter *p,
+			   const TQRect &r,
+			   const TQColor &backgroundColor,
+			   const TQColor &buttonColor,
+			   const TQColor &highlightColor,
 			   const uint flags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom|
 					   Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight|Is_Horizontal) const;
 	
-	inline QWidget::BackgroundOrigin setPixmapOrigin(QWidget::BackgroundOrigin origin);
+	inline TQWidget::BackgroundOrigin setPixmapOrigin(TQWidget::BackgroundOrigin origin);
 	
 	mutable Rubber* rubber;
-	mutable QRect oldRubberRect;
+	mutable TQRect oldRubberRect;
 	mutable bool viewPortPressed;
 	mutable bool ignoreNextFocusRect;
 	uint _argbRubberBandColor;
 	mutable bool compositeManagerRunning;
-	const QWidget* rubberViewPort;
+	const TQWidget* rubberViewPort;
 	
 protected:
 	
@@ -235,25 +235,25 @@ protected:
 
 	struct TextEffectSettings {
 		TextEffect mode;
-		QColor color;
-		QColor buttonColor;
+		TQColor color;
+		TQColor buttonColor;
 		int opacity;
 		int buttonOpacity;
-		QPoint pos;
-		QPoint buttonPos;
+		TQPoint pos;
+		TQPoint buttonPos;
 	};
 
 	struct GroupBoxSettings {
 		bool tintBackground;
 		int brightness;
 		bool customColor;
-		QColor color;
+		TQColor color;
 	};
 
 	struct FocusIndicatorSettings {
-		QColor color;
+		TQColor color;
 		int opacity;
-		QColor buttonColor;
+		TQColor buttonColor;
 		int buttonOpacity;
 		bool drawUnderline;
 		bool indicateFocus;
@@ -308,51 +308,51 @@ protected:
 		PE_ScrollBarSubLine2 = 0xf000001
 	};
 	
-	void renderContour(QPainter *p,
-			const QRect &r,
-			const QColor &backgroundColor,
-			const QColor &contourColor,
+	void renderContour(TQPainter *p,
+			const TQRect &r,
+			const TQColor &backgroundColor,
+			const TQColor &contourColor,
 			const uint flags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom|
 				Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight) const;
 	
-	void renderButtonShadow(QPainter *p, const QRect &r, const uint flags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom|
+	void renderButtonShadow(TQPainter *p, const TQRect &r, const uint flags = Draw_Left|Draw_Right|Draw_Top|Draw_Bottom|
 			Round_UpperLeft|Round_UpperRight|Round_BottomLeft|Round_BottomRight|Is_Horizontal) const;
 	
-	QPixmap* renderLineEditShadow(QWidget* widget, QRect rect, QColor bg, uint flags, bool reverse);
+	TQPixmap* renderLineEditShadow(TQWidget* widget, TQRect rect, TQColor bg, uint flags, bool reverse);
 	
-	inline void renderPixel(QPainter *p,
-		const QPoint &pos,
+	inline void renderPixel(TQPainter *p,
+		const TQPoint &pos,
 		const int alpha,
-		const QColor &color,
-		const QColor &background = QColor(),
+		const TQColor &color,
+		const TQColor &background = TQColor(),
 		bool fullAlphaBlend = true) const;
 
-	void renderButton(QPainter *p,
-			  const QRect &r,
-			  const QColorGroup &g,
+	void renderButton(TQPainter *p,
+			  const TQRect &r,
+			  const TQColorGroup &g,
 			  bool sunken = false,
 			  bool mouseOver = false,
 			  bool horizontal = true,
 			  bool enabled = true,
 			  bool khtmlMode = false) const;
 
-	void renderHeader(QPainter *p,
-			  const QRect &r,
-			  const QColorGroup &g,
+	void renderHeader(TQPainter *p,
+			  const TQRect &r,
+			  const TQColorGroup &g,
 			  bool sunken = false,
 			  bool mouseOver = false,
 			  bool horizontal = true,
 			  bool enabled = true) const;
 
-	void renderGradient(QPainter *p,
-			const QRect &r,
-			const QColor &c1,
-			const QColor &c2,
+	void renderGradient(TQPainter *p,
+			const TQRect &r,
+			const TQColor &c1,
+			const TQColor &c2,
 			bool horizontal = true) const;
 
-	void renderTab(QPainter *p,
-			const QRect &r,
-			const QColorGroup &g,
+	void renderTab(TQPainter *p,
+			const TQRect &r,
+			const TQColorGroup &g,
 			bool mouseOver = false,
 			const bool selected = false,
 			const bool bottom = false,
@@ -371,53 +371,53 @@ protected:
 	DSurface headerSurface;
 	DSurface checkItemSurface;
 	
-	bool eventFilter(QObject *, QEvent *);
-	
-	QString configMode;
-	void removeCachedSbPix(const QColor &color) {
-		QPixmapCache::remove("sHCap"+QString::number(color.pixel(), 16)+"1"+configMode);
-		QPixmapCache::remove("sHCap"+QString::number(color.pixel(), 16)+"0"+configMode);
-		QPixmapCache::remove("sVCap"+QString::number(color.pixel(), 16)+"1"+configMode);
-		QPixmapCache::remove("sVCap"+QString::number(color.pixel(), 16)+"0"+configMode);
-		QPixmapCache::remove(QString::number(color.pixel(), 16)+"sh"+configMode);
-		QPixmapCache::remove(QString::number(color.pixel(), 16)+"sv"+configMode);
-		QPixmapCache::remove(QString::number(color.pixel(), 16)+"ah"+configMode);
-		QPixmapCache::remove(QString::number(color.pixel(), 16)+"av"+configMode);
+	bool eventFilter(TQObject *, TQEvent *);
+	
+	TQString configMode;
+	void removeCachedSbPix(const TQColor &color) {
+		TQPixmapCache::remove("sHCap"+TQString::number(color.pixel(), 16)+"1"+configMode);
+		TQPixmapCache::remove("sHCap"+TQString::number(color.pixel(), 16)+"0"+configMode);
+		TQPixmapCache::remove("sVCap"+TQString::number(color.pixel(), 16)+"1"+configMode);
+		TQPixmapCache::remove("sVCap"+TQString::number(color.pixel(), 16)+"0"+configMode);
+		TQPixmapCache::remove(TQString::number(color.pixel(), 16)+"sh"+configMode);
+		TQPixmapCache::remove(TQString::number(color.pixel(), 16)+"sv"+configMode);
+		TQPixmapCache::remove(TQString::number(color.pixel(), 16)+"ah"+configMode);
+		TQPixmapCache::remove(TQString::number(color.pixel(), 16)+"av"+configMode);
 	};
 	
-	QColor getGroupBoxColor(const QWidget* w) const;
-	QPixmap* createCheckMark(const QColor color) const;
-	QPixmap* createRadioIndicator(const QColor color) const;
-	QPixmap disableIcon(const QPixmap* icon) const;;
+	TQColor getGroupBoxColor(const TQWidget* w) const;
+	TQPixmap* createCheckMark(const TQColor color) const;
+	TQPixmap* createRadioIndicator(const TQColor color) const;
+	TQPixmap disableIcon(const TQPixmap* icon) const;;
 	
-	QWidget* hoverWidget;
+	TQWidget* hoverWidget;
 
-	QPixmap* checkMark;
-	QPixmap* radioIndicator;
-	QPixmap* popupFrame;
-	QPixmap* border1;
+	TQPixmap* checkMark;
+	TQPixmap* radioIndicator;
+	TQPixmap* popupFrame;
+	TQPixmap* border1;
 	mutable bool alphaButtonMode;
 	bool KApplicationMode;
-	QColor _checkMarkColor;
+	TQColor _checkMarkColor;
 	
-	QMap<const QGroupBox*, const QPixmap*> groupBoxPixmaps;
+	TQMap<const TQGroupBox*, const TQPixmap*> groupBoxPixmaps;
 	uint preMultiplyColor(const uint &c) const;
-	QToolButton* popupButton;
-	QTimer* popupTimer;
-	QPoint popupMousePressPos;
+	TQToolButton* popupButton;
+	TQTimer* popupTimer;
+	TQPoint popupMousePressPos;
 
 protected slots:
-	void khtmlWidgetDestroyed(QObject* w);
-	void groupBoxDestroyed(QObject* w);
+	void khtmlWidgetDestroyed(TQObject* w);
+	void groupBoxDestroyed(TQObject* w);
 	
 	//Animation slots.
 	void updateProgressPos();
 	void updateScrollPos(); // smoothscroll
 	
-	void progressBarDestroyed(QObject* bar);
-	inline QColor dGetColor(const QColor &color, const int value) const;
-	inline QColor lightenColor(const QColor &color, const int value) const;
-	inline QColor darkenColor(const QColor &color, const int value) const;
+	void progressBarDestroyed(TQObject* bar);
+	inline TQColor dGetColor(const TQColor &color, const int value) const;
+	inline TQColor lightenColor(const TQColor &color, const int value) const;
+	inline TQColor darkenColor(const TQColor &color, const int value) const;
 	void updateTabWidgetFrame();
 	void spinBoxValueChanged(int);
 	void toolPopupPressed();
@@ -439,12 +439,12 @@ private:
 	bool _drawTriangularExpander;
 	bool _customCheckMarkColor;
 	bool _smoothScrolling;
-	QColor _toolTipColor;
+	TQColor _toolTipColor;
 	int _buttonHeightAdjustment;
 	bool _customPopupMenuColor;
-	QColor _popupMenuColor;
+	TQColor _popupMenuColor;
 	bool _customSelMenuItemColor;
-	QColor _selMenuItemColor;
+	TQColor _selMenuItemColor;
 	bool _drawPopupMenuGradient;
 	bool _indentPopupMenuItems;
 	bool _centerTabs;
@@ -465,16 +465,16 @@ private:
 	// smoothscrolling
 	int scrollDistance;
 	bool scrollVertical;
-	QScrollView* scrollWidget;
-	QTimer* scrollTimer;
+	TQScrollView* scrollWidget;
+	TQTimer* scrollTimer;
 	
 	bool hoveredToolBoxTab;
 	
 	// track khtml widgets.
-	QMap<const QWidget*,bool> khtmlWidgets;
+	TQMap<const TQWidget*,bool> khtmlWidgets;
 	
 	//Animation support.
-	QMap<QWidget*, int> progAnimWidgets;
+	TQMap<TQWidget*, int> progAnimWidgets;
 
 	// pixmap cache.
 	enum CacheEntryType {
@@ -488,14 +488,14 @@ private:
 		CacheEntryType type;
 		int width;
 		int height;
-		QRgb c1Rgb;
-		QRgb c2Rgb;
+		TQRgb c1Rgb;
+		TQRgb c2Rgb;
 		bool horizontal;
 	
-		QPixmap* pixmap;
+		TQPixmap* pixmap;
 	
-		CacheEntry(CacheEntryType t, int w, int h, QRgb c1, QRgb c2 = 0,
-			bool hor = false, QPixmap* p = 0 ):
+		CacheEntry(CacheEntryType t, int w, int h, TQRgb c1, TQRgb c2 = 0,
+			bool hor = false, TQPixmap* p = 0 ):
 			type(t), width(w), height(h), c1Rgb(c1), c2Rgb(c2), horizontal(hor), pixmap(p)
 		{}
 	
@@ -506,7 +506,7 @@ private:
 	
 		int key()
 		{
-			// create an int key from the properties which is used to refer to entries in the QIntCache.
+			// create an int key from the properties which is used to refer to entries in the TQIntCache.
 			// the result may not be 100% correct as we don't have so much space in one integer -- use
 			// == operator after find to make sure we got the right one. :)
 			return horizontal ^ (type<<1) ^ (width<<5) ^ (height<<10) ^ (c1Rgb<<19) ^ (c2Rgb<<22);
@@ -521,27 +521,27 @@ private:
 				(c1Rgb == other.c1Rgb) &&
 				(horizontal = other.horizontal);
 // 				   if(!match) {
-// 					   qDebug("operator ==: CacheEntries don't match!");
-// 					   qDebug("width: %d\t\tother width: %d", width, other.width);
-// 					   qDebug("height: %d\t\tother height: %d", height, other.height);
-// 					   qDebug("fgRgb: %d\t\tother fgRgb: %d", fgRgb, other.fgRgb);
-// 					   qDebug("bgRgb: %d\t\tother bgRgb: %d", bgRgb, other.bgRgb);
-// 					   qDebug("surfaceFlags: %d\t\tother surfaceFlags: %d", surfaceFlags, other.surfaceFlags);
+// 					   tqDebug("operator ==: CacheEntries don't match!");
+// 					   tqDebug("width: %d\t\tother width: %d", width, other.width);
+// 					   tqDebug("height: %d\t\tother height: %d", height, other.height);
+// 					   tqDebug("fgRgb: %d\t\tother fgRgb: %d", fgRgb, other.fgRgb);
+// 					   tqDebug("bgRgb: %d\t\tother bgRgb: %d", bgRgb, other.bgRgb);
+// 					   tqDebug("surfaceFlags: %d\t\tother surfaceFlags: %d", surfaceFlags, other.surfaceFlags);
 // 				   }
 			return match;
 		}
 	};
-	QIntCache<CacheEntry> *pixmapCache;
+	TQIntCache<CacheEntry> *pixmapCache;
 
 	// For KPE_ListViewBranch
-	mutable QBitmap *verticalLine;
-	mutable QBitmap *horizontalLine;
+	mutable TQBitmap *verticalLine;
+	mutable TQBitmap *horizontalLine;
 	
 	// For progress bar animation
-	QTimer *animationTimer;
+	TQTimer *animationTimer;
 	
-	void renderTabSeparator(QPainter *p, const QRect &r, const QColor buttonColor, bool tabAbove) const;
-	void renderGroupBox(QObject *obj, QEvent *ev);
+	void renderTabSeparator(TQPainter *p, const TQRect &r, const TQColor buttonColor, bool tabAbove) const;
+	void renderGroupBox(TQObject *obj, TQEvent *ev);
 };
 
 
@@ -565,22 +565,22 @@ class ButtonContour
 		int created[num_types][num_states];
 		int shadowCreated[num_states];
 		
-		QColor contour[num_states];
+		TQColor contour[num_states];
 		uint c1[num_types][num_states]; // top shadow
 		uint c2[num_types][num_states]; // outer ring
 		uint c3[num_types][num_states]; // inner ring
 		uint c4[num_types][num_states]; // bottom first shadow line
 		uint c5[num_types][num_states]; // bottom second shadow line
 		uint c6[num_types][num_states]; // first left shadow line
-		QPixmap* btnEdges[num_types][num_states];
-		QPixmap* btnVLines[num_types][num_states];
-		QPixmap* btnHLines[num_types][num_states];
+		TQPixmap* btnEdges[num_types][num_states];
+		TQPixmap* btnVLines[num_types][num_states];
+		TQPixmap* btnHLines[num_types][num_states];
 		
 		// for sunken type and sunken flat buttons
-		QPixmap* buttonShadowRectangular[num_states];
-		QPixmap* buttonShadowRound [num_states];
-		QPixmap* buttonShadowHlines[num_states];
-		QPixmap* buttonShadowVlines[num_states];
+		TQPixmap* buttonShadowRectangular[num_states];
+		TQPixmap* buttonShadowRound [num_states];
+		TQPixmap* buttonShadowHlines[num_states];
+		TQPixmap* buttonShadowVlines[num_states];
 		
 		
 		bool alphaMode() {
@@ -604,16 +604,16 @@ class ButtonContour
 		uint color6() {
 			return c6[type][state];
 		}
-		QColor contourColor(int t) {
+		TQColor contourColor(int t) {
 			return contour[t];
 		}
-		QPixmap* buttonEdges() {
+		TQPixmap* buttonEdges() {
 			return btnEdges[type][state];
 		}
-		QPixmap* buttonVLines() {
+		TQPixmap* buttonVLines() {
 			return btnVLines[type][state];
 		}
-		QPixmap* buttonHLines() {
+		TQPixmap* buttonHLines() {
 			return btnHLines[type][state];
 		}
 		void setType(ContourType t = Contour_Sunken) {
@@ -631,20 +631,20 @@ class ButtonContour
 			state = s;
 			createPixmaps(type, state);
 		}
-		void setColor(ContourState s, QColor color) {
+		void setColor(ContourState s, TQColor color) {
 			contour[s] = color;
 			
 			uint c2_tmp;
 			uint c3_tmp;
 			if(defaultType == Contour_Sunken /*|| defaultType == Contour_Simple*/) {
-				c2_tmp = qRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 218);
-				c3_tmp = qRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 35);
+				c2_tmp = tqRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 218);
+				c3_tmp = tqRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 35);
 			}
 			else {
-				c2_tmp = qRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 203);
+				c2_tmp = tqRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 203);
 				
-				QColor whiteColor(qRgba(Qt::white.red(), Qt::white.green(), Qt::white.blue(), 34));
-				QColor blackColor(qRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 35));
+				TQColor whiteColor(tqRgba(TQt::white.red(), TQt::white.green(), TQt::white.blue(), 34));
+				TQColor blackColor(tqRgba(contour[s].red(), contour[s].green(), contour[s].blue(), 35));
 				
 				c3_tmp = blendColors(whiteColor, blackColor).rgb();
 			}
@@ -669,16 +669,16 @@ class ButtonContour
 			alpha_mode = false;
 		}
 		
-		QPixmap* shadowRound() {
+		TQPixmap* shadowRound() {
 			return buttonShadowRound[state];
 		}
-		QPixmap* shadowRectangular() {
+		TQPixmap* shadowRectangular() {
 			return buttonShadowRectangular[state];
 		}
-		QPixmap* shadowHLines() {
+		TQPixmap* shadowHLines() {
 			return buttonShadowHlines[state];
 		}
-		QPixmap* shadowVLines() {
+		TQPixmap* shadowVLines() {
 			return buttonShadowVlines[state];
 		}
 		
@@ -690,11 +690,11 @@ class ButtonContour
 			// for pressed sunken buttons + pressed KMultiTabbarTabs
 			if(drawButtonSunkenShadow && !shadowCreated[state]) {
 				
-				QColor shadowColor = alphaBlendColors(Qt::black, contour[state], 120);
-				buttonShadowRectangular[state] = new QPixmap(tintImage(qembed_findImage("btnPressedShadowRectangular"), shadowColor));
-				buttonShadowRound[state] = new QPixmap(tintImage(qembed_findImage("btnPressedShadowRound"), shadowColor));
-				buttonShadowHlines[state] = new QPixmap(tintImage(qembed_findImage("btnPressedShadowHLines"), shadowColor));
-				buttonShadowVlines[state] = new QPixmap(tintImage(qembed_findImage("btnPressedShadowVLines"), shadowColor));
+				TQColor shadowColor = alphaBlendColors(TQt::black, contour[state], 120);
+				buttonShadowRectangular[state] = new TQPixmap(tintImage(qembed_findImage("btnPressedShadowRectangular"), shadowColor));
+				buttonShadowRound[state] = new TQPixmap(tintImage(qembed_findImage("btnPressedShadowRound"), shadowColor));
+				buttonShadowHlines[state] = new TQPixmap(tintImage(qembed_findImage("btnPressedShadowHLines"), shadowColor));
+				buttonShadowVlines[state] = new TQPixmap(tintImage(qembed_findImage("btnPressedShadowVLines"), shadowColor));
 				shadowCreated[state] = 1;
 			}
 			
@@ -702,9 +702,9 @@ class ButtonContour
 			if(created[type][state])
 				return;
 			
-			QImage btnVLines_img;
-			QImage btnHLines_img;
-			QImage btnShadow_img;
+			TQImage btnVLines_img;
+			TQImage btnHLines_img;
+			TQImage btnShadow_img;
 			
 			switch(type) {
 				case Contour_Simple: // now pressed raised!
@@ -734,14 +734,14 @@ class ButtonContour
 					break;
 			}
 			
-			btnEdges[type][state] = new QPixmap(btnShadow_img);
-			btnVLines[type][state] = new QPixmap(btnVLines_img);
-			btnHLines[type][state] = new QPixmap(btnHLines_img);
+			btnEdges[type][state] = new TQPixmap(btnShadow_img);
+			btnVLines[type][state] = new TQPixmap(btnVLines_img);
+			btnHLines[type][state] = new TQPixmap(btnHLines_img);
 			created[type][state] = 1;
 		}
 };
 
-class RubberWidget : public QWidget
+class RubberWidget : public TQWidget
 {
 	public:
 		RubberWidget(Window window);
@@ -763,7 +763,7 @@ class Rubber
 		
 		RubberWidget* parent;
 		RubberWidget* rubber;
-		QRegion mask;
+		TQRegion mask;
 		uint color;
 		
 		void destroy() {
@@ -775,46 +775,46 @@ class Rubber
 				rubber = 0;
 			}
 		}
-		void create(QRect& r, QRegion& mask);
-		void updateMask(QRegion& mask);
+		void create(TQRect& r, TQRegion& mask);
+		void updateMask(TQRegion& mask);
 };
 
 
 // DominoXXX classes to access protected (or private...) members
-class DominoQGroupBox : public QGroupBox
+class DominoTQGroupBox : public TQGroupBox
 {
 	friend class DominoStyle;
 	public:
-		DominoQGroupBox( QWidget* parent=0, const char* name=0 )
-	: QGroupBox( parent, name ) {}
+		DominoTQGroupBox( TQWidget* parent=0, const char* name=0 )
+	: TQGroupBox( parent, name ) {}
 };
 
-class DominoQWidget : public QWidget
+class DominoTQWidget : public TQWidget
 {
 	friend class DominoStyleConfig;
 	friend class DominoStyle;
 	public:
-		DominoQWidget( QWidget* parent=0, const char* name=0 )
-	: QWidget( parent, name ) {}
+		DominoTQWidget( TQWidget* parent=0, const char* name=0 )
+	: TQWidget( parent, name ) {}
 	
 };
 
-class DominoQFrame : public QFrame
+class DominoTQFrame : public TQFrame
 {
 	friend class DominoStyle;
 	public:
-		DominoQFrame( QFrame* parent=0, const char* name=0 )
-	: QFrame( parent, name ) {}
+		DominoTQFrame( TQFrame* parent=0, const char* name=0 )
+	: TQFrame( parent, name ) {}
 };
 
-// QWhatsThis
-class DominoQWhatsThat : public QWidget
+// TQWhatsThis
+class DominoTQWhatsThat : public TQWidget
 {
 	friend class DominoStyle;
 	public:
-		DominoQWhatsThat(): QWidget() {}
+		DominoTQWhatsThat(): TQWidget() {}
 	private:
-		QString text;
+		TQString text;
 };
 
 class DominoKToolBarButton : public KToolBarButton
@@ -824,42 +824,42 @@ class DominoKToolBarButton : public KToolBarButton
 		DominoKToolBarButton(): KToolBarButton() {}
 };
 
-class DominoQListBoxItem : public QListBoxItem
+class DominoTQListBoxItem : public TQListBoxItem
 {
 	friend class DominoStyle;
 	public:
-		DominoQListBoxItem(): QListBoxItem() {}
+		DominoTQListBoxItem(): TQListBoxItem() {}
 };
 
-class DominoQTabWidget : public QTabWidget
+class DominoTQTabWidget : public TQTabWidget
 {
 	friend class DominoStyleConfig;
 	friend class DominoStyle;
 	public:
-		DominoQTabWidget( QWidget* parent=0, const char* name=0 )
-	: QTabWidget( parent, name ) {}
+		DominoTQTabWidget( TQWidget* parent=0, const char* name=0 )
+	: TQTabWidget( parent, name ) {}
 };
 
-class DominoQSpinBox : public QSpinBox
+class DominoTQSpinBox : public TQSpinBox
 {
 	friend class DominoStyle;
 	public:
-		DominoQSpinBox( QFrame* parent=0, const char* name=0 )
-	: QSpinBox( parent, name ) {}
+		DominoTQSpinBox( TQFrame* parent=0, const char* name=0 )
+	: TQSpinBox( parent, name ) {}
 };
 
-class DominoQPixmap : public QPixmap
+class DominoTQPixmap : public TQPixmap
 {
 	friend class DominoStyle;
 	public:
-		DominoQPixmap( int w, int h,  int depth = -1) : QPixmap(w, h, depth) {}
+		DominoTQPixmap( int w, int h,  int depth = -1) : TQPixmap(w, h, depth) {}
 };
 
-class DominoQButton : public QButton
+class DominoTQButton : public TQButton
 {
 	friend class DominoStyle;
 	public:
-		DominoQButton(): QButton() {}
+		DominoTQButton(): TQButton() {}
 };
 
 #endif // __DOMINO_H
diff --git a/domino/eventfilter.cpp b/domino/eventfilter.cpp
index a3dce1c..69be358 100644
--- a/domino/eventfilter.cpp
+++ b/domino/eventfilter.cpp
@@ -16,22 +16,22 @@
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
-bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
+bool DominoStyle::eventFilter(TQObject *obj, TQEvent *ev)
 {
 	
-// 	qDebug("className:   %s  --  name:  %s", obj->className(), obj->name());
+// 	tqDebug("className:   %s  --  name:  %s", obj->className(), obj->name());
 	
-	if(dynamic_cast<QComboBox*>(obj)) {
+	if(dynamic_cast<TQComboBox*>(obj)) {
 		
 		switch(ev->type()) {
-			case QEvent::Paint: {
+			case TQEvent::Paint: {
 				
-				QComboBox* cb = dynamic_cast<QComboBox*>(obj);
+				TQComboBox* cb = dynamic_cast<TQComboBox*>(obj);
 				bool khtmlWidget = khtmlWidgets.contains(cb);
-				const QColorGroup & g = cb->colorGroup();
+				const TQColorGroup & g = cb->colorGroup();
 				
-				QPixmap buffer;
-				QPainter p;
+				TQPixmap buffer;
+				TQPainter p;
 				if(khtmlWidget)
 					p.begin(cb);
 				else {
@@ -44,30 +44,30 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				
 				if(!khtmlWidget && cb->parentWidget() && cb->parentWidget()->backgroundPixmap()){
 					
-					QPoint point = cb->backgroundOffset();
+					TQPoint point = cb->backgroundOffset();
 					p.drawTiledPixmap( 0, 0, cb->width(), cb->height(),
 							*cb->parentWidget()->backgroundPixmap(),
 							point.x(), point.y() );
 				}
 				
 				
-				QStyle::SFlags flags = QStyle::Style_Default;
+				TQStyle::SFlags flags = TQStyle::Style_Default;
 				if (cb->isEnabled())
-					flags |= QStyle::Style_Enabled;
+					flags |= TQStyle::Style_Enabled;
 				if (cb->hasFocus())
-					flags |= QStyle::Style_HasFocus;
+					flags |= TQStyle::Style_HasFocus;
 				
 				if(!cb->listBox()) {
 					
-					drawComplexControl( QStyle::CC_ComboBox, &p, cb, cb->rect(), g,
-							flags, (uint)QStyle::SC_All, /*(cb->arrowDown ? */QStyle::SC_ComboBoxArrow /*: QStyle::SC_None )*/);
+					drawComplexControl( TQStyle::CC_ComboBox, &p, cb, cb->rect(), g,
+							flags, (uint)TQStyle::SC_All, /*(cb->arrowDown ? */TQStyle::SC_ComboBoxArrow /*: TQStyle::SC_None )*/);
 					
-					QRect re = querySubControlMetrics( QStyle::CC_ComboBox, cb, QStyle::SC_ComboBoxEditField );
-					re = QStyle::visualRect(re, cb);
+					TQRect re = querySubControlMetrics( TQStyle::CC_ComboBox, cb, TQStyle::SC_ComboBoxEditField );
+					re = TQStyle::visualRect(re, cb);
 					p.setClipRect( re );
 					
-					QString str = 0;
-					const QPixmap *pix = 0;
+					TQString str = 0;
+					const TQPixmap *pix = 0;
 					if(cb->count() > 0) {
 						str = cb->text(cb->currentItem());
 						cb->pixmap(cb->currentItem());
@@ -75,7 +75,7 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					if ( !str.isNull() ) {
 // 						p.save();
 // 						p.setFont(cb->font());
-// 						QFontMetrics fm(cb->font());
+// 						TQFontMetrics fm(cb->font());
 // 						int x = re.x(), y = re.y() + fm.ascent();
 // 						if( pix )
 // 							x += pix->width() + 5;
@@ -87,22 +87,22 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					}
 					if ( pix ) {
 						p.fillRect( re.x(), re.y(), pix->width() + 4, re.height(),
-								cb->colorGroup().brush( QColorGroup::Base ) );
+								cb->colorGroup().brush( TQColorGroup::Base ) );
 						p.drawPixmap( re.x() + 2, re.y() +
 								( re.height() - pix->height() ) / 2, *pix );
 					}
 				}
 				else {
-					drawComplexControl( QStyle::CC_ComboBox, &p, cb, cb->rect(), g,
-							flags, (uint)QStyle::SC_All, /*(d->arrowDown ? */QStyle::SC_ComboBoxArrow/* : QStyle::SC_None )*/);
-					QRect re = querySubControlMetrics( QStyle::CC_ComboBox, cb, QStyle::SC_ComboBoxEditField );
-					re = QStyle::visualRect(re, cb);
+					drawComplexControl( TQStyle::CC_ComboBox, &p, cb, cb->rect(), g,
+							flags, (uint)TQStyle::SC_All, /*(d->arrowDown ? */TQStyle::SC_ComboBoxArrow/* : TQStyle::SC_None )*/);
+					TQRect re = querySubControlMetrics( TQStyle::CC_ComboBox, cb, TQStyle::SC_ComboBoxEditField );
+					re = TQStyle::visualRect(re, cb);
 					p.setClipRect( re );
 					
 					if ( !cb->editable() ) {
 						
-						QString str = 0;
-						const QPixmap *pix = 0;
+						TQString str = 0;
+						const TQPixmap *pix = 0;
 						if(cb->count() > 0) {
 							str = cb->text(cb->currentItem());
 							pix = cb->pixmap(cb->currentItem());
@@ -110,16 +110,16 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 						
 						re.addCoords(+2, 0, 0, -1);
 						if(pix) {
-							drawItem( &p, QRect(re.left()+1, re.top(), re.width(), re.height()-1), AlignLeft|AlignVCenter, cb->colorGroup(),
+							drawItem( &p, TQRect(re.left()+1, re.top(), re.width(), re.height()-1), AlignLeft|AlignVCenter, cb->colorGroup(),
 									cb->isEnabled(), pix, 0, -1, &cb->colorGroup().buttonText() );
 							re.setX(re.x()+pix->width()+2);
 						}
 						if(!str.isNull()) {
-							dominoDrawItem( &p, QRect(re.left(), re.top(), re.width(), re.height()), AlignLeft|AlignVCenter, cb->colorGroup(),
+							dominoDrawItem( &p, TQRect(re.left(), re.top(), re.width(), re.height()), AlignLeft|AlignVCenter, cb->colorGroup(),
 									cb->isEnabled(), 0, str, -1, &cb->colorGroup().buttonText(), textEffectSettings.mode > 0 ? 1 : 0 );
 						}
 						else if(!pix) {
-							DominoQListBoxItem * item = (DominoQListBoxItem*)cb->listBox()->item( cb->currentItem() );
+							DominoTQListBoxItem * item = (DominoTQListBoxItem*)cb->listBox()->item( cb->currentItem() );
 							if ( item ) {
 								int itemh = item->height( cb->listBox() );
 								p.translate( re.x(), re.y() +(re.height()- itemh)/2);
@@ -129,22 +129,22 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					}
 					else if ( cb->listBox() && cb->listBox()->item( cb->currentItem() ) ) {
 						
-						QListBoxItem * item = cb->listBox()->item( cb->currentItem() );
-						const QPixmap *pix = item->pixmap();
+						TQListBoxItem * item = cb->listBox()->item( cb->currentItem() );
+						const TQPixmap *pix = item->pixmap();
 						if ( pix ) {
 							if(re.width() < pix->width())
 								return true;
-							QColor color = cb->isEnabled() ? cb->lineEdit()->paletteBackgroundColor() : cb->lineEdit()->palette().active().background();
-							QPixmap* shadowPix = renderLineEditShadow(cb, QRect(0, 0, pix->width() + 3, re.height()), color, Draw_Left, QApplication::reverseLayout());
+							TQColor color = cb->isEnabled() ? cb->lineEdit()->paletteBackgroundColor() : cb->lineEdit()->palette().active().background();
+							TQPixmap* shadowPix = renderLineEditShadow(cb, TQRect(0, 0, pix->width() + 3, re.height()), color, Draw_Left, TQApplication::reverseLayout());
 	
-							if(!QApplication::reverseLayout()) {
+							if(!TQApplication::reverseLayout()) {
 								int x = re.x();
 								int y = re.y();
 								int w = pix->width() + 4;
 								int h = re.height()+re.y();
 								
-								QRegion mask(x+3, y, w+3, h);
-								mask += QRegion(x, y+3, 3, h-9);
+								TQRegion mask(x+3, y, w+3, h);
+								mask += TQRegion(x, y+3, 3, h-9);
 								p.setClipRegion(mask);
 							}
 							bitBlt(shadowPix, 3, ( shadowPix->height() - pix->height() ) / 2, pix);
@@ -162,33 +162,33 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				return true;
 				
 			}
-			case QEvent::Enter: {
-				QButton* btn = static_cast<QButton*>(obj);
+			case TQEvent::Enter: {
+				TQButton* btn = static_cast<TQButton*>(obj);
 				if(btn->isEnabled()) {
 					hoverWidget = btn;
 					btn->repaint(false);
 				}
 				return false;
 			}
-			case QEvent::Leave: {
-				QButton* btn = static_cast<QButton*>(obj);
+			case TQEvent::Leave: {
+				TQButton* btn = static_cast<TQButton*>(obj);
 				if(btn->isEnabled()) {
 					hoverWidget = 0;
 					btn->repaint(false);
 				}
 				return false;
 			}
-			case QEvent::PaletteChange: {
-				setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Widget);
+			case TQEvent::PaletteChange: {
+				setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Widget);
 				return true;
 			}
-			case QEvent::ParentPaletteChange: {
-				setDominoButtonPalette(dynamic_cast<QWidget*>(obj), Palette_Parent);
+			case TQEvent::ParentPaletteChange: {
+				setDominoButtonPalette(dynamic_cast<TQWidget*>(obj), Palette_Parent);
 				return false;
 			}
-			case QEvent::ApplicationPaletteChange: {
-				if(!khtmlWidgets.contains(static_cast<QWidget*>(obj)))
-					setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Application);
+			case TQEvent::ApplicationPaletteChange: {
+				if(!khtmlWidgets.contains(static_cast<TQWidget*>(obj)))
+					setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Application);
 				return true;
 			}
 			default:
@@ -197,17 +197,17 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	}
 
 	// don't repaint the combobox if the mouse moves over the listbox.
-	if(dynamic_cast<QListBox*>(obj) && dynamic_cast<QComboBox*>(obj->parent())) {
+	if(dynamic_cast<TQListBox*>(obj) && dynamic_cast<TQComboBox*>(obj->parent())) {
 		
-		if(dynamic_cast<QComboBox*>(obj->parent())) {
-			if(ev->type() == QEvent::Show) {
-				QComboBox* cb = dynamic_cast<QComboBox*>(obj->parent());
+		if(dynamic_cast<TQComboBox*>(obj->parent())) {
+			if(ev->type() == TQEvent::Show) {
+				TQComboBox* cb = dynamic_cast<TQComboBox*>(obj->parent());
 				cb->repaint(false);
 				cb->setUpdatesEnabled(false);
 				return false;
 			}
-			if(ev->type() == QEvent::Hide) {
-				QComboBox* cb = dynamic_cast<QComboBox*>(obj->parent());
+			if(ev->type() == TQEvent::Hide) {
+				TQComboBox* cb = dynamic_cast<TQComboBox*>(obj->parent());
 				cb->setUpdatesEnabled(true);
 				cb->repaint(false);
 				return false;
@@ -216,13 +216,13 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		// don't return here
 	}
 	
-	if (dynamic_cast<QLineEdit*>(obj) || (dynamic_cast<QFrame*>(obj) && dynamic_cast<QFrame*>(obj)->frameShape() == QFrame::LineEditPanel) || obj->isA("QDateTimeEditor")) {
+	if (dynamic_cast<TQLineEdit*>(obj) || (dynamic_cast<TQFrame*>(obj) && dynamic_cast<TQFrame*>(obj)->frameShape() == TQFrame::LineEditPanel) || obj->isA("TQDateTimeEditor")) {
 		
-		QWidget* lineEdit = dynamic_cast<QWidget*>(obj);
+		TQWidget* lineEdit = dynamic_cast<TQWidget*>(obj);
 		bool khtmlMode = khtmlWidgets.contains(lineEdit);
-		bool isLineEdit = dynamic_cast<QLineEdit*>(obj);
-		bool isReadOnly = isLineEdit && dynamic_cast<QLineEdit*>(obj)->isReadOnly();
-		QFrame* frame = dynamic_cast<QFrame*>(obj);
+		bool isLineEdit = dynamic_cast<TQLineEdit*>(obj);
+		bool isReadOnly = isLineEdit && dynamic_cast<TQLineEdit*>(obj)->isReadOnly();
+		TQFrame* frame = dynamic_cast<TQFrame*>(obj);
 		if((isReadOnly || khtmlMode) && frame->frameWidth() <= 0) {
 			return false;
 		}
@@ -233,36 +233,36 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		bool isDateTimeEditor = false;
 		bool hasPixmap = false;
 		bool noFrame = false;
-		QRect r = lineEdit->rect();
+		TQRect r = lineEdit->rect();
 		
-		if(dynamic_cast<QComboBox*>(lineEdit->parentWidget())) {
+		if(dynamic_cast<TQComboBox*>(lineEdit->parentWidget())) {
 			isComboBox = true;
-			QComboBox* cb = dynamic_cast<QComboBox*>(lineEdit->parentWidget());
+			TQComboBox* cb = dynamic_cast<TQComboBox*>(lineEdit->parentWidget());
 			if(cb->count() > 0 && cb->pixmap(cb->currentItem()))
 				hasPixmap = true;
 		}
-		else if(obj->isA("QDateTimeEditor"))
+		else if(obj->isA("TQDateTimeEditor"))
 			isDateTimeEditor = true;
-		else if(dynamic_cast<QSpinWidget*>(lineEdit->parentWidget()))
+		else if(dynamic_cast<TQSpinWidget*>(lineEdit->parentWidget()))
 			isSpinWidget = true;
-		else if(isLineEdit && frame->frameShape() == QFrame::NoFrame)
+		else if(isLineEdit && frame->frameShape() == TQFrame::NoFrame)
 			noFrame = true;
 		
-// 		if(isSpinWidget && !isComboBox && frame->frameShape() == QFrame::NoFrame)
+// 		if(isSpinWidget && !isComboBox && frame->frameShape() == TQFrame::NoFrame)
 // 			return false;
 		
 		int x, y, w, h;
 		r.rect(&x, &y, &w, &h);
 
 		switch(ev->type()) {
-			case QEvent::Show:
+			case TQEvent::Show:
 				if(khtmlMode)
 					return true;
-			case QEvent::Resize: {
+			case TQEvent::Resize: {
 				if(noFrame) return false;
 				
 				if(isLineEdit) {
-					QRect frameRect(r.x()+1, r.y(), r.width()-1, r.height());
+					TQRect frameRect(r.x()+1, r.y(), r.width()-1, r.height());
 					if(frame->frameRect() != frameRect)
 						frame->setFrameRect(frameRect);
 					
@@ -270,14 +270,14 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				
 				if(isSpinWidget || isComboBox) {
 					
-					if(!hasPixmap && !QApplication::reverseLayout()) {
-						QRegion mask(x+3, y, w-3, h);
-						mask += QRegion(x, y+3, 3, h-6);
+					if(!hasPixmap && !TQApplication::reverseLayout()) {
+						TQRegion mask(x+3, y, w-3, h);
+						mask += TQRegion(x, y+3, 3, h-6);
 						lineEdit->setMask(mask);
 					}
-					else if(QApplication::reverseLayout()) {
-						QRegion mask(x, y, w-3, h);
-						mask += QRegion(w-3, y+3, 3, h-6);
+					else if(TQApplication::reverseLayout()) {
+						TQRegion mask(x, y, w-3, h);
+						mask += TQRegion(w-3, y+3, 3, h-6);
 						lineEdit->setMask(mask);
 					}
 					else if(isComboBox)
@@ -285,16 +285,16 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				}
 				else if(isDateTimeEditor) {
 					
-					if(!QApplication::reverseLayout()) {
-						QRegion mask(x+2, y, w-2, h);
-						mask += QRegion(x+1, y+1, 1, h-2);
-						mask += QRegion(x, y+2, 1, h-4);
+					if(!TQApplication::reverseLayout()) {
+						TQRegion mask(x+2, y, w-2, h);
+						mask += TQRegion(x+1, y+1, 1, h-2);
+						mask += TQRegion(x, y+2, 1, h-4);
 						lineEdit->setMask(mask);
 					}
 					else {
-						QRegion mask(x, y, w-2, h);
-						mask += QRegion(w-2, y+1, 1, h-2);
-						mask += QRegion(w-1, y+2, 1, h-4);
+						TQRegion mask(x, y, w-2, h);
+						mask += TQRegion(w-2, y+1, 1, h-2);
+						mask += TQRegion(w-1, y+2, 1, h-4);
 						lineEdit->setMask(mask);
 					}
 				}
@@ -305,27 +305,27 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				}
 				return false;
 			}
-			case QEvent::Paint: {
+			case TQEvent::Paint: {
 				
 				if(noFrame)
 					return false;
 				
-				const QColorGroup cg = lineEdit->colorGroup();
-				const QColor bg = !isEnabled ? cg.background() : lineEdit->paletteBackgroundColor();
-				QPainter p;
+				const TQColorGroup cg = lineEdit->colorGroup();
+				const TQColor bg = !isEnabled ? cg.background() : lineEdit->paletteBackgroundColor();
+				TQPainter p;
 				
 				if(isSpinWidget || isComboBox || isDateTimeEditor) {
 					
-					 // QDateTimeEditor doesn't respect background pixmaps :(
+					 // TQDateTimeEditor doesn't respect background pixmaps :(
 					if(w <1 || h <1 || isDateTimeEditor)
 						return false;
 					
 					uint flags = hasPixmap ? Draw_Right : Draw_Left|Draw_Right;
-					QPixmap* lineEditPix = renderLineEditShadow(lineEdit, lineEdit->rect(), bg, flags, QApplication::reverseLayout());
+					TQPixmap* lineEditPix = renderLineEditShadow(lineEdit, lineEdit->rect(), bg, flags, TQApplication::reverseLayout());
 					lineEdit->setUpdatesEnabled(false);
 					lineEdit->setErasePixmap(*lineEditPix);
 					// update the gap which resulted from the altered frame rect...
-					lineEdit->erase(QRect(x, y, 1, h));
+					lineEdit->erase(TQRect(x, y, 1, h));
 					lineEdit->setUpdatesEnabled(true);
 					delete lineEditPix;
 					return false;
@@ -333,18 +333,18 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				
 				
 				// normal lineEdit
-				const QPixmap* parentBgPix = lineEdit->parentWidget() ? lineEdit->parentWidget()->paletteBackgroundPixmap() : 0;
-				QPixmap* lineEditEdges = 0;
-				if(khtmlMode || parentBgPix || !(lineEditEdges = QPixmapCache::find(QString::number(bg.pixel(), 16)+QString::number(cg.background().pixel(), 16)+"lEditEdges"))) {
+				const TQPixmap* parentBgPix = lineEdit->parentWidget() ? lineEdit->parentWidget()->paletteBackgroundPixmap() : 0;
+				TQPixmap* lineEditEdges = 0;
+				if(khtmlMode || parentBgPix || !(lineEditEdges = TQPixmapCache::find(TQString::number(bg.pixel(), 16)+TQString::number(cg.background().pixel(), 16)+"lEditEdges"))) {
 					if(khtmlMode) {
 						
-						QPixmap insidePix = tintImage(qembed_findImage("lineedit4inside"), bg);
+						TQPixmap insidePix = tintImage(qembed_findImage("lineedit4inside"), bg);
 						bitBlt(lineEdit, x, y, &insidePix, 0, 0, 4, 4);
 						bitBlt(lineEdit, w-4, y, &insidePix, 4, 0, 4, 4);
 						bitBlt(lineEdit, x, h-4, &insidePix, 0, 4, 4, 4);
 						bitBlt(lineEdit, w-4, h-4, &insidePix, 4, 4, 4, 4);
 						
-						QPixmap edgesPix = qembed_findImage("lineedit4edges");
+						TQPixmap edgesPix = qembed_findImage("lineedit4edges");
 						bitBlt(lineEdit, x, y, &edgesPix, 0, 0, 4, 4);
 						bitBlt(lineEdit, w-4, y, &edgesPix, 4, 0, 4, 4);
 						bitBlt(lineEdit, x, h-4, &edgesPix, 0, 4, 4, 4);
@@ -352,11 +352,11 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					}
 					else {
 						
-						lineEditEdges = new QPixmap(8, 8);
+						lineEditEdges = new TQPixmap(8, 8);
 						if(parentBgPix) {
-							QPoint offset = lineEdit->parentWidget()->backgroundOffset();
-							offset += QPoint(lineEdit->geometry().x(), lineEdit->geometry().y());
-							QPainter painter(lineEditEdges);
+							TQPoint offset = lineEdit->parentWidget()->backgroundOffset();
+							offset += TQPoint(lineEdit->geometry().x(), lineEdit->geometry().y());
+							TQPainter painter(lineEditEdges);
 							painter.drawTiledPixmap(0, 0, 4, 4, *parentBgPix, offset.x(), offset.y());
 							painter.drawTiledPixmap(4, 0, 4, 4, *parentBgPix, offset.x()+r.width()-4, offset.y());
 							painter.drawTiledPixmap(0, 4, 4, 4, *parentBgPix, offset.x(), offset.y()+r.height()-4);
@@ -365,24 +365,24 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 						else
 							lineEditEdges->fill(cg.background());
 						
-						QPixmap tmpPix = tintImage(qembed_findImage("lineedit4inside"), bg);
+						TQPixmap tmpPix = tintImage(qembed_findImage("lineedit4inside"), bg);
 						bitBlt(lineEditEdges, 0, 0, &tmpPix, 0, 0, 8, 8);
 						
-						QPixmap tmpPix2 = qembed_findImage("lineedit4edges");
+						TQPixmap tmpPix2 = qembed_findImage("lineedit4edges");
 						bitBlt(lineEditEdges, 0, 0, &tmpPix2, 0, 0, 8, 8);
 						
 						if(!parentBgPix)
-							QPixmapCache::insert(QString::number(bg.pixel(), 16)+QString::number(cg.background().pixel(), 16)+"lEditEdges", *lineEditEdges);
+							TQPixmapCache::insert(TQString::number(bg.pixel(), 16)+TQString::number(cg.background().pixel(), 16)+"lEditEdges", *lineEditEdges);
 					}
 				}
 				
 				
-				QPixmap* lineEditPix = 0;
+				TQPixmap* lineEditPix = 0;
 				
 				if(khtmlMode)
 					p.begin(lineEdit);
 				else {
-					lineEditPix = new QPixmap(w, h);
+					lineEditPix = new TQPixmap(w, h);
 					p.begin(lineEditPix);
 					
 					bitBlt(lineEditPix, x, y, lineEditEdges, 0, 0, 4, 4);
@@ -392,17 +392,17 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					
 				}
 				
-				p.fillRect(QRect(x+4, y, w-8, h), bg);
-				p.fillRect(QRect(x, y+4, 4, h-8), bg);
-				p.fillRect(QRect(w-4, y+4, 4, h-8), bg);
+				p.fillRect(TQRect(x+4, y, w-8, h), bg);
+				p.fillRect(TQRect(x, y+4, 4, h-8), bg);
+				p.fillRect(TQRect(w-4, y+4, 4, h-8), bg);
 				
-				QColor top_1 = alphaBlendColors(QColor(26, 26, 26), bg, 125);
-				QColor top_2 = alphaBlendColors(QColor(18, 18, 18), bg, 50);
-				QColor top_3 = alphaBlendColors(QColor(16, 16, 16), bg, 6);
-				QColor bottom = alphaBlendColors(QColor(0, 0, 0), bg, 30);
+				TQColor top_1 = alphaBlendColors(TQColor(26, 26, 26), bg, 125);
+				TQColor top_2 = alphaBlendColors(TQColor(18, 18, 18), bg, 50);
+				TQColor top_3 = alphaBlendColors(TQColor(16, 16, 16), bg, 6);
+				TQColor bottom = alphaBlendColors(TQColor(0, 0, 0), bg, 30);
 					
-				QColor left_1 = alphaBlendColors(QColor(0, 0, 0), bg, 78);
-				QColor left_2 = alphaBlendColors(QColor(0, 0, 0), bg, 10);
+				TQColor left_1 = alphaBlendColors(TQColor(0, 0, 0), bg, 78);
+				TQColor left_2 = alphaBlendColors(TQColor(0, 0, 0), bg, 10);
 					
 				p.setPen(top_1);
 				p.drawLine(x+4, y, w-5, y);
@@ -440,34 +440,34 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				}
 				return false;
 			}
-			case QEvent::MouseButtonPress:
-			case 6/*QEvent::KeyPress*/: {
-				// it will be reseted in QLineEdit::mouseMoveEvent()
+			case TQEvent::MouseButtonPress:
+			case 6/*TQEvent::KeyPress*/: {
+				// it will be reseted in TQLineEdit::mouseMoveEvent()
 				if(isLineEdit && !khtmlMode && isEnabled && !isReadOnly && !isDateTimeEditor)
-					static_cast<QWidget*>(obj)->setCursor(Qt::blankCursor);
+					static_cast<TQWidget*>(obj)->setCursor(TQt::blankCursor);
 				return false;
 			}
-			case QEvent::ApplicationPaletteChange:
+			case TQEvent::ApplicationPaletteChange:
 				if(!khtmlMode) {
-					lineEdit->setBackgroundMode(QWidget::PaletteBase);
-					lineEdit->setPalette(qApp->palette());
+					lineEdit->setBackgroundMode(TQWidget::PaletteBase);
+					lineEdit->setPalette(tqApp->palette());
 				}
 				return true;
-			case QEvent::ParentPaletteChange:
+			case TQEvent::ParentPaletteChange:
 				if(!khtmlMode) {
-					lineEdit->setBackgroundMode(QWidget::PaletteBase);
+					lineEdit->setBackgroundMode(TQWidget::PaletteBase);
 					lineEdit->setPalette(lineEdit->parentWidget()->palette());
 				}
 				return true;
-			case QEvent::PaletteChange:
+			case TQEvent::PaletteChange:
 				if(!khtmlMode) {
-					lineEdit->setBackgroundMode(QWidget::PaletteBase);
+					lineEdit->setBackgroundMode(TQWidget::PaletteBase);
 					lineEdit->setPalette(lineEdit->palette());
 				}
 				return true;
-			case QEvent::Wheel:
-			case QEvent::Hide:
-			case 7/*QEvent::KeyRelease*/:
+			case TQEvent::Wheel:
+			case TQEvent::Hide:
+			case 7/*TQEvent::KeyRelease*/:
 				// jump to smoothscrolling
 				if(_smoothScrolling)
 					break;
@@ -482,37 +482,37 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	// argb rubberBand
 	if(!strcmp(obj->name(), "qt_viewport") && rubberBandType == ArgbRubber) {
 		switch(ev->type()) {
-			case QEvent::ChildRemoved:
-			case QEvent::DragMove:
-			case QEvent::DragEnter: {
+			case TQEvent::ChildRemoved:
+			case TQEvent::DragMove:
+			case TQEvent::DragEnter: {
 				if(rubber) {
 					viewPortPressed = false;
-					oldRubberRect = QRect();
+					oldRubberRect = TQRect();
 					rubber->destroy();
 				}
 				return false;
 			}
-			case QEvent::MouseButtonPress: {
+			case TQEvent::MouseButtonPress: {
 				viewPortPressed = true;
-				rubberViewPort = static_cast<const QWidget*>(obj);
+				rubberViewPort = static_cast<const TQWidget*>(obj);
 				break;
 			}
-			case QEvent::MouseButtonRelease:
+			case TQEvent::MouseButtonRelease:
 				if(rubber) {
 					viewPortPressed = false;
 					rubberViewPort = 0;
-					oldRubberRect = QRect();
-					if(dynamic_cast<QListView*>(obj->parent()) && rubber->window)
+					oldRubberRect = TQRect();
+					if(dynamic_cast<TQListView*>(obj->parent()) && rubber->window)
 						ignoreNextFocusRect = true;
 					rubber->destroy();
 				}
 				
 #if KDE_VERSION >= 0x30506
-			case QEvent::Show: {
+			case TQEvent::Show: {
 				char selectionName[64];
-				snprintf(selectionName, 64, "_NET_WM_CM_S%d", DefaultScreen(qt_xdisplay()));
-				Atom compSelection = XInternAtom(qt_xdisplay(), selectionName, False);
-				if(XGetSelectionOwner(qt_xdisplay(), compSelection)) {
+				snprintf(selectionName, 64, "_NET_WM_CM_S%d", DefaultScreen(tqt_xdisplay()));
+				Atom compSelection = XInternAtom(tqt_xdisplay(), selectionName, False);
+				if(XGetSelectionOwner(tqt_xdisplay(), compSelection)) {
 					compositeManagerRunning = true;
 				}
 				else {
@@ -527,19 +527,19 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	
 	
 	// smoothscrolling
-	if(dynamic_cast<QScrollView*>(obj) && _smoothScrolling) {
+	if(dynamic_cast<TQScrollView*>(obj) && _smoothScrolling) {
 		switch(ev->type()) {
-			case QEvent::Wheel: {
-				QWheelEvent* e = (QWheelEvent*)ev;
-				QScrollView* sv = dynamic_cast<QScrollView*>(obj);
+			case TQEvent::Wheel: {
+				TQWheelEvent* e = (TQWheelEvent*)ev;
+				TQScrollView* sv = dynamic_cast<TQScrollView*>(obj);
 				bool pageSteps = false;
 				int pageStep = sv->verticalScrollBar()->pageStep();
 				int lineStep = sv->verticalScrollBar()->lineStep();
-				scrollVertical = e->orientation() == Qt::Vertical;
+				scrollVertical = e->orientation() == TQt::Vertical;
 				
-				QScrollBar* scrollBar = scrollVertical ? sv->verticalScrollBar() : sv->horizontalScrollBar();
+				TQScrollBar* scrollBar = scrollVertical ? sv->verticalScrollBar() : sv->horizontalScrollBar();
 				
-				int step = QMIN( QApplication::wheelScrollLines()*lineStep, pageStep );
+				int step = TQMIN( TQApplication::wheelScrollLines()*lineStep, pageStep );
 				if ( ( e->state() & ControlButton ) || ( e->state() & ShiftButton ) ) {
 					step = pageStep;
 					pageSteps = true;
@@ -552,13 +552,13 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				
 				// don't accumulate to much
 				if(scrollDistance < 0) {
-					scrollDistance = pageSteps? QMAX(scrollDistance, pageStep*2-(pageStep*4)): scrollDistance;
+					scrollDistance = pageSteps? TQMAX(scrollDistance, pageStep*2-(pageStep*4)): scrollDistance;
 					int minDistance = scrollBar->maxValue() - scrollBar->value();
-					scrollDistance = QMAX(scrollDistance, minDistance-(minDistance*2));
+					scrollDistance = TQMAX(scrollDistance, minDistance-(minDistance*2));
 				}
 				else {
-					scrollDistance = pageSteps? QMIN(scrollDistance, pageStep*2): scrollDistance;
-					scrollDistance = QMIN(scrollDistance, scrollBar->value());
+					scrollDistance = pageSteps? TQMIN(scrollDistance, pageStep*2): scrollDistance;
+					scrollDistance = TQMIN(scrollDistance, scrollBar->value());
 				}
 				
 				if(scrollDistance != 0) {
@@ -567,20 +567,20 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				
 				return true;
 			}
-			case 7: { // ?? 7 = QEvent::KeyRelease
-				QKeyEvent* ke = (QKeyEvent*)ev;
-				if(scrollTimer->isActive() && (ke->key() == Qt::Key_Shift || ke->key() == Qt::Key_Control)) {
+			case 7: { // ?? 7 = TQEvent::KeyRelease
+				TQKeyEvent* ke = (TQKeyEvent*)ev;
+				if(scrollTimer->isActive() && (ke->key() == TQt::Key_Shift || ke->key() == TQt::Key_Control)) {
 					scrollTimer->stop();
 					scrollDistance = 0;
 				}
 				return false;
 			}
-			case QEvent::WindowActivate:
-			case QEvent::WindowDeactivate:
+			case TQEvent::WindowActivate:
+			case TQEvent::WindowDeactivate:
 				// fixes the scrollbar flicker
 				return true;
-			case QEvent::Hide:
-			case QEvent::Show:
+			case TQEvent::Hide:
+			case TQEvent::Show:
 				scrollDistance = 0;
 				// don't return here (because of konqframe and ?)
 			default:
@@ -589,66 +589,66 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	}
 
 
-	if ( dynamic_cast<QScrollBar*>(obj) ) {
+	if ( dynamic_cast<TQScrollBar*>(obj) ) {
 		
 		switch(ev->type()) {
-			case QEvent::WindowActivate: {
-				QScrollBar* sb = dynamic_cast<QScrollBar*>(obj);
-				if(sb->backgroundMode() == Qt::NoBackground && !sb->testWState(WState_HasMouse)) {
-					sb->setBackgroundMode(Qt::PaletteButton);
+			case TQEvent::WindowActivate: {
+				TQScrollBar* sb = dynamic_cast<TQScrollBar*>(obj);
+				if(sb->backgroundMode() == TQt::NoBackground && !sb->testWState(WState_HasMouse)) {
+					sb->setBackgroundMode(TQt::PaletteButton);
 				}
 				return true;
 			}
-			case QEvent::Show: {
+			case TQEvent::Show: {
 				// no flicker in konqi and konsole, hits maybe others, too.
 				if(obj->parent()->parent() && (!strcmp(obj->parent()->parent()->name(), "KonqFrame") || !strcmp(obj->parent()->parent()->name(), "tab pages"))) {
-					dynamic_cast<QScrollBar*>(obj)->setBackgroundMode(Qt::NoBackground);
+					dynamic_cast<TQScrollBar*>(obj)->setBackgroundMode(TQt::NoBackground);
 				}
 				scrollDistance = 0;
 				return true;
 			}
-			case QEvent::Hide:
+			case TQEvent::Hide:
 				scrollDistance = 0;
 				return true;
-			case QEvent::Resize: {
-				QScrollBar* sb = dynamic_cast<QScrollBar*>(obj);
-				if(sb->backgroundMode() != Qt::NoBackground && sb->isVisible()) {
-					sb->setBackgroundMode(Qt::NoBackground);
+			case TQEvent::Resize: {
+				TQScrollBar* sb = dynamic_cast<TQScrollBar*>(obj);
+				if(sb->backgroundMode() != TQt::NoBackground && sb->isVisible()) {
+					sb->setBackgroundMode(TQt::NoBackground);
 				}
 				return false;
 			}
-			case QEvent::ParentPaletteChange: {
-				QScrollBar* sb = dynamic_cast<QScrollBar*>(obj);
-				sb->setBackgroundMode(Qt::PaletteButton);
+			case TQEvent::ParentPaletteChange: {
+				TQScrollBar* sb = dynamic_cast<TQScrollBar*>(obj);
+				sb->setBackgroundMode(TQt::PaletteButton);
 				sb->setPalette(sb->parentWidget()->palette());
 				return true;
 			}
-			case QEvent::PaletteChange: {
-				QScrollBar* sb = dynamic_cast<QScrollBar*>(obj);
-				sb->setBackgroundMode(Qt::PaletteButton);
+			case TQEvent::PaletteChange: {
+				TQScrollBar* sb = dynamic_cast<TQScrollBar*>(obj);
+				sb->setBackgroundMode(TQt::PaletteButton);
 				sb->setPalette(sb->palette());
 				return true;
 			}
-			case QEvent::ApplicationPaletteChange: { // ###
-				QScrollBar* sb = dynamic_cast<QScrollBar*>(obj);
+			case TQEvent::ApplicationPaletteChange: { // ###
+				TQScrollBar* sb = dynamic_cast<TQScrollBar*>(obj);
 				removeCachedSbPix(sb->paletteBackgroundColor());
-				sb->setBackgroundMode(Qt::PaletteButton);
+				sb->setBackgroundMode(TQt::PaletteButton);
 // 				sb->update();
 				return false;
 			}
-			case QEvent::Wheel: {
+			case TQEvent::Wheel: {
 				if(!_smoothScrolling)
 					return false;
-				QWheelEvent* e = (QWheelEvent*)ev;
-				QScrollBar* sb = dynamic_cast<QScrollBar*>(obj);
-				if(!dynamic_cast<QScrollView*>(sb->parentWidget()))
+				TQWheelEvent* e = (TQWheelEvent*)ev;
+				TQScrollBar* sb = dynamic_cast<TQScrollBar*>(obj);
+				if(!dynamic_cast<TQScrollView*>(sb->parentWidget()))
 					return false;
 				
 				bool pageSteps = false;
 				int pageStep = sb->pageStep();
 				int lineStep = sb->lineStep();
 				
-				int step = QMIN( QApplication::wheelScrollLines()*lineStep, pageStep );
+				int step = TQMIN( TQApplication::wheelScrollLines()*lineStep, pageStep );
 				if ( ( e->state() & ControlButton ) || ( e->state() & ShiftButton ) ) {
 					step = pageStep;
 					pageSteps = true;
@@ -656,30 +656,30 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				int dy = (e->delta()*step)/120;
 				
 				e->accept();
-				scrollWidget = dynamic_cast<QScrollView*>(sb->parentWidget());
+				scrollWidget = dynamic_cast<TQScrollView*>(sb->parentWidget());
 				scrollDistance += dy;
 				
 				// don't accumulate to much
 				if(scrollDistance < 0) {
-					scrollDistance = pageSteps? QMAX(scrollDistance, pageStep*2-(pageStep*4)): scrollDistance;
+					scrollDistance = pageSteps? TQMAX(scrollDistance, pageStep*2-(pageStep*4)): scrollDistance;
 					int minDistance = sb->maxValue() - sb->value();
-					scrollDistance = QMAX(scrollDistance, minDistance-(minDistance*2));
+					scrollDistance = TQMAX(scrollDistance, minDistance-(minDistance*2));
 				}
 				else {
-					scrollDistance = pageSteps? QMIN(scrollDistance, pageStep*2): scrollDistance;
-					scrollDistance = QMIN(scrollDistance, sb->value());
+					scrollDistance = pageSteps? TQMIN(scrollDistance, pageStep*2): scrollDistance;
+					scrollDistance = TQMIN(scrollDistance, sb->value());
 				}
 				
-				scrollVertical = sb->orientation() == Qt::Vertical;
+				scrollVertical = sb->orientation() == TQt::Vertical;
 				if(scrollDistance != 0) {
 					scrollTimer->start(pageSteps? 4: 14);
 				}
 				
 				return true;
 			}
-			case 7: { // ?? 7 = QEvent::KeyRelease
-				QKeyEvent* ke = (QKeyEvent*)ev;
-				if(scrollTimer->isActive() && (ke->key() == Qt::Key_Shift || ke->key() == Qt::Key_Control)) {
+			case 7: { // ?? 7 = TQEvent::KeyRelease
+				TQKeyEvent* ke = (TQKeyEvent*)ev;
+				if(scrollTimer->isActive() && (ke->key() == TQt::Key_Shift || ke->key() == TQt::Key_Control)) {
 					scrollTimer->stop();
 					scrollDistance = 0;
 				}
@@ -691,78 +691,78 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	}
 
 
-	if ( dynamic_cast<QProgressBar*>(obj) && _animateProgressBar)
+	if ( dynamic_cast<TQProgressBar*>(obj) && _animateProgressBar)
 	{
 		switch(ev->type()) {
-			case QEvent::Show:
+			case TQEvent::Show:
 				if(!animationTimer->isActive())
 					animationTimer->start( 50, false );
 				return true;
-			case QEvent::Hide:
+			case TQEvent::Hide:
 				if(animationTimer->isActive())
 					animationTimer->stop();
 				return true;
-			case QEvent::ApplicationPaletteChange:
-				setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Application);
+			case TQEvent::ApplicationPaletteChange:
+				setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Application);
 				return true;
-			case QEvent::ParentPaletteChange:
-				setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Parent);
+			case TQEvent::ParentPaletteChange:
+				setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Parent);
 				return true;
-			case QEvent::PaletteChange:
-				setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Widget);
+			case TQEvent::PaletteChange:
+				setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Widget);
 				return true;
 			default:
 				return false;
 		}
 	}
 	
-	if (dynamic_cast<QStatusBar*>(obj)) {
-		if(ev->type() == QEvent::PaletteChange) {
-			QStatusBar* sb = dynamic_cast<QStatusBar*>(obj);
-			sb->setPaletteBackgroundColor(qApp->palette().active().background());
-			sb->setPaletteForegroundColor(qApp->palette().active().foreground());
+	if (dynamic_cast<TQStatusBar*>(obj)) {
+		if(ev->type() == TQEvent::PaletteChange) {
+			TQStatusBar* sb = dynamic_cast<TQStatusBar*>(obj);
+			sb->setPaletteBackgroundColor(tqApp->palette().active().background());
+			sb->setPaletteForegroundColor(tqApp->palette().active().foreground());
 			return true;
 		}
 		return false;
 	}
 	
-	if (dynamic_cast<QGroupBox*>(obj) && dynamic_cast<QFrame*>(obj)->frameShape() == QFrame::GroupBoxPanel) {
-		QGroupBox* gb = dynamic_cast<QGroupBox*>(obj);
-		QRect r = gb->rect();
+	if (dynamic_cast<TQGroupBox*>(obj) && dynamic_cast<TQFrame*>(obj)->frameShape() == TQFrame::GroupBoxPanel) {
+		TQGroupBox* gb = dynamic_cast<TQGroupBox*>(obj);
+		TQRect r = gb->rect();
 		
 		switch(ev->type()) {
-			case QEvent::Paint: {
+			case TQEvent::Paint: {
 // 				if(y+16 > h || 16 > w) // don't overlap the pixmaps
 // 					return false;
 				renderGroupBox(obj, ev);
 				return true;
 			}
-			case QEvent::Resize: {
+			case TQEvent::Resize: {
 				if(!gb->isFlat())
 					renderGroupBox(obj, ev);
 				return false;
 			}
-			case QEvent::ApplicationPaletteChange:
-			case QEvent::PaletteChange:
-			case QEvent::ParentPaletteChange: {
+			case TQEvent::ApplicationPaletteChange:
+			case TQEvent::PaletteChange:
+			case TQEvent::ParentPaletteChange: {
 				
 				if(gb->isFlat() || gb->lineWidth() <= 0) {
 					return false;
 				}
 				
-				QColor outsideColor = gb->parentWidget() ? gb->parentWidget()->paletteBackgroundColor() : gb->paletteBackgroundColor();
-				QColor insideColor = groupBoxSettings.tintBackground ? getGroupBoxColor(gb) : gb->paletteBackgroundColor();
+				TQColor outsideColor = gb->parentWidget() ? gb->parentWidget()->paletteBackgroundColor() : gb->paletteBackgroundColor();
+				TQColor insideColor = groupBoxSettings.tintBackground ? getGroupBoxColor(gb) : gb->paletteBackgroundColor();
 				
-				QPalette pal(qApp->palette());
-				pal.setColor(QPalette::Active, QColorGroup::Background, insideColor);
-				pal.setColor(QPalette::Inactive, QColorGroup::Background, insideColor);
-				pal.setColor(QPalette::Disabled, QColorGroup::Background, insideColor);
-				pal.setColor(QPalette::Disabled, QColorGroup::Text, alphaBlendColors(pal.active().foreground(), insideColor, 40));
+				TQPalette pal(tqApp->palette());
+				pal.setColor(TQPalette::Active, TQColorGroup::Background, insideColor);
+				pal.setColor(TQPalette::Inactive, TQColorGroup::Background, insideColor);
+				pal.setColor(TQPalette::Disabled, TQColorGroup::Background, insideColor);
+				pal.setColor(TQPalette::Disabled, TQColorGroup::Text, alphaBlendColors(pal.active().foreground(), insideColor, 40));
 				gb->setPalette(pal);
 				
 				
 				if(gb->isCheckable()) {
-					((QCheckBox*)gb->child("qt_groupbox_checkbox", 0, false))->setPaletteBackgroundColor(outsideColor);
+					((TQCheckBox*)gb->child("qt_groupbox_checkbox", 0, false))->setPaletteBackgroundColor(outsideColor);
 				}
 				
 				if(groupBoxPixmaps.contains(gb)) {
@@ -776,17 +776,17 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		}
 	}
 
-	if(dynamic_cast<QSpinWidget*>(obj)) {
+	if(dynamic_cast<TQSpinWidget*>(obj)) {
 		
 		switch(ev->type()) {
-			case QEvent::Paint: {
+			case TQEvent::Paint: {
 				
-				QSpinWidget* sw = static_cast<QSpinWidget*>(obj);
-				QPixmap buffer(sw->size());
-				QPainter p(&buffer);
+				TQSpinWidget* sw = static_cast<TQSpinWidget*>(obj);
+				TQPixmap buffer(sw->size());
+				TQPainter p(&buffer);
 				
 				if(sw->parentWidget() && sw->parentWidget()->parentWidget() && sw->parentWidget()->parentWidget()->backgroundPixmap()) {
-					QPoint point = sw->backgroundOffset();
+					TQPoint point = sw->backgroundOffset();
 					p.drawTiledPixmap( 0, 0, sw->width(), sw->height(),
 							*sw->parentWidget()->parentWidget()->backgroundPixmap(), point.x(), point.y() );
 				}
@@ -794,47 +794,47 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				
 				
 				///////
-				QStyle::SFlags flags = QStyle::Style_Default;
+				TQStyle::SFlags flags = TQStyle::Style_Default;
 				if (sw->isEnabled())
-					flags |= QStyle::Style_Enabled;
+					flags |= TQStyle::Style_Enabled;
 				if (sw->hasFocus() || sw->focusProxy() && sw->focusProxy()->hasFocus())
-					flags |= QStyle::Style_HasFocus;
+					flags |= TQStyle::Style_HasFocus;
 				if(spinWidgetDown && sw->hasMouse())
-					flags |= QStyle::Style_Down;
-				QRect fr = QStyle::visualRect(querySubControlMetrics( QStyle::CC_SpinWidget, sw, QStyle::SC_SpinWidgetFrame ), sw );
-				drawComplexControl( QStyle::CC_SpinWidget, &p, sw, sw->rect(), sw->colorGroup(), flags, (uint)QStyle::SC_All, QStyle::SC_None );
+					flags |= TQStyle::Style_Down;
+				TQRect fr = TQStyle::visualRect(querySubControlMetrics( TQStyle::CC_SpinWidget, sw, TQStyle::SC_SpinWidgetFrame ), sw );
+				drawComplexControl( TQStyle::CC_SpinWidget, &p, sw, sw->rect(), sw->colorGroup(), flags, (uint)TQStyle::SC_All, TQStyle::SC_None );
 				p.end();
 				p.begin(sw);
 				p.drawPixmap(0,0,buffer);
 				return true;
 			}
-			case QEvent::MouseButtonRelease:
-			case QEvent::MouseButtonPress:
-			case QEvent::MouseButtonDblClick: {
-				QSpinWidget* sw = static_cast<QSpinWidget*>(obj);
-				QPainter p(sw);
+			case TQEvent::MouseButtonRelease:
+			case TQEvent::MouseButtonPress:
+			case TQEvent::MouseButtonDblClick: {
+				TQSpinWidget* sw = static_cast<TQSpinWidget*>(obj);
+				TQPainter p(sw);
 				
-				QStyle::SFlags flags = QStyle::Style_Default;
+				TQStyle::SFlags flags = TQStyle::Style_Default;
 				if (sw->isEnabled())
-					flags |= QStyle::Style_Enabled;
+					flags |= TQStyle::Style_Enabled;
 				if (sw->hasFocus() || sw->focusProxy() && sw->focusProxy()->hasFocus())
-					flags |= QStyle::Style_HasFocus;
-				if(ev->type() != QEvent::MouseButtonRelease && dynamic_cast<QSpinBox*>(sw->parentWidget())) {
-					QSpinBox* sb = dynamic_cast<QSpinBox*>(sw->parentWidget());
-					QMouseEvent* e = (QMouseEvent*)ev;
+					flags |= TQStyle::Style_HasFocus;
+				if(ev->type() != TQEvent::MouseButtonRelease && dynamic_cast<TQSpinBox*>(sw->parentWidget())) {
+					TQSpinBox* sb = dynamic_cast<TQSpinBox*>(sw->parentWidget());
+					TQMouseEvent* e = (TQMouseEvent*)ev;
 					
 					if(sb->downRect().contains(e->pos()) && sb->value() != sb->minValue()) {
-						flags |= QStyle::Style_Down;
+						flags |= TQStyle::Style_Down;
 						spinWidgetDown = true;
 					}
 					if(sb->upRect().contains(e->pos()) && sb->value() != sb->maxValue()) {
-						flags |= QStyle::Style_Down;
+						flags |= TQStyle::Style_Down;
 						spinWidgetDown = true;
 					}
 					if(spinWidgetDown) {
 						if(sw->paletteBackgroundPixmap())
 							sw->erase();
-						drawComplexControl( QStyle::CC_SpinWidget, &p, sw, sw->rect(), sw->colorGroup(), flags, (uint)QStyle::SC_All, QStyle::SC_None);
+						drawComplexControl( TQStyle::CC_SpinWidget, &p, sw, sw->rect(), sw->colorGroup(), flags, (uint)TQStyle::SC_All, TQStyle::SC_None);
 					}
 					return false;
 					
@@ -844,34 +844,34 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				
 				if(sw->paletteBackgroundPixmap())
 					sw->erase();
-				drawComplexControl( QStyle::CC_SpinWidget, &p, sw, sw->rect(), sw->colorGroup(), flags, (uint)QStyle::SC_All, QStyle::SC_None);
+				drawComplexControl( TQStyle::CC_SpinWidget, &p, sw, sw->rect(), sw->colorGroup(), flags, (uint)TQStyle::SC_All, TQStyle::SC_None);
 				return false;
 			}
-			case QEvent::Enter: {
-				QPushButton* btn = static_cast<QPushButton*>(obj);
+			case TQEvent::Enter: {
+				TQPushButton* btn = static_cast<TQPushButton*>(obj);
 				if(!btn->isEnabled())
 					return false;
 				hoverWidget = btn;
 				btn->repaint(btn->paletteBackgroundPixmap());
 				return false;
 			}
-			case QEvent::Leave: {
+			case TQEvent::Leave: {
 				spinWidgetDown = false;
-				QPushButton* btn = static_cast<QPushButton*>(obj);
+				TQPushButton* btn = static_cast<TQPushButton*>(obj);
 				if(!btn->isEnabled())
 					return false;
 				hoverWidget = 0;
 				btn->repaint(btn->paletteBackgroundPixmap());
 				return false;
 			}
-			case QEvent::ApplicationPaletteChange:
-				setDominoButtonPalette(dynamic_cast<QWidget*>(obj), Palette_Application);
+			case TQEvent::ApplicationPaletteChange:
+				setDominoButtonPalette(dynamic_cast<TQWidget*>(obj), Palette_Application);
 				return true;
-			case QEvent::ParentPaletteChange:
-				setDominoButtonPalette(dynamic_cast<QWidget*>(obj), Palette_Parent);
+			case TQEvent::ParentPaletteChange:
+				setDominoButtonPalette(dynamic_cast<TQWidget*>(obj), Palette_Parent);
 				return true;
-			case QEvent::PaletteChange:
-				setDominoButtonPalette(dynamic_cast<QWidget*>(obj), Palette_Parent);
+			case TQEvent::PaletteChange:
+				setDominoButtonPalette(dynamic_cast<TQWidget*>(obj), Palette_Parent);
 				return true;
 			default:
 				break;
@@ -880,12 +880,12 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	}
 
 	
-	if (dynamic_cast<QTabBar*>(obj)) {
+	if (dynamic_cast<TQTabBar*>(obj)) {
 		
 		switch(ev->type()) {
-			case QEvent::Wheel: {
-				QWheelEvent* e = (QWheelEvent*)ev;
-				QTabWidget* tw = dynamic_cast<QTabWidget*>(obj->parent());
+			case TQEvent::Wheel: {
+				TQWheelEvent* e = (TQWheelEvent*)ev;
+				TQTabWidget* tw = dynamic_cast<TQTabWidget*>(obj->parent());
 				if(!tw)
 					return false;
 				
@@ -905,31 +905,31 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					tw->setCurrentPage(current );
 				return true;
 			}
-			case QEvent::ApplicationPaletteChange:
-				setDominoButtonPalette(dynamic_cast<QWidget*>(obj), Palette_Application);
+			case TQEvent::ApplicationPaletteChange:
+				setDominoButtonPalette(dynamic_cast<TQWidget*>(obj), Palette_Application);
 				return true;
-			case QEvent::ParentPaletteChange:
-				setDominoButtonPalette(dynamic_cast<QWidget*>(obj), Palette_Parent);
+			case TQEvent::ParentPaletteChange:
+				setDominoButtonPalette(dynamic_cast<TQWidget*>(obj), Palette_Parent);
 				return true;
-			case QEvent::PaletteChange:
-				setDominoButtonPalette(dynamic_cast<QWidget*>(obj), Palette_Widget);
+			case TQEvent::PaletteChange:
+				setDominoButtonPalette(dynamic_cast<TQWidget*>(obj), Palette_Widget);
 				return true;
 			default:
 				return false;
 		}
 	}
 	
-	if (dynamic_cast<QTabWidget*>(obj)) {
+	if (dynamic_cast<TQTabWidget*>(obj)) {
 		
-		QTabWidget* tw = dynamic_cast<QTabWidget*>(obj);
+		TQTabWidget* tw = dynamic_cast<TQTabWidget*>(obj);
 		if(tw->isA("KonqFrameTabs")) {
 			
-			QColorGroup cg = qApp->palette().active();
+			TQColorGroup cg = tqApp->palette().active();
 			switch (ev->type()) {
-				case QEvent::Paint: {
-					QRect r = tw->rect();
+				case TQEvent::Paint: {
+					TQRect r = tw->rect();
 					int top, height;
-					if(tw->tabPosition() == QTabWidget::Top) {
+					if(tw->tabPosition() == TQTabWidget::Top) {
 						top = r.top();
 						height =  r.height()-tw->currentPage()->height();
 					}
@@ -938,7 +938,7 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 						height = r.height();
 					}
 					
-					QPainter p(tw);
+					TQPainter p(tw);
 					p.setPen(cg.background());
 					p.drawLine(r.left(), top, r.width(), top);
 					
@@ -949,9 +949,9 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					p.drawLine(r.left(), top+2, r.width(), top+2);
 					return true;
 				}
-				case QEvent::Show:
-				case QEvent::PaletteChange:
-				case QEvent::ApplicationPaletteChange: {
+				case TQEvent::Show:
+				case TQEvent::PaletteChange:
+				case TQEvent::ApplicationPaletteChange: {
 					if(tw->eraseColor() != cg.background().dark(konqTabBarContrast))
 						tw->setEraseColor(cg.background().dark(konqTabBarContrast));
 					return true;
@@ -960,22 +960,22 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					return false;
 			}
 		}
-		else if(ev->type() == QEvent::Wheel) {
+		else if(ev->type() == TQEvent::Wheel) {
 			if(!tw)
 				return false;
 			
-			QRect r = tw->rect();
-			QRect re  = ((DominoQTabWidget*)tw)->tabBar()->rect();
+			TQRect r = tw->rect();
+			TQRect re  = ((DominoTQTabWidget*)tw)->tabBar()->rect();
 			int top;
-			if(tw->tabPosition() == QTabWidget::Top) {
+			if(tw->tabPosition() == TQTabWidget::Top) {
 				top = r.top();
 			}
 			else {
 				top = r.top() + tw->height()-re.height() - 2;
 			}
 			
-			QWheelEvent* e = (QWheelEvent*)ev;
-			if(QRect(re.x(), top, r.width(), re.height()).contains(e->pos())) {
+			TQWheelEvent* e = (TQWheelEvent*)ev;
+			if(TQRect(re.x(), top, r.width(), re.height()).contains(e->pos())) {
 				int current = tw->currentPageIndex();
 				int count = tw->count();
 				if(count < 2)
@@ -992,23 +992,23 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				return true;
 			}
 		}
-		if(ev->type() == QEvent::LayoutHint) {
+		if(ev->type() == TQEvent::LayoutHint) {
 			if(!tw)
 				return false;
-			QWidget* w;
-			if((w = tw->cornerWidget(Qt::TopRight))) {
+			TQWidget* w;
+			if((w = tw->cornerWidget(TQt::TopRight))) {
 				if(!w->width() != 25 || w->height() != 23)
 					w->setFixedSize(25, 23);
 			}
-			if((w = tw->cornerWidget(Qt::TopLeft))) {
+			if((w = tw->cornerWidget(TQt::TopLeft))) {
 				if(!w->width() != 25 || w->height() != 23)
 					w->setFixedSize(25, 23);
 			}
-			if((w = tw->cornerWidget(Qt::BottomRight))) {
+			if((w = tw->cornerWidget(TQt::BottomRight))) {
 				if(!w->width() != 25 || w->height() != 23)
 					w->setFixedSize(25, 23);
 			}
-			if((w = tw->cornerWidget(Qt::BottomLeft))) {
+			if((w = tw->cornerWidget(TQt::BottomLeft))) {
 				if(!w->width() != 25 || w->height() != 23)
 					w->setFixedSize(25, 23);
 			}
@@ -1017,9 +1017,9 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		}
 		return false;
  	}
-	if(::qt_cast<KToolBarButton*>(obj)) {
+	if(::tqt_cast<KToolBarButton*>(obj)) {
 		switch(ev->type()) {
-			case QEvent::Paint: {
+			case TQEvent::Paint: {
 				KToolBar *bar = dynamic_cast<KToolBar*>(obj->parent());
 				if(!bar) return false;  // KMyMoney2
 				KToolBarButton* btn = dynamic_cast<KToolBarButton*>(obj);
@@ -1039,31 +1039,31 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				}
 				
 				
-				SFlags flags = QStyle::Style_Default;
-				SCFlags active = QStyle::SC_None;
-				if(btn->isOn()) flags |= QStyle::Style_On;
+				SFlags flags = TQStyle::Style_Default;
+				SCFlags active = TQStyle::SC_None;
+				if(btn->isOn()) flags |= TQStyle::Style_On;
 				if (btn->isDown()) {
-					flags  |= QStyle::Style_Down;
-					active |= QStyle::SC_ToolButton;
+					flags  |= TQStyle::Style_Down;
+					active |= TQStyle::SC_ToolButton;
 				}
-				if (btn->isEnabled())  flags |= QStyle::Style_Enabled;
-				if (btn->isEnabled() && btn->hasMouse())    flags |= QStyle::Style_Raised;
-				if (btn->hasFocus())   flags |= QStyle::Style_HasFocus;
+				if (btn->isEnabled())  flags |= TQStyle::Style_Enabled;
+				if (btn->isEnabled() && btn->hasMouse())    flags |= TQStyle::Style_Raised;
+				if (btn->hasFocus())   flags |= TQStyle::Style_HasFocus;
 				//SCFlags controls,
 				
-				QPainter p(btn);
+				TQPainter p(btn);
 				
 				if(btn->isDown()/* || btn->isOn()*/)
 					buttonContour->setState(Contour_Pressed);
 				else if(btn == hoverWidget && btn->isEnabled())
 					buttonContour->setState(Contour_MouseOver);
 				
-				drawComplexControl(QStyle::CC_ToolButton, &p, btn, btn->rect(), btn->colorGroup(), flags, QStyle::SC_ToolButton, active, QStyleOption());
+				drawComplexControl(TQStyle::CC_ToolButton, &p, btn, btn->rect(), btn->colorGroup(), flags, TQStyle::SC_ToolButton, active, TQStyleOption());
 				buttonContour->reset();
 				return true;
 			}
-			case QEvent::MouseButtonPress: {
-				if(((QMouseEvent*)ev)->button() == Qt::RightButton)
+			case TQEvent::MouseButtonPress: {
+				if(((TQMouseEvent*)ev)->button() == TQt::RightButton)
 					return false;
 				KToolBarButton* btn = dynamic_cast<KToolBarButton*>(obj);
 				btn->setUpdatesEnabled(false);
@@ -1072,8 +1072,8 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				hoverWidget = 0;
 				return false;
 			}
-			case QEvent::MouseButtonRelease: {
-				if(((QMouseEvent*)ev)->button() == Qt::RightButton)
+			case TQEvent::MouseButtonRelease: {
+				if(((TQMouseEvent*)ev)->button() == TQt::RightButton)
 					return false;
 				KToolBarButton* btn = dynamic_cast<KToolBarButton*>(obj);
 				btn->setUpdatesEnabled(false);
@@ -1083,15 +1083,15 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					hoverWidget = btn;
 				return false;
 			}
-			case QEvent::MouseButtonDblClick: {
-				if(((QMouseEvent*)ev)->button() == Qt::RightButton)
+			case TQEvent::MouseButtonDblClick: {
+				if(((TQMouseEvent*)ev)->button() == TQt::RightButton)
 					return false;
 				KToolBarButton* btn = dynamic_cast<KToolBarButton*>(obj);
 				if(!btn->isOn()) btn->setOn(true);
 				hoverWidget = 0;
 				return false;
 			}
-			case QEvent::Enter: {
+			case TQEvent::Enter: {
 				KToolBarButton* btn = dynamic_cast<KToolBarButton*>(obj);
 				if(btn->isEnabled()) {
 					hoverWidget = btn;
@@ -1099,7 +1099,7 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				}
 				return false;
 			}
-			case QEvent::Leave: {
+			case TQEvent::Leave: {
 				KToolBarButton* btn = dynamic_cast<KToolBarButton*>(obj);
 				if(btn == hoverWidget) {
 					hoverWidget = 0;
@@ -1107,15 +1107,15 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				}
 				return false;
 			}
-			case QEvent::Move: {
+			case TQEvent::Move: {
 				if(_toolBtnAsBtn) {
 					KToolBarButton* btn = dynamic_cast<KToolBarButton*>(obj);
 					btn->repaint(false);
 				}
 				return false;
 			}
-			case QEvent::ApplicationPaletteChange: {
-				setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Application);
+			case TQEvent::ApplicationPaletteChange: {
+				setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Application);
 				return true;
 			}
 			default:
@@ -1123,35 +1123,35 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		}
 	}
 
-	if(dynamic_cast<QRadioButton*>(obj) && dynamic_cast<QRadioButton*>(obj)->paletteBackgroundPixmap()) {
-		if (ev->type() == QEvent::Paint) {
-			QRadioButton* rb = static_cast<QRadioButton*>(obj);
+	if(dynamic_cast<TQRadioButton*>(obj) && dynamic_cast<TQRadioButton*>(obj)->paletteBackgroundPixmap()) {
+		if (ev->type() == TQEvent::Paint) {
+			TQRadioButton* rb = static_cast<TQRadioButton*>(obj);
 			
 			rb->removeEventFilter(this);
-			QApplication::sendEvent(rb, (QPaintEvent*)ev);
+			TQApplication::sendEvent(rb, (TQPaintEvent*)ev);
 			rb->installEventFilter(this);
 			
-			QStyle::SFlags flags = QStyle::Style_Default;
+			TQStyle::SFlags flags = TQStyle::Style_Default;
 			if ( rb->isEnabled() )
-				flags |= QStyle::Style_Enabled;
+				flags |= TQStyle::Style_Enabled;
 			if ( rb->hasFocus() )
-				flags |= QStyle::Style_HasFocus;
+				flags |= TQStyle::Style_HasFocus;
 			if ( rb->isDown() )
-				flags |= QStyle::Style_Down;
+				flags |= TQStyle::Style_Down;
 			if ( rb->hasMouse() )
-				flags |= QStyle::Style_MouseOver;
-			if ( rb->state() == QButton::On )
-				flags |= QStyle::Style_On;
-			else if ( rb->state() == QButton::Off )
-				flags |= QStyle::Style_Off;
+				flags |= TQStyle::Style_MouseOver;
+			if ( rb->state() == TQButton::On )
+				flags |= TQStyle::Style_On;
+			else if ( rb->state() == TQButton::Off )
+				flags |= TQStyle::Style_Off;
 			
-			QPainter p(rb);
-			drawControl(CE_RadioButton, &p, rb, QRect(0,0,17,17), rb->palette().active(), flags);
+			TQPainter p(rb);
+			drawControl(CE_RadioButton, &p, rb, TQRect(0,0,17,17), rb->palette().active(), flags);
 			return true;
 		}
-		if (ev->type() == QEvent::Show && !strcmp(obj->name(), "__khtml")) {
-			QRadioButton* rb = static_cast<QRadioButton*>(obj);
-			QBitmap bm(rb->size());
+		if (ev->type() == TQEvent::Show && !strcmp(obj->name(), "__khtml")) {
+			TQRadioButton* rb = static_cast<TQRadioButton*>(obj);
+			TQBitmap bm(rb->size());
 			bm.fill(color0);
 			rb->setMask(bm);
 		}
@@ -1160,71 +1160,71 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	
 	if (obj->isA("KonqCheckBox")) {
 		
-		if (ev->type() == QEvent::Show || ev->type() == QEvent::ApplicationPaletteChange) { // at least doesn't flicker in the unchecked state ;-)
-			QButton* btn = dynamic_cast<QButton*>(obj);
-			QPixmap pix(btn->size());
-			pix.fill(qApp->palette().active().background());
-			QPainter p(&pix);
-			drawControl( CE_CheckBox, &p, btn, QRect(0,0,18,19), qApp->palette().active(), Style_Default|Style_Off, QStyleOption::Default);
+		if (ev->type() == TQEvent::Show || ev->type() == TQEvent::ApplicationPaletteChange) { // at least doesn't flicker in the unchecked state ;-)
+			TQButton* btn = dynamic_cast<TQButton*>(obj);
+			TQPixmap pix(btn->size());
+			pix.fill(tqApp->palette().active().background());
+			TQPainter p(&pix);
+			drawControl( CE_CheckBox, &p, btn, TQRect(0,0,18,19), tqApp->palette().active(), Style_Default|Style_Off, TQStyleOption::Default);
 			btn->setErasePixmap(pix);
 			return true;
 		}
-		if (ev->type() == QEvent::Paint) {
-			QButton* btn = dynamic_cast<QButton*>(obj);
+		if (ev->type() == TQEvent::Paint) {
+			TQButton* btn = dynamic_cast<TQButton*>(obj);
 			btn->erase();
 			SFlags flags = Style_Default;
 			if ( btn->isDown() )
 				flags |= Style_Down;
-			if ( btn->state() == QButton::On )
+			if ( btn->state() == TQButton::On )
 				flags |= Style_On;
-			else if ( btn->state() == QButton::Off )
+			else if ( btn->state() == TQButton::Off )
 				flags |= Style_Off;
 			if ( btn->isEnabled() )
 				flags |= Style_Enabled;
-			QPainter p(btn);
-			drawPrimitive(PE_CheckMark, &p, QRect(0,0,16,17), qApp->palette().active(), flags);
+			TQPainter p(btn);
+			drawPrimitive(PE_CheckMark, &p, TQRect(0,0,16,17), tqApp->palette().active(), flags);
 			return true;
 		}
 		return false;
 	}
 	
-	if(dynamic_cast<QCheckBox*>(obj)) {
-		if (ev->type() == QEvent::Paint) {
-			QCheckBox* cb = static_cast<QCheckBox*>(obj);
+	if(dynamic_cast<TQCheckBox*>(obj)) {
+		if (ev->type() == TQEvent::Paint) {
+			TQCheckBox* cb = static_cast<TQCheckBox*>(obj);
 			
 			bool khtmlWidget = !strcmp(obj->name(), "__khtml");
 			if(khtmlWidget || cb->paletteBackgroundPixmap()) {
 				if(khtmlWidget) {
 					// this prevents the checkbox been erased before the rest of the html page
-					QBitmap bm(cb->size());
+					TQBitmap bm(cb->size());
 					bm.fill(color0);
 					cb->setMask(bm);
 				}
 				else {
 					// draws a masked checkbox
 					cb->removeEventFilter(this);
-					QApplication::sendEvent(cb, (QPaintEvent*)ev);
+					TQApplication::sendEvent(cb, (TQPaintEvent*)ev);
 					cb->installEventFilter(this);
 				}
 				// draws the missing alpha part
-				QStyle::SFlags flags = QStyle::Style_Default;
+				TQStyle::SFlags flags = TQStyle::Style_Default;
 				if ( cb->isEnabled() )
-					flags |= QStyle::Style_Enabled;
+					flags |= TQStyle::Style_Enabled;
 				if ( cb->hasFocus() )
-					flags |= QStyle::Style_HasFocus;
+					flags |= TQStyle::Style_HasFocus;
 				if ( cb->isDown() )
-					flags |= QStyle::Style_Down;
+					flags |= TQStyle::Style_Down;
 				if ( cb->hasMouse() )
-					flags |= QStyle::Style_MouseOver;
-				if ( cb->state() == QButton::On )
-					flags |= QStyle::Style_On;
-				else if ( cb->state() == QButton::Off )
-					flags |= QStyle::Style_Off;
-				else if ( cb->state() == QButton::NoChange )
-					flags |= QStyle::Style_NoChange;
-				
-				QPainter p(cb);
-				drawControl(CE_CheckBox, &p, cb, QRect(0,0,18,19), cb->palette().active(), flags);
+					flags |= TQStyle::Style_MouseOver;
+				if ( cb->state() == TQButton::On )
+					flags |= TQStyle::Style_On;
+				else if ( cb->state() == TQButton::Off )
+					flags |= TQStyle::Style_Off;
+				else if ( cb->state() == TQButton::NoChange )
+					flags |= TQStyle::Style_NoChange;
+				
+				TQPainter p(cb);
+				drawControl(CE_CheckBox, &p, cb, TQRect(0,0,18,19), cb->palette().active(), flags);
 				return true;
 			}
 			return false;
@@ -1232,26 +1232,26 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		return false;
 	}
 	
-	if(dynamic_cast<QPopupMenu*>(obj)) {
+	if(dynamic_cast<TQPopupMenu*>(obj)) {
 		switch(ev->type()) {
-			case QEvent::Resize:
-			case QEvent::Show: {
-				QWidget* w = static_cast<QWidget*>(obj);
-				QRect r = w->rect();
-				QRegion mask(r.x()+2, r.y(), r.width()-4, r.height());
-				mask += QRegion(r.x(), r.y()+2, r.width(), r.height()-4);
-				mask += QRegion(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
+			case TQEvent::Resize:
+			case TQEvent::Show: {
+				TQWidget* w = static_cast<TQWidget*>(obj);
+				TQRect r = w->rect();
+				TQRegion mask(r.x()+2, r.y(), r.width()-4, r.height());
+				mask += TQRegion(r.x(), r.y()+2, r.width(), r.height()-4);
+				mask += TQRegion(r.x()+1, r.y()+1, r.width()-2, r.height()-2);
 				w->setMask(mask);
 				return false;
 			}
-			case QEvent::Hide:
-				static_cast<QWidget*>(obj)->setBackgroundMode(NoBackground);
+			case TQEvent::Hide:
+				static_cast<TQWidget*>(obj)->setBackgroundMode(NoBackground);
 				return false;
-			case QEvent::ApplicationPaletteChange:
+			case TQEvent::ApplicationPaletteChange:
 				if(obj->isA("PanelKMenu")) {
-					QWidget* w = static_cast<QWidget*>(obj);
-					QPalette pal = qApp->palette();
-					pal.setColor(QColorGroup::ButtonText, alphaBlendColors(_popupMenuColor, pal.active().foreground(), 150));
+					TQWidget* w = static_cast<TQWidget*>(obj);
+					TQPalette pal = tqApp->palette();
+					pal.setColor(TQColorGroup::ButtonText, alphaBlendColors(_popupMenuColor, pal.active().foreground(), 150));
 					w->setPalette(pal);
 					return true;
 				}
@@ -1261,38 +1261,38 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	}
 	
 	
-	if(dynamic_cast<QPushButton*>(obj) && !obj->isA("KDockButton_Private") || dynamic_cast<QToolButton*>(obj) ) {
-		QWidget* w = static_cast<QWidget*>(obj);
+	if(dynamic_cast<TQPushButton*>(obj) && !obj->isA("KDockButton_Private") || dynamic_cast<TQToolButton*>(obj) ) {
+		TQWidget* w = static_cast<TQWidget*>(obj);
 
 		switch(ev->type()) {
-			case QEvent::Enter: {
+			case TQEvent::Enter: {
 				if(!w->isEnabled()) return false;
 				hoverWidget = w;
 				w->repaint(false);
 				return false;
 			}
-			case QEvent::Leave: {
+			case TQEvent::Leave: {
 				if(!w->isEnabled()) return false;
 				hoverWidget = 0;
 				w->repaint(false);
 				return false;
 			}
-			case QEvent::MouseButtonPress: {
-				if(dynamic_cast<QToolButton*>(obj)) {
-					QMouseEvent* e = (QMouseEvent*)ev;
-					if(e->button() == Qt::LeftButton)
+			case TQEvent::MouseButtonPress: {
+				if(dynamic_cast<TQToolButton*>(obj)) {
+					TQMouseEvent* e = (TQMouseEvent*)ev;
+					if(e->button() == TQt::LeftButton)
 						popupMousePressPos = e->pos();
 				}
 				return false;
 			}
-			case QEvent::MouseMove: {
-				QMouseEvent* e = (QMouseEvent*)ev;
-				if(dynamic_cast<QToolButton*>(obj) && popupTimer->isActive() && ((e->pos()-popupMousePressPos).manhattanLength() > 4 /*KGlobalSettings::dndEventDelay()*/))
+			case TQEvent::MouseMove: {
+				TQMouseEvent* e = (TQMouseEvent*)ev;
+				if(dynamic_cast<TQToolButton*>(obj) && popupTimer->isActive() && ((e->pos()-popupMousePressPos).manhattanLength() > 4 /*KGlobalSettings::dndEventDelay()*/))
 					popupToolMenu();
 				return false;
 			}
-			case QEvent::ParentPaletteChange: {
-				if(obj->isA("QToolButton")) {
+			case TQEvent::ParentPaletteChange: {
+				if(obj->isA("TQToolButton")) {
 					
 					if(w->parentWidget() && !khtmlWidgets.contains(w)) {
 						w->setUpdatesEnabled(false);
@@ -1302,7 +1302,7 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 						}
 						else {
 							w->setBackgroundMode(PaletteBackground);
-							w->setBackgroundOrigin(QWidget::WidgetOrigin);
+							w->setBackgroundOrigin(TQWidget::WidgetOrigin);
 							setDominoButtonPalette(w, Palette_Parent);
 						}
 						w->setUpdatesEnabled(true);
@@ -1315,44 +1315,44 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				return true;
 				break;
 			}
-			case QEvent::PaletteChange: {
+			case TQEvent::PaletteChange: {
 				setDominoButtonPalette(w, Palette_Widget);
 				return true;
 			}
-			case QEvent::ApplicationPaletteChange: {
+			case TQEvent::ApplicationPaletteChange: {
 				return true;
 			}
 			default:
 				return false;
 		}
 	}
-	if(obj->isA("QDockWindowHandle") || obj->isA("AppletHandleDrag"))  {
-		if ((ev->type() == QEvent::Enter) &&  static_cast<QWidget*>(obj)->isEnabled()) {
-			QWidget* w = static_cast<QWidget*>(obj);
+	if(obj->isA("TQDockWindowHandle") || obj->isA("AppletHandleDrag"))  {
+		if ((ev->type() == TQEvent::Enter) &&  static_cast<TQWidget*>(obj)->isEnabled()) {
+			TQWidget* w = static_cast<TQWidget*>(obj);
 			hoverWidget = w;
 			w->repaint(true);
 			return false;
 		}
-		if (ev->type() == QEvent::Leave && static_cast<QWidget*>(obj) == hoverWidget) {
+		if (ev->type() == TQEvent::Leave && static_cast<TQWidget*>(obj) == hoverWidget) {
 			hoverWidget = 0;
-			static_cast<QWidget*>(obj)->repaint(true);
+			static_cast<TQWidget*>(obj)->repaint(true);
 			return false;
 		}
 		return false;
 	}
 	
 	if(obj->isA("KDockButton_Private")) {
-		if (ev->type() == QEvent::Paint) {
-			QPixmap* btnPix = 0;
-			QButton* btn = static_cast<QButton*>(obj);
-			if(!(btnPix = QPixmapCache::find(QString::number(btn->paletteBackgroundColor().pixel(), 16)+btn->name()))) {
-				QPixmap* tmpPix = new QPixmap(qembed_findImage(btn->name()));
+		if (ev->type() == TQEvent::Paint) {
+			TQPixmap* btnPix = 0;
+			TQButton* btn = static_cast<TQButton*>(obj);
+			if(!(btnPix = TQPixmapCache::find(TQString::number(btn->paletteBackgroundColor().pixel(), 16)+btn->name()))) {
+				TQPixmap* tmpPix = new TQPixmap(qembed_findImage(btn->name()));
 				if(!tmpPix)
 					return false;
-				btnPix = new QPixmap(12, 24);
+				btnPix = new TQPixmap(12, 24);
 				btnPix->fill(btn->paletteBackgroundColor());
 				bitBlt(btnPix, 0, 0, tmpPix);
-				QPixmapCache::insert(QString::number(btn->paletteBackgroundColor().pixel(), 16)+btn->name(), btnPix);
+				TQPixmapCache::insert(TQString::number(btn->paletteBackgroundColor().pixel(), 16)+btn->name(), btnPix);
 			}
 			
 			if(btn->isOn() || btn->isDown())
@@ -1367,20 +1367,20 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	if(dynamic_cast<KPopupTitle*>(obj)) {
 		
 		switch(ev->type()) {
-			case QEvent::Paint: {
+			case TQEvent::Paint: {
 				
 				KPopupTitle* pt = static_cast<KPopupTitle*>(obj);
-				QRect r = pt->rect();
-				QPainter p(pt);
+				TQRect r = pt->rect();
+				TQPainter p(pt);
 				
 				if(pt->parentWidget() && pt->parentWidget()->paletteBackgroundPixmap()) {
-					QPoint point = QPoint(pt->geometry().x(), pt->geometry().y());
+					TQPoint point = TQPoint(pt->geometry().x(), pt->geometry().y());
 					p.drawTiledPixmap( 0, 0, pt->width(), pt->height(),
 							*pt->parentWidget()->backgroundPixmap(),
 							point.x(), point.y() );
 				}
 				
-				QFont f = p.font();
+				TQFont f = p.font();
 				f.setBold(true);
 				p.setFont(f);
 				
@@ -1398,38 +1398,38 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				return false;
 		}
 	}
-	if(dynamic_cast<QButton*>(obj) && obj->parent() && obj->parent()->isA("QToolBox")) {
-		QWidget* w = dynamic_cast<QWidget*>(obj);
+	if(dynamic_cast<TQButton*>(obj) && obj->parent() && obj->parent()->isA("TQToolBox")) {
+		TQWidget* w = dynamic_cast<TQWidget*>(obj);
 		if(!w->isEnabled())
 			return false;
-		if(ev->type() == QEvent::Enter) {
+		if(ev->type() == TQEvent::Enter) {
 			hoveredToolBoxTab = true;
 			w->repaint(false);
 			return false;
 		}
-		if(ev->type() == QEvent::Leave) {
+		if(ev->type() == TQEvent::Leave) {
 			hoveredToolBoxTab = false;
 			w->repaint(false);
 			return false;
 		}
-		if(ev->type() == QEvent::Move) {
+		if(ev->type() == TQEvent::Move) {
 			hoveredToolBoxTab = false;
 			return false;
 		}
 		return false;
 	}
-	if(dynamic_cast<QHeader*>(obj)) {
+	if(dynamic_cast<TQHeader*>(obj)) {
 		switch(ev->type()) {
-			case QEvent::ApplicationPaletteChange:
-				static_cast<QHeader*>(obj)->setBackgroundMode(Qt::PaletteBackground);
-				setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Application);
+			case TQEvent::ApplicationPaletteChange:
+				static_cast<TQHeader*>(obj)->setBackgroundMode(TQt::PaletteBackground);
+				setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Application);
 				return true;
-			case QEvent::ParentPaletteChange:
-				setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Parent);
+			case TQEvent::ParentPaletteChange:
+				setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Parent);
 				return true;
-			case QEvent::PaletteChange:
-				static_cast<QHeader*>(obj)->setBackgroundMode(Qt::PaletteBackground);
-				setDominoButtonPalette(static_cast<QWidget*>(obj), Palette_Widget);
+			case TQEvent::PaletteChange:
+				static_cast<TQHeader*>(obj)->setBackgroundMode(TQt::PaletteBackground);
+				setDominoButtonPalette(static_cast<TQWidget*>(obj), Palette_Widget);
 				return true;
 			default:
 				return false;
@@ -1437,25 +1437,25 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		return false;
 	}
 	
-	if(dynamic_cast<QDockWindow*>(obj)) {
+	if(dynamic_cast<TQDockWindow*>(obj)) {
 		switch(ev->type()) {
-			case QEvent::LayoutHint: {
-				QDockWindow* dw = dynamic_cast<QDockWindow*>(obj);
+			case TQEvent::LayoutHint: {
+				TQDockWindow* dw = dynamic_cast<TQDockWindow*>(obj);
 				if(!dw->widget())
 					return false;
 				if(!dw->area()) {
-					dw->setFrameStyle(QFrame::Panel|QFrame::Sunken);
+					dw->setFrameStyle(TQFrame::Panel|TQFrame::Sunken);
 					dw->setLineWidth(1);
-					QRect r = dw->rect();
-					QRegion mask(r);
-					mask -= QRegion(0, 0, 1, 1);
-					mask -= QRegion(r.width()-1, 0, 1, 1);
-					mask -= QRegion(0, r.height()-1, 1, 1);
-					mask -= QRegion(r.width()-1, r.height()-1, 1, 1);
+					TQRect r = dw->rect();
+					TQRegion mask(r);
+					mask -= TQRegion(0, 0, 1, 1);
+					mask -= TQRegion(r.width()-1, 0, 1, 1);
+					mask -= TQRegion(0, r.height()-1, 1, 1);
+					mask -= TQRegion(r.width()-1, r.height()-1, 1, 1);
 					dw->setMask(mask);
 				}
-				else if(dw->frameStyle() == QFrame::Panel|QFrame::Sunken) {
-					dw->setFrameStyle(QFrame::StyledPanel|QFrame::Sunken);
+				else if(dw->frameStyle() == TQFrame::Panel|TQFrame::Sunken) {
+					dw->setFrameStyle(TQFrame::StyledPanel|TQFrame::Sunken);
 					dw->setLineWidth(2);
 					dw->clearMask();
 				}
@@ -1465,17 +1465,17 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 				
 		}
 	}
-	else if(obj->isA("QWorkspaceChild")) {
+	else if(obj->isA("TQWorkspaceChild")) {
 		switch(ev->type()) {
-			case QEvent::Show:
-			case QEvent::Resize: {
-				QWidget* w = static_cast<QWidget*>(obj);
-				QRect r = w->rect();
-				QRegion mask(r);
-				mask -= QRegion(0, 0, 1, 1);
-				mask -= QRegion(r.width()-1, 0, 1, 1);
-				mask -= QRegion(0, r.height()-1, 1, 1);
-				mask -= QRegion(r.width()-1, r.height()-1, 1, 1);
+			case TQEvent::Show:
+			case TQEvent::Resize: {
+				TQWidget* w = static_cast<TQWidget*>(obj);
+				TQRect r = w->rect();
+				TQRegion mask(r);
+				mask -= TQRegion(0, 0, 1, 1);
+				mask -= TQRegion(r.width()-1, 0, 1, 1);
+				mask -= TQRegion(0, r.height()-1, 1, 1);
+				mask -= TQRegion(r.width()-1, r.height()-1, 1, 1);
 				w->setMask(mask);
 			}
 			default:
@@ -1483,47 +1483,47 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		}
 	}
 		
-	if(obj->isA("QDockWindowResizeHandle")) {
-		if(ev->type() == QEvent::PaletteChange)
-			static_cast<QWidget*>(obj)->setBackgroundMode(Qt::PaletteBackground);
+	if(obj->isA("TQDockWindowResizeHandle")) {
+		if(ev->type() == TQEvent::PaletteChange)
+			static_cast<TQWidget*>(obj)->setBackgroundMode(TQt::PaletteBackground);
 		return false;
 	}
 		
-	if(obj->isA("QWhatsThat")) { // QWhatsThis
+	if(obj->isA("TQWhatsThat")) { // TQWhatsThis
 		
-		if (ev->type() == QEvent::Show) {
-			QWidget* w = dynamic_cast<QWidget*>(obj);
-			w->setBackgroundMode(Qt::NoBackground);
-			QRect r = w->rect();
-			QRegion mask(r.x()+3, r.y(), r.width()-6, r.height());
-			mask += QRegion(r.x()+2, r.y()+1, r.width()-4, r.height()-2);
-			mask += QRegion(r.x()+1, r.y()+2, r.width()-2, r.height()-4);
-			mask += QRegion(r.x(), r.y()+3, r.width(), r.height()-6);
+		if (ev->type() == TQEvent::Show) {
+			TQWidget* w = dynamic_cast<TQWidget*>(obj);
+			w->setBackgroundMode(TQt::NoBackground);
+			TQRect r = w->rect();
+			TQRegion mask(r.x()+3, r.y(), r.width()-6, r.height());
+			mask += TQRegion(r.x()+2, r.y()+1, r.width()-4, r.height()-2);
+			mask += TQRegion(r.x()+1, r.y()+2, r.width()-2, r.height()-4);
+			mask += TQRegion(r.x(), r.y()+3, r.width(), r.height()-6);
 			w->setMask(mask);
 			return true;
 		}
 		
-		if (ev->type() == QEvent::Paint) {
-			DominoQWhatsThat* dwt = (DominoQWhatsThat*)obj;
-			QString text = dwt->text;
-			QRect r = dwt->rect();
+		if (ev->type() == TQEvent::Paint) {
+			DominoTQWhatsThat* dwt = (DominoTQWhatsThat*)obj;
+			TQString text = dwt->text;
+			TQRect r = dwt->rect();
 			
 			int x = r.x();
 			int y = r.y();
 			int w = r.width();
 			int h = r.height();
 			
-			QRegion mask(x+1, y+4, w-2, h-8);
-			mask += QRegion(x+2, y+3, w-4, h-6);
-			mask += QRegion(x+3, y+2, w-6, h-4);
-			mask += QRegion(x+4, y+1, w-8, h-2);
+			TQRegion mask(x+1, y+4, w-2, h-8);
+			mask += TQRegion(x+2, y+3, w-4, h-6);
+			mask += TQRegion(x+3, y+2, w-6, h-4);
+			mask += TQRegion(x+4, y+1, w-8, h-2);
 			
-			QPainter p(dwt);
+			TQPainter p(dwt);
 			p.setClipRegion(mask);
-			renderGradient(&p, QRect(r.left(), r.top(), r.width(), r.height()), _toolTipColor.light(110), _toolTipColor.dark(105), true);
+			renderGradient(&p, TQRect(r.left(), r.top(), r.width(), r.height()), _toolTipColor.light(110), _toolTipColor.dark(105), true);
 			p.setClipping(false);
 			
-			QColor tabContour2 = qApp->palette().active().background().dark(150);
+			TQColor tabContour2 = tqApp->palette().active().background().dark(150);
 			
 			p.save();
 			p.setPen(tabContour2);
@@ -1540,9 +1540,9 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 			
 			r.addCoords( 12, 8, -12, -8 );
 			
-			if(QStyleSheet::mightBeRichText( text )) {
-				QSimpleRichText* srt = new QSimpleRichText( text, dwt->font());
-				srt->draw(&p, r.x(), r.y(), r, qApp->palette().active(), 0);
+			if(TQStyleSheet::mightBeRichText( text )) {
+				TQSimpleRichText* srt = new TQSimpleRichText( text, dwt->font());
+				srt->draw(&p, r.x(), r.y(), r, tqApp->palette().active(), 0);
 			}
 			else {
 				r.addCoords( 2, 3, 0, 0 );
@@ -1557,57 +1557,57 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 	
 	if(obj->isA("KonqFileTip")) {
 		
-		if (ev->type() == QEvent::Show || ev->type() == QEvent::Paint) {
+		if (ev->type() == TQEvent::Show || ev->type() == TQEvent::Paint) {
 			
-			QWidget* widget = dynamic_cast<QWidget*>(obj);
-			QRect r = widget->rect();
+			TQWidget* widget = dynamic_cast<TQWidget*>(obj);
+			TQRect r = widget->rect();
 			
-			QPixmap pix(r.size());
-			QPainter p(&pix);
-			renderGradient(&p, QRect(r.left(), r.top(), r.width(), r.height()), _toolTipColor.light(110), _toolTipColor.dark(105), true);
+			TQPixmap pix(r.size());
+			TQPainter p(&pix);
+			renderGradient(&p, TQRect(r.left(), r.top(), r.width(), r.height()), _toolTipColor.light(110), _toolTipColor.dark(105), true);
 			
-			if(ev->type() == QEvent::Show) {
-				dynamic_cast<QFrame*>(widget)->setFrameStyle(QFrame::NoFrame);
-				widget->setBackgroundMode(Qt::NoBackground);
-				
-				QRegion mask(r.x()+3, r.y(), r.width()-6, r.height());
-				mask += QRegion(r.x()+2, r.y()+1, r.width()-4, r.height()-2);
-				mask += QRegion(r.x()+1, r.y()+2, r.width()-2, r.height()-4);
-				mask += QRegion(r.x(), r.y()+3, r.width(), r.height()-6);
-				dynamic_cast<QFrame*>(widget)->setMask(mask);
-				
-				QObjectList *list = const_cast<QObjectList *>(widget->children());
-				QObjectListIt it( *list );
-				QObject * o;
+			if(ev->type() == TQEvent::Show) {
+				dynamic_cast<TQFrame*>(widget)->setFrameStyle(TQFrame::NoFrame);
+				widget->setBackgroundMode(TQt::NoBackground);
+				
+				TQRegion mask(r.x()+3, r.y(), r.width()-6, r.height());
+				mask += TQRegion(r.x()+2, r.y()+1, r.width()-4, r.height()-2);
+				mask += TQRegion(r.x()+1, r.y()+2, r.width()-2, r.height()-4);
+				mask += TQRegion(r.x(), r.y()+3, r.width(), r.height()-6);
+				dynamic_cast<TQFrame*>(widget)->setMask(mask);
+				
+				TQObjectList *list = const_cast<TQObjectList *>(widget->children());
+				TQObjectListIt it( *list );
+				TQObject * o;
 				while ( (o = it.current()) != 0 ) {
 					++it;
-					if(dynamic_cast<QLabel*>(o)) {
-						QLabel* l = dynamic_cast<QLabel*>(o);
-						l->setBackgroundOrigin(QWidget::ParentOrigin);
+					if(dynamic_cast<TQLabel*>(o)) {
+						TQLabel* l = dynamic_cast<TQLabel*>(o);
+						l->setBackgroundOrigin(TQWidget::ParentOrigin);
 						l->setPaletteBackgroundPixmap(pix);
 					}
 				}
 			}
 			p.end();
 			
-			if(ev->type() == QEvent::Paint) {
+			if(ev->type() == TQEvent::Paint) {
 				
 				int x = r.x();
 				int y = r.y();
 				int w = r.width();
 				int h = r.height();
 				
-				QRegion mask(x+1, y+4, w-2, h-8);
-				mask += QRegion(x+2, y+3, w-4, h-6);
-				mask += QRegion(x+3, y+2, w-6, h-4);
-				mask += QRegion(x+4, y+1, w-8, h-2);
+				TQRegion mask(x+1, y+4, w-2, h-8);
+				mask += TQRegion(x+2, y+3, w-4, h-6);
+				mask += TQRegion(x+3, y+2, w-6, h-4);
+				mask += TQRegion(x+4, y+1, w-8, h-2);
 				
 				p.begin(widget);
 				p.setClipRegion(mask);
 				p.drawPixmap(0, 0, pix);
 				p.setClipping(false);
 				
-				QColor tabContour2 = qApp->palette().active().background().dark(150);
+				TQColor tabContour2 = tqApp->palette().active().background().dark(150);
 				p.setPen(tabContour2);
 				p.drawLine(x+7,y, w-8,y); // top
 				p.drawLine(x+7,h-1, w-8,h-1); // bottom
@@ -1626,26 +1626,26 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		return false;
 	}
 	
-	if(obj->isA("QTipLabel")) {
+	if(obj->isA("TQTipLabel")) {
 		
-		if (ev->type() == QEvent::Show) {
-			QLabel* l = dynamic_cast<QLabel*>(obj);
+		if (ev->type() == TQEvent::Show) {
+			TQLabel* l = dynamic_cast<TQLabel*>(obj);
 			l->resize( l->width()+2, l->height()+2);
-			l->setBackgroundMode(Qt::NoBackground);
+			l->setBackgroundMode(TQt::NoBackground);
 			int x, y, w, h;
 			l->rect().rect(&x, &y, &w, &h);
 			
-			QRegion mask(x, y+3, w, h-6);
-			mask += QRegion(x+1, y+2, w-2, h-4);
-			mask += QRegion(x+2, y+1, w-4, h-2);
-			mask += QRegion(x+3, y, w-6, h);
+			TQRegion mask(x, y+3, w, h-6);
+			mask += TQRegion(x+1, y+2, w-2, h-4);
+			mask += TQRegion(x+2, y+1, w-4, h-2);
+			mask += TQRegion(x+3, y, w-6, h);
 			l->setMask(mask);
 			return true;
 		}
-		if (ev->type() == QEvent::Paint) {
+		if (ev->type() == TQEvent::Paint) {
 			
-			QLabel* label = dynamic_cast<QLabel*>(obj);
-			QRect r = label->rect();
+			TQLabel* label = dynamic_cast<TQLabel*>(obj);
+			TQRect r = label->rect();
 			
 			int x = r.x();
 			int y = r.y();
@@ -1653,18 +1653,18 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 			int h = r.height();
 			
 			// one pixel smaler as the mask
-			QRegion mask(x+1, y+4, w-2, h-8);
-			mask += QRegion(x+2, y+3, w-4, h-6);
-			mask += QRegion(x+3, y+2, w-6, h-4);
-			mask += QRegion(x+4, y+1, w-8, h-2);
+			TQRegion mask(x+1, y+4, w-2, h-8);
+			mask += TQRegion(x+2, y+3, w-4, h-6);
+			mask += TQRegion(x+3, y+2, w-6, h-4);
+			mask += TQRegion(x+4, y+1, w-8, h-2);
 			
-			QPainter p(label);
+			TQPainter p(label);
 			p.setClipRegion(mask);
 			
-			renderGradient(&p, QRect(r.left(), r.top(), r.width(), r.height()), _toolTipColor.light(110), _toolTipColor.dark(105), true);
+			renderGradient(&p, TQRect(r.left(), r.top(), r.width(), r.height()), _toolTipColor.light(110), _toolTipColor.dark(105), true);
 			p.setClipping(false);
 			
-			QColor tabContour2 = qApp->palette().active().background().dark(150);
+			TQColor tabContour2 = tqApp->palette().active().background().dark(150);
 			p.setPen(tabContour2);
 			p.drawLine(x+7,y, w-8,y); // top
 			p.drawLine(x+7,h-1, w-8,h-1); // bottom
@@ -1676,20 +1676,20 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 			bitBlt(label, x, h-7, border1, 0, 7, 7, 7);
 			bitBlt(label, w-7, h-7, border1, 7, 7, 7, 7);
 			
-			QSimpleRichText* srt = new QSimpleRichText(label->text(), label->font());
+			TQSimpleRichText* srt = new TQSimpleRichText(label->text(), label->font());
 			srt->setWidth(r.width()-5);
-			srt->draw(&p, r.x()+4, r.y(), r, qApp->palette().active(),0);
+			srt->draw(&p, r.x()+4, r.y(), r, tqApp->palette().active(),0);
 			delete srt;
 		}
 		return true;
 	}
-	if(obj->isA("QViewportWidget") && dynamic_cast<QTextEdit*>(obj->parent())) {
+	if(obj->isA("TQViewportWidget") && dynamic_cast<TQTextEdit*>(obj->parent())) {
 		switch(ev->type()) {
-			case QEvent::MouseButtonPress:
-			case 6/*QEvent::KeyPress*/: {
-				QTextEdit* te = dynamic_cast<QTextEdit*>(obj->parent());
+			case TQEvent::MouseButtonPress:
+			case 6/*TQEvent::KeyPress*/: {
+				TQTextEdit* te = dynamic_cast<TQTextEdit*>(obj->parent());
 				if(te->isEnabled() && !te->isReadOnly())
-					static_cast<QWidget*>(obj)->setCursor(Qt::blankCursor);
+					static_cast<TQWidget*>(obj)->setCursor(TQt::blankCursor);
 				return false;
 			}
 			default:
@@ -1697,46 +1697,46 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 		}
 	}
 
-	if (dynamic_cast<QFrame*>(obj)) { // at last because other widgets may include a frame.
+	if (dynamic_cast<TQFrame*>(obj)) { // at last because other widgets may include a frame.
 		
-		QFrame* f = dynamic_cast<QFrame*>(obj);
-		const QRect r = f->rect();
+		TQFrame* f = dynamic_cast<TQFrame*>(obj);
+		const TQRect r = f->rect();
 		
-		if (ev->type() == QEvent::Paint) {
+		if (ev->type() == TQEvent::Paint) {
 			
 			switch(f->frameShape()){
-				case QFrame::HLine: {
-					QPainter p(f);
+				case TQFrame::HLine: {
+					TQPainter p(f);
 // 					p.setPen(f->paletteBackgroundColor().dark(120));
 					p.setPen(alphaBlendColors(f->paletteForegroundColor(), f->paletteBackgroundColor(), 40));
 					p.drawLine(0,0,f->frameRect().width(),0);
 					return true;
 				}
-				case QFrame::VLine: {
-					QPainter p(f);
+				case TQFrame::VLine: {
+					TQPainter p(f);
 					p.setPen(alphaBlendColors(f->paletteForegroundColor(), f->paletteBackgroundColor(), 40));
 					p.drawLine(0,0,0,f->frameRect().height());
 					return true;
 				}
-				case QFrame::WinPanel:
-				case QFrame::Panel: {
+				case TQFrame::WinPanel:
+				case TQFrame::Panel: {
 					if(f->parentWidget() && f->parentWidget()->isA("KDockSplitter")) {
 						
 						if(!f->erasePixmap()) {
 							bool horizontal = (r.width() > r.height());
-							QPixmap pix(r.size());
-							QPainter p(&pix);
+							TQPixmap pix(r.size());
+							TQPainter p(&pix);
 							renderGradient(&p, r, lightenColor(f->paletteBackgroundColor(), 40), darkenColor(f->paletteBackgroundColor(), 30), horizontal);
 							f->setErasePixmap(pix);
 						}
 						return true;
 					}
 					
-					QPainter p(f);
-					QColor frameColor;
-					if(f->frameShape() == QFrame::Panel && f->frameShadow() == QFrame::Plain) // used as a selection in kspread
+					TQPainter p(f);
+					TQColor frameColor;
+					if(f->frameShape() == TQFrame::Panel && f->frameShadow() == TQFrame::Plain) // used as a selection in kspread
 						frameColor = f->paletteBackgroundColor().dark(160);
-					else if(dynamic_cast<QListBox*>(obj) && dynamic_cast<QComboBox*>(obj->parent()))
+					else if(dynamic_cast<TQListBox*>(obj) && dynamic_cast<TQComboBox*>(obj->parent()))
 						frameColor = f->paletteBackgroundColor().dark(190);
 					else
 						frameColor = f->paletteBackgroundColor().dark(120);
@@ -1745,34 +1745,34 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 					p.setPen(frameColor);
 					p.drawRect(f->rect());
 					
-					QPaintEvent* e = (QPaintEvent*)ev;
+					TQPaintEvent* e = (TQPaintEvent*)ev;
 					p.setClipRegion(e->region().intersect(f->contentsRect()));
-					DominoQFrame* df = (DominoQFrame*)f;
+					DominoTQFrame* df = (DominoTQFrame*)f;
 					df->drawContents(&p);
 					
-					DominoQWidget* dw = (DominoQWidget*)f;
-					QPaintEvent* event = new QPaintEvent(e->region().intersect(f->contentsRect()));
+					DominoTQWidget* dw = (DominoTQWidget*)f;
+					TQPaintEvent* event = new TQPaintEvent(e->region().intersect(f->contentsRect()));
 					dw->paintEvent(event);
 					return true;
 				}
-				case QFrame::ToolBarPanel: {
+				case TQFrame::ToolBarPanel: {
 					if(f->isA("KonqSidebarTree")) {
-						QPainter p(f);
-						p.setPen(qApp->palette().active().background().dark(120));
+						TQPainter p(f);
+						p.setPen(tqApp->palette().active().background().dark(120));
 						p.drawRect(f->rect());
 						return true;
 					}
 					return false;
 				}
-				case QFrame::Box: {
+				case TQFrame::Box: {
 					if(f->parentWidget() && !strcmp(f->parentWidget()->name(), "KonqFrame")) {
-						QPainter p(f);
-						p.fillRect(r.width()-16, r.height()-16, 15, 15, qApp->palette().active().background()); // 15x15 scrollview cornerwidget gap
+						TQPainter p(f);
+						p.fillRect(r.width()-16, r.height()-16, 15, 15, tqApp->palette().active().background()); // 15x15 scrollview cornerwidget gap
 						return true;
 					}
 					else if(konquerorMode && f->isA("KHTMLView")) {
-						QPainter p(f);
-						p.setPen(qApp->palette().active().background().dark(120));
+						TQPainter p(f);
+						p.setPen(tqApp->palette().active().background().dark(120));
 						p.drawRect(f->rect());
 						return true;
 					}
@@ -1782,39 +1782,39 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 			}
 		}
 		
-		if (ev->type() == QEvent::Show || ev->type() == QEvent::ApplicationPaletteChange) { // ApplicationPaletteChange for style changes
+		if (ev->type() == TQEvent::Show || ev->type() == TQEvent::ApplicationPaletteChange) { // ApplicationPaletteChange for style changes
 			
 			switch(f->frameShape()){
-				case QFrame::TabWidgetPanel:
-					if(ev->type() == QEvent::ApplicationPaletteChange) {
+				case TQFrame::TabWidgetPanel:
+					if(ev->type() == TQEvent::ApplicationPaletteChange) {
 						
 						if(f->lineWidth() != 4)
 							f->setLineWidth(4);
-						if(f->frameRect() != QRect(0, 0, f->width(), f->height()-1))
-							f->setFrameRect(QRect(0, 0, f->width(), f->height()-1));
+						if(f->frameRect() != TQRect(0, 0, f->width(), f->height()-1))
+							f->setFrameRect(TQRect(0, 0, f->width(), f->height()-1));
 						if(f->margin() != 0)
 							f->setMargin(0);
 						
-						QWidget* w = f->parentWidget();
+						TQWidget* w = f->parentWidget();
 						for(int i=0; i<3; i++) { // the third parentcheck is for the tabWidget on kcm khtml_plugins
 							if(!w) break;
-							if(dynamic_cast<QGroupBox*>(w)) {
-								f->setPaletteBackgroundColor(qApp->palette().active().background());
+							if(dynamic_cast<TQGroupBox*>(w)) {
+								f->setPaletteBackgroundColor(tqApp->palette().active().background());
 								break;
 							}
 							w = w->parentWidget();
 						}
 					}
 					return true;
-				case QFrame::Box:
+				case TQFrame::Box:
 					if(f->parentWidget() && !strcmp(f->parentWidget()->name(), "KonqFrame")) {
-						f->setEraseColor(qApp->palette().active().background().dark(120));
+						f->setEraseColor(tqApp->palette().active().background().dark(120));
 						f->erase();
 						return true;
 					}
-				case QFrame::Panel:
-					if(ev->type() == QEvent::ApplicationPaletteChange && f->parentWidget() && f->parentWidget()->isA("KDockSplitter")) {
-						f->setBackgroundMode(Qt::PaletteBackground);
+				case TQFrame::Panel:
+					if(ev->type() == TQEvent::ApplicationPaletteChange && f->parentWidget() && f->parentWidget()->isA("KDockSplitter")) {
+						f->setBackgroundMode(TQt::PaletteBackground);
 						return true;
 					}
 				default:
@@ -1822,11 +1822,11 @@ bool DominoStyle::eventFilter(QObject *obj, QEvent *ev)
 			}
 			return false;
 		}
-		if(ev->type() == QEvent::LayoutHint && f->frameShape() == QFrame::TabWidgetPanel) { // don't look broken in kcm stylePreview
+		if(ev->type() == TQEvent::LayoutHint && f->frameShape() == TQFrame::TabWidgetPanel) { // don't look broken in kcm stylePreview
 			if(f->lineWidth() != 4)
 				f->setLineWidth(4);
-			if(f->frameRect() != QRect(0, 0, f->width(), f->height()-1))
-				f->setFrameRect(QRect(0, 0, f->width(), f->height()-1));
+			if(f->frameRect() != TQRect(0, 0, f->width(), f->height()-1))
+				f->setFrameRect(TQRect(0, 0, f->width(), f->height()-1));
 			if(f->margin() != 0)
 				f->setMargin(0);
 			
diff --git a/domino/misc.cpp b/domino/misc.cpp
index b5b337f..f94f414 100644
--- a/domino/misc.cpp
+++ b/domino/misc.cpp
@@ -18,10 +18,10 @@
  * Boston, MA 02111-1307, USA.
  */
 
-#include <qcolor.h>
+#include <tqcolor.h>
 #include "misc.h"
-#include <qimage.h>
-#include <qpixmap.h>
+#include <tqimage.h>
+#include <tqpixmap.h>
 #include <endian.h>
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
@@ -36,33 +36,33 @@
 
 
 
-QColor alphaBlendColors(const QColor &bgColor, const QColor &fgColor, const int a)
+TQColor alphaBlendColors(const TQColor &bgColor, const TQColor &fgColor, const int a)
 {
-	QRgb rgb = bgColor.rgb();
-	QRgb rgb_b = fgColor.rgb();
+	TQRgb rgb = bgColor.rgb();
+	TQRgb rgb_b = fgColor.rgb();
 	uint alpha;
 	if(a > 255) alpha = 255;
 	else if(a < 0) alpha = 0;
 	else alpha = a;
 	uint inv_alpha = 255 - alpha;
 	
-	return QColor((qRed(rgb_b)*inv_alpha + qRed(rgb)*alpha)>>8,
-				(qGreen(rgb_b)*inv_alpha + qGreen(rgb)*alpha)>>8,
-				(qBlue(rgb_b)*inv_alpha + qBlue(rgb)*alpha)>>8 );
+	return TQColor((tqRed(rgb_b)*inv_alpha + tqRed(rgb)*alpha)>>8,
+				(tqGreen(rgb_b)*inv_alpha + tqGreen(rgb)*alpha)>>8,
+				(tqBlue(rgb_b)*inv_alpha + tqBlue(rgb)*alpha)>>8 );
 }
 
-QColor blendColors(const QColor &bgColor, const QColor &fgColor)
+TQColor blendColors(const TQColor &bgColor, const TQColor &fgColor)
 {
 	
 	uint fg_r = fgColor.red();
 	uint fg_g = fgColor.green();
 	uint fg_b = fgColor.blue();
-	uint fg_a = qAlpha(fgColor.rgb());
+	uint fg_a = tqAlpha(fgColor.rgb());
 	
 	uint bg_r = bgColor.red();
 	uint bg_g = bgColor.green();
 	uint bg_b = bgColor.blue();
-	uint bg_a = qAlpha(bgColor.rgb());
+	uint bg_a = tqAlpha(bgColor.rgb());
 	
 	uint ac = 65025 - (255 - fg_a) * (255 - bg_a);
 	uint res_r = ((255 - fg_a) * bg_r * bg_a + fg_a * fg_r  * 255 + 127) / ac;
@@ -70,37 +70,37 @@ QColor blendColors(const QColor &bgColor, const QColor &fgColor)
 	uint res_b = ((255 - fg_a) * bg_b * bg_a + fg_a * fg_b  * 255 + 127) / ac;
 	uint res_a = (ac+127)/255;
 	
-	return QColor(qRgba(res_r,res_g, res_b, res_a ));
+	return TQColor(tqRgba(res_r,res_g, res_b, res_a ));
 }
 
-QImage tintImage(const QImage &img, const QColor &tintColor) {
+TQImage tintImage(const TQImage &img, const TQColor &tintColor) {
 	
-	QImage *result = new QImage(img.width(), img.height(), 32, 0, QImage::IgnoreEndian);
+	TQImage *result = new TQImage(img.width(), img.height(), 32, 0, TQImage::IgnoreEndian);
 	result->setAlphaBuffer( true );
 	register uint *data = (unsigned int*) img.bits();
 	register uint *resultData = (unsigned int*) result->bits();
 	register uint total = img.width()*img.height();
 	for ( uint current = 0 ; current < total ; ++current ) {
-		resultData[ current ] = qRgba( tintColor.red(), tintColor.green(), tintColor.blue(), qAlpha( data[ current ] ));
+		resultData[ current ] = tqRgba( tintColor.red(), tintColor.green(), tintColor.blue(), tqAlpha( data[ current ] ));
 	}
 	return *result;
 }
 
-QImage setImageOpacity(const QImage &img, const uint &p) {
-	QImage *result = new QImage(img.width(), img.height(), 32, 0, QImage::IgnoreEndian);
+TQImage setImageOpacity(const TQImage &img, const uint &p) {
+	TQImage *result = new TQImage(img.width(), img.height(), 32, 0, TQImage::IgnoreEndian);
 	result->setAlphaBuffer( true );
 	register uint *data = (unsigned int*) img.bits();
 	register uint *resultData = (unsigned int*) result->bits();
 	register uint alpha;
 	register uint total = img.width()*img.height();
 	for ( uint current = 0 ; current < total ; ++current ) {
-		alpha = qAlpha( data[ current ] ) * p / 100;
-		resultData[ current ] = qRgba( qRed( data[ current ] ), qGreen( data[ current ] ), qBlue( data[ current ] ), alpha );
+		alpha = tqAlpha( data[ current ] ) * p / 100;
+		resultData[ current ] = tqRgba( tqRed( data[ current ] ), tqGreen( data[ current ] ), tqBlue( data[ current ] ), alpha );
 	}
 	return *result;
 }
 
-bool blend( const QImage & upper, const QImage & lower, QImage & output)
+bool blend( const TQImage & upper, const TQImage & lower, TQImage & output)
 // adopted from kimageeffect::blend - that is not endian safe and cannot handle complex alpha combinations...
 {
 	if
diff --git a/domino/misc.h b/domino/misc.h
index 18026b5..08c650c 100644
--- a/domino/misc.h
+++ b/domino/misc.h
@@ -20,9 +20,9 @@
 #ifndef __MISC_H
 #define __MISC_H
 
-QColor blendColors(const QColor &backgroundColor, const QColor &foregroundColor);
-QColor alphaBlendColors(const QColor &backgroundColor, const QColor &foregroundColor, const int alpha);
-QImage tintImage(const QImage &img, const QColor &tintColor);
-QImage setImageOpacity(const QImage &img, const uint &p);
-bool blend( const QImage & upper, const QImage & lower, QImage & output);
+TQColor blendColors(const TQColor &backgroundColor, const TQColor &foregroundColor);
+TQColor alphaBlendColors(const TQColor &backgroundColor, const TQColor &foregroundColor, const int alpha);
+TQImage tintImage(const TQImage &img, const TQColor &tintColor);
+TQImage setImageOpacity(const TQImage &img, const uint &p);
+bool blend( const TQImage & upper, const TQImage & lower, TQImage & output);
 #endif // __MISC_H