Port gtk-qt-engine to TQt4

This enables compilation under both Qt3 and Qt4


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/gtk-qt-engine@1230499 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 518 insertions, 518 deletions

diff --git a/src/qt_qt_wrapper.cpp b/src/qt_qt_wrapper.cpp
index 6ca87fb..9eb3c47 100644
--- a/src/qt_qt_wrapper.cpp
+++ b/src/qt_qt_wrapper.cpp
@@ -1,20 +1,20 @@
-#include <qstyle.h>
-#include <qpainter.h>
-#include <qpushbutton.h>
-#include <qimage.h>
-#include <qstylefactory.h>
-#include <qtabbar.h>
-#include <qcheckbox.h>
-#include <qradiobutton.h>
-#include <qscrollbar.h>
-#include <qmenubar.h>
-#include <qcombobox.h>
-#include <qprogressbar.h>
-#include <qslider.h>
-#include <qtoolbutton.h>
-#include <qapplication.h>
-#include <qdir.h>
-#include <qregexp.h>
+#include <tqstyle.h>
+#include <tqpainter.h>
+#include <tqpushbutton.h>
+#include <tqimage.h>
+#include <tqstylefactory.h>
+#include <tqtabbar.h>
+#include <tqcheckbox.h>
+#include <tqradiobutton.h>
+#include <tqscrollbar.h>
+#include <tqmenubar.h>
+#include <tqcombobox.h>
+#include <tqprogressbar.h>
+#include <tqslider.h>
+#include <tqtoolbutton.h>
+#include <tqapplication.h>
+#include <tqdir.h>
+#include <tqregexp.h>
 
 #undef signals
 #include <gdk/gdkx.h>
@@ -40,41 +40,41 @@
 #include "qt_qt_wrapper.h"
 #include "qt_style.h"
 
-#define RC_CACHE_VERSION QString("1")
+#define RC_CACHE_VERSION TQString("1")
 
 
-bool gtkQtEnable = false;
+bool gtkTQtEnable = false;
 bool mozillaFix = false;
-bool qAppOwner = false;
+bool tqAppOwner = false;
 
-QStringList appDirList;
-typedef QMap<QString, QString> IconMap;
+TQStringList appDirList;
+typedef TQMap<TQString, TQString> IconMap;
 IconMap iconMap[4];
 extern int errno;
 
-QScrollBar* scrollBar = 0;
-QWidget* meepWidget = 0;
-QWidget* meepWidgetP = 0;
-QSlider* meepSlider = 0;
-QTabBar* meepTabBar = 0;
+TQScrollBar* scrollBar = 0;
+TQWidget* meepWidget = 0;
+TQWidget* meepWidgetP = 0;
+TQSlider* meepSlider = 0;
+TQTabBar* meepTabBar = 0;
 GdkGC* altBackGC = 0;
-QWidget* smw = 0;
+TQWidget* smw = 0;
 
 GtkRcStyle* gtkRcStyle = 0;
 
-QStringList kdeSearchPaths;
-QString iconTheme;
-QStringList iconThemeDirs;
-QColor alternateBackgroundColour;
+TQStringList kdeSearchPaths;
+TQString iconTheme;
+TQStringList iconThemeDirs;
+TQColor alternateBackgroundColour;
 int showIconsOnButtons;
 int toolbarStyle;
 
-const QPixmap* backgroundTile;
+const TQPixmap* backgroundTile;
 GdkPixmap* backgroundTileGdk;
-QPixmap* menuBackgroundPixmap;
+TQPixmap* menuBackgroundPixmap;
 GdkPixmap* menuBackgroundPixmapGdk;
 
-QPixmap* fillPixmap;
+TQPixmap* fillPixmap;
 
 int scrollBarSpacingLeft = 0;
 int scrollBarSpacingRight = 0;
@@ -86,14 +86,14 @@ int isDomino;
 int isPolyester;
 int eclipseFix;
 int openOfficeFix;
-int gtkQtDebug;
+int gtkTQtDebug;
 
 Atom kipcCommAtom;
 Atom desktopWindowAtom;
 
 void setFillPixmap(GdkPixbuf* buf)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	// This code isn't very robust.  It doesn't handle depths other than 24 bits.
@@ -106,7 +106,7 @@ void setFillPixmap(GdkPixbuf* buf)
 	if (depth != 24)
 		return;
 	
-	QImage fillImage(width, height, 32);
+	TQImage fillImage(width, height, 32);
 	
 	uchar* source = gdk_pixbuf_get_pixels(buf);
 	uchar* dest = fillImage.bits();
@@ -130,7 +130,7 @@ void setFillPixmap(GdkPixbuf* buf)
 	if (fillPixmap)
 		delete fillPixmap;
 	fillPixmap = 0;
-	fillPixmap = new QPixmap();
+	fillPixmap = new TQPixmap();
 	fillPixmap->convertFromImage(fillImage);
 	return;
 }
@@ -151,7 +151,7 @@ static int dummy_xio_errhandler( Display * )
 	return 0;
 }
 
-void createQApp()
+void createTQApp()
 {
 	int argc = 1;
 	char** argv;
@@ -160,7 +160,7 @@ void createQApp()
 	argv[0] = (char*) malloc(sizeof(char) * 19);
 	strncpy(argv[0], "gtk-qt-application", 19);
 	
-	QString cmdLine;
+	TQString cmdLine;
 	
 #ifdef USE_FREEBSD
 /* 
@@ -205,7 +205,7 @@ void createQApp()
 	}
 	if (ret == -1) 
 	{
-		printf("Gtk-Qt theme engine warning:\n");
+		printf("Gtk-TQt theme engine warning:\n");
 		printf(msg);
 		printf("  This may cause problems for the GNOME window manager\n");
 	}       
@@ -289,18 +289,18 @@ void createQApp()
 	
 	if (ret == -1)
 	{
-		printf("Gtk-Qt theme engine warning:\n");
+		printf("Gtk-TQt theme engine warning:\n");
 		printf(msg);
 		printf("  This may cause problems for the GNOME window manager\n");
 	}
 #else // USE_SOLARIS
 #ifndef USE_FREEBSD
-	QCString cmdlinePath;
+	TQCString cmdlinePath;
 	cmdlinePath.sprintf("/proc/%d/cmdline", getpid());
 	int fd = open(cmdlinePath, O_RDONLY);
 	if (fd == -1)
 	{
-		printf("Gtk-Qt theme engine warning:\n");
+		printf("Gtk-TQt theme engine warning:\n");
 		printf("  Could not open %s\n", (const char*)cmdlinePath);
 		printf("  This may cause problems for the GNOME window manager\n");
 	}
@@ -319,7 +319,7 @@ void createQApp()
 #endif // USE_FREEBSD
 #endif // USE_SOLARIS
 
-	mozillaFix = (cmdLine.contains("mozilla") || cmdLine.contains("firefox"));
+	mozillaFix = (cmdLine.tqcontains("mozilla") || cmdLine.tqcontains("firefox"));
 	
 	openOfficeFix = (cmdLine.endsWith("soffice.bin"))
 	              | (cmdLine.endsWith("swriter.bin"))
@@ -328,17 +328,17 @@ void createQApp()
 	              | (cmdLine.endsWith("spadmin.bin"))
 	              | (cmdLine.endsWith("simpress.bin"));
 
-	eclipseFix = cmdLine.contains("eclipse");
+	eclipseFix = cmdLine.tqcontains("eclipse");
 	
-	gtkQtDebug = (getenv("GTK_QT_ENGINE_DEBUG") != NULL) ? 1 : 0;
+	gtkTQtDebug = (getenv("GTK_TQT_ENGINE_DEBUG") != NULL) ? 1 : 0;
 	
-	if (gtkQtDebug)
-		printf("createQApp()\n");
+	if (gtkTQtDebug)
+		printf("createTQApp()\n");
 	
 	char* sessionEnv = getenv("SESSION_MANAGER");
-	if (QString(sessionEnv).endsWith(QString::number(getpid())) || cmdLine.contains("nspluginviewer") || cmdLine.contains("gnome-wm") || cmdLine.contains("metacity") || cmdLine.contains("xfwm4") || (getenv("GTK_QT_ENGINE_DISABLE") != NULL))
+	if (TQString(sessionEnv).endsWith(TQString::number(getpid())) || cmdLine.tqcontains("nspluginviewer") || cmdLine.tqcontains("gnome-wm") || cmdLine.tqcontains("metacity") || cmdLine.tqcontains("xfwm4") || (getenv("GTK_TQT_ENGINE_DISABLE") != NULL))
 	{
-		printf("Not initializing the Gtk-Qt theme engine\n");
+		printf("Not initializing the Gtk-TQt theme engine\n");
 	}
 	else
 	{
@@ -355,10 +355,10 @@ void createQApp()
 		
 		initKdeSettings();
 		
-		if (!qApp)
+		if (!tqApp)
 		{
-			new QApplication(gdk_x11_get_default_xdisplay());
-			qAppOwner = true;
+			new TQApplication(gdk_x11_get_default_xdisplay());
+			tqAppOwner = true;
 		}
 
 #ifndef USE_SOLARIS
@@ -372,29 +372,29 @@ void createQApp()
 		XSetErrorHandler( original_x_errhandler );
 		XSetIOErrorHandler( original_xio_errhandler );
 		
-		gtkQtEnable = true;
+		gtkTQtEnable = true;
 	}
 	
 	free(argv[0]);
 	free(argv);
 	
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
-	isBaghira   = (QString(qApp->style().name()).lower() == "baghira");
-	isKeramik   = (QString(qApp->style().name()).lower() == "keramik");
-	isAlloy     = (QString(qApp->style().name()).lower() == "alloy");
-	isDomino    = (QString(qApp->style().name()).lower() == "domino");
-	isPolyester = (QString(qApp->style().name()).lower() == "polyester");
+	isBaghira   = (TQString(tqApp->tqstyle().name()).lower() == "baghira");
+	isKeramik   = (TQString(tqApp->tqstyle().name()).lower() == "keramik");
+	isAlloy     = (TQString(tqApp->tqstyle().name()).lower() == "alloy");
+	isDomino    = (TQString(tqApp->tqstyle().name()).lower() == "domino");
+	isPolyester = (TQString(tqApp->tqstyle().name()).lower() == "polyester");
 	
 	if (isDomino)
 	{
-		QScrollBar sbar(NULL);
+		TQScrollBar sbar(NULL);
 		sbar.setOrientation(Qt::Horizontal);
 		sbar.setValue(1);
 		sbar.resize(200,25);
 		
-		QRect rect = qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar, &sbar, QStyle::SC_ScrollBarGroove);
+		TQRect rect = tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar, &sbar, TQStyle::SC_ScrollBarGroove);
 		scrollBarSpacingLeft = rect.x();
 		scrollBarSpacingRight = 200 - rect.x() - rect.width();
 	}
@@ -403,7 +403,7 @@ void createQApp()
 	/*setGnomeFonts();
 	setGnomeIcons();*/
 	
-	if (!cmdLine.contains("xfce-mcs-manager"))
+	if (!cmdLine.tqcontains("xfce-mcs-manager"))
 	{
 		// Get KDE related atoms from the X server
 		kipcCommAtom = XInternAtom ( gdk_x11_get_default_xdisplay() , "KIPC_COMM_ATOM" , false );
@@ -411,7 +411,7 @@ void createQApp()
 		
 		// Create a new window, and set the KDE_DESKTOP_WINDOW property on it
 		// This window will then receive events from KDE when the style changes
-		smw = new QWidget(0,0);
+		smw = new TQWidget(0,0);
 		long data = 1;
 		XChangeProperty(gdk_x11_get_default_xdisplay(), smw->winId(),
 			desktopWindowAtom, desktopWindowAtom,
@@ -421,12 +421,12 @@ void createQApp()
 		gdk_window_add_filter( NULL, gdkEventFilter, 0);
 	}
 	
-	meepWidgetP = new QWidget(0);
-	meepWidget = new QWidget(meepWidgetP);
-	meepSlider = new QSlider(meepWidget);
+	meepWidgetP = new TQWidget(0);
+	meepWidget = new TQWidget(meepWidgetP);
+	meepSlider = new TQSlider(meepWidget);
 	meepWidget->polish();
 	
-	meepTabBar = new QTabBar(meepWidget);
+	meepTabBar = new TQTabBar(meepWidget);
 	
 	menuBackgroundPixmap = NULL;
 	backgroundTile = meepWidget->paletteBackgroundPixmap();
@@ -434,18 +434,18 @@ void createQApp()
 		backgroundTileGdk = gdk_pixmap_foreign_new(backgroundTile->handle());
 }
 
-void destroyQApp()
+void destroyTQApp()
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	delete meepWidget;
 	delete meepWidgetP;
 	delete menuBackgroundPixmap;
 	delete smw;
-	if (qAppOwner)
+	if (tqAppOwner)
 	{
-		delete qApp;
-		qApp = 0;
+		delete tqApp;
+		tqApp = 0;
 	}
 	if (altBackGC != 0)
 		gtk_gc_release(altBackGC);
@@ -463,17 +463,17 @@ GdkFilterReturn gdkEventFilter(GdkXEvent *xevent, GdkEvent *gevent, gpointer dat
 		if (event->xclient.data.l[0] != 2)
 			return GDK_FILTER_REMOVE;
 		
-		if (gtkQtDebug)
+		if (gtkTQtDebug)
 			printf("StyleChanged IPC message\n");
 		
 		// Find out the new widget style
-		QString styleName = kdeConfigValue("General", "widgetStyle", "");
-		QStyle* style = QStyleFactory::create(styleName);
+		TQString styleName = kdeConfigValue("General", "widgetStyle", "");
+		TQStyle* style = TQStyleFactory::create(styleName);
 		if (!style)
 			return GDK_FILTER_REMOVE;
 		
-		// Tell the QApplication about this new style
-		qApp->setStyle(style);
+		// Tell the TQApplication about this new style
+		tqApp->setStyle(style);
 		
 		// Now we need to update GTK's properties
 		setRcProperties(gtkRcStyle, 1); // Rewrite our cache file
@@ -484,20 +484,20 @@ GdkFilterReturn gdkEventFilter(GdkXEvent *xevent, GdkEvent *gevent, gpointer dat
 	return GDK_FILTER_CONTINUE;
 }
 
-QString kdeConfigValue(const QString& section, const QString& name, const QString& def)
+TQString kdeConfigValue(const TQString& section, const TQString& name, const TQString& def)
 {
-	for ( QStringList::Iterator it = kdeSearchPaths.begin(); it != kdeSearchPaths.end(); ++it )
+	for ( TQStringList::Iterator it = kdeSearchPaths.begin(); it != kdeSearchPaths.end(); ++it )
 	{
-		if (!QFile::exists((*it) + "/share/config/kdeglobals"))
+		if (!TQFile::exists((*it) + "/share/config/kdeglobals"))
 			continue;
 		
-		QFile file((*it) + "/share/config/kdeglobals");
+		TQFile file((*it) + "/share/config/kdeglobals");
 		if (!file.open( IO_ReadOnly ))
 			continue;
 		
-		QTextStream stream( &file );
-		QString line;
-		QString sec;
+		TQTextStream stream( &file );
+		TQString line;
+		TQString sec;
 		int i = 1;
 		while ( !stream.atEnd() )
 		{
@@ -509,7 +509,7 @@ QString kdeConfigValue(const QString& section, const QString& name, const QStrin
 			}
 			if (sec != section)
 				continue;
-			QRegExp parser("([\\S]*)\\s*=\\s*([\\S]*)");
+			TQRegExp parser("([\\S]*)\\s*=\\s*([\\S]*)");
 			if (parser.search(line) == -1)
 				continue;
 			if (parser.cap(1) == name)
@@ -520,23 +520,23 @@ QString kdeConfigValue(const QString& section, const QString& name, const QStrin
 	return def;
 }
 
-QString kdeFindDir(const QString& suffix, const QString& file1, const QString& file2)
+TQString kdeFindDir(const TQString& suffix, const TQString& file1, const TQString& file2)
 {
-	for ( QStringList::Iterator it = kdeSearchPaths.begin(); it != kdeSearchPaths.end(); ++it )
+	for ( TQStringList::Iterator it = kdeSearchPaths.begin(); it != kdeSearchPaths.end(); ++it )
 	{
-		if ((QFile::exists((*it) + suffix + file1)) || (QFile::exists((*it) + suffix + file2)))
+		if ((TQFile::exists((*it) + suffix + file1)) || (TQFile::exists((*it) + suffix + file2)))
 			return (*it) + suffix;
 	}
-	return QString::null;
+	return TQString();
 }
 
-QString runCommand(const QString& command)
+TQString runCommand(const TQString& command)
 {
 	FILE* p = popen(command.latin1(), "r");
 	if ((p == NULL) || (p < 0))
-		return QString::null;
+		return TQString();
 	
-	QString ret;
+	TQString ret;
 	while (!feof(p))
 	{
 		char buffer[256];
@@ -553,28 +553,28 @@ void initKdeSettings()
 {
 	kdeSearchPaths.clear();
 	
-	QString kdeHome = getenv("KDEHOME");
-	QString kdeDirs = getenv("KDEDIRS");
-	QString kdeDir = getenv("KDEDIR");
+	TQString kdeHome = getenv("KDEHOME");
+	TQString kdeDirs = getenv("KDEDIRS");
+	TQString kdeDir = getenv("KDEDIR");
 	
 	if (!kdeHome.isEmpty())
 		kdeSearchPaths.append(kdeHome);
 	kdeSearchPaths.append(runCommand("kde-config --localprefix"));
 	
 	if (!kdeDirs.isEmpty())
-		kdeSearchPaths += QStringList::split(':', kdeDirs);
+		kdeSearchPaths += TQStringList::split(':', kdeDirs);
 	if (!kdeDir.isEmpty())
 		kdeSearchPaths.append(kdeDir);
 	kdeSearchPaths.append(runCommand("kde-config --prefix"));
 	
 	iconTheme = kdeConfigValue("Icons", "Theme", "crystalsvg");
-	QStringList back = QStringList::split(',', kdeConfigValue("General", "alternateBackground", "238,246,255"));
+	TQStringList back = TQStringList::split(',', kdeConfigValue("General", "alternateBackground", "238,246,255"));
 	alternateBackgroundColour.setRgb(back[0].toInt(), back[1].toInt(), back[2].toInt());
 
 	showIconsOnButtons = (kdeConfigValue("KDE", "ShowIconsOnPushButtons", "true").lower() == "true");
 	
 	
-	QString tmp = kdeConfigValue("Toolbar style", "IconText", "true").lower();
+	TQString tmp = kdeConfigValue("Toolbar style", "IconText", "true").lower();
 	if (tmp == "icononly")
 		toolbarStyle = 0;
 	else if (tmp == "icontextright")
@@ -587,64 +587,64 @@ void initKdeSettings()
 		toolbarStyle = 0;
 }
 
-QStyle::SFlags stateToSFlags(GtkStateType state)
+TQStyle::SFlags stateToSFlags(GtkStateType state)
 {
 	switch (state)
 	{
 		case GTK_STATE_ACTIVE:
-			return QStyle::Style_Enabled | QStyle::Style_Down;
+			return TQStyle::Style_Enabled | TQStyle::Style_Down;
 		case GTK_STATE_PRELIGHT:
-			return QStyle::Style_Enabled | QStyle::Style_MouseOver | QStyle::Style_Raised;
+			return TQStyle::Style_Enabled | TQStyle::Style_MouseOver | TQStyle::Style_Raised;
 		case GTK_STATE_SELECTED:
-			return QStyle::Style_Enabled | QStyle::Style_HasFocus | QStyle::Style_Raised;
+			return TQStyle::Style_Enabled | TQStyle::Style_HasFocus | TQStyle::Style_Raised;
 		case GTK_STATE_INSENSITIVE:
-			return QStyle::Style_Default | QStyle::Style_Raised;
+			return TQStyle::Style_Default | TQStyle::Style_Raised;
 		default:
-			return QStyle::Style_Enabled | QStyle::Style_Raised;
+			return TQStyle::Style_Enabled | TQStyle::Style_Raised;
 	}
 }
 
-QColor gdkColorToQColor(GdkColor* c)
+TQColor gdkColorToTQColor(GdkColor* c)
 {
-	return QColor(c->red / 256, c->green / 256, c->blue / 256);
+	return TQColor(c->red / 256, c->green / 256, c->blue / 256);
 }
 
 
 // The drawing functions follow the same pattern:
 //  * Set the appropriate flags
 //  * Ask QT to paint the widget to a pixmap
-//  * Create a GdkPixmap that points to our QPixmap
+//  * Create a GdkPixmap that points to our TQPixmap
 //  * Paint the pixmap on the window
 
 
 void drawButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int defaultButton, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap     pixmap(w, h);
-	QPainter    painter(&pixmap);
-	QPushButton button(meepWidget);	
-	button.setBackgroundOrigin(QWidget::ParentOrigin);
+	TQPixmap     pixmap(w, h);
+	TQPainter    painter(&pixmap);
+	TQPushButton button(meepWidget);	
+	button.setBackgroundOrigin(TQWidget::ParentOrigin);
 	button.setGeometry(x, y, w, h);
 	if (style->rc_style->bg[GTK_STATE_NORMAL].pixel != 0)
-		button.setPaletteBackgroundColor(gdkColorToQColor(&style->rc_style->bg[GTK_STATE_NORMAL]));
-	QPoint p = button.backgroundOffset();
-	QPoint pos = button.pos();
+		button.setPaletteBackgroundColor(gdkColorToTQColor(&style->rc_style->bg[GTK_STATE_NORMAL]));
+	TQPoint p = button.backgroundOffset();
+	TQPoint pos = button.pos();
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	
 	if (defaultButton)
-		sflags |= QStyle::Style_ButtonDefault;
+		sflags |= TQStyle::Style_ButtonDefault;
 	button.setDefault(defaultButton);
 
-	painter.fillRect(0, 0, w, h, qApp->palette().active().background());
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().background());
 
-	qApp->style().drawControl(QStyle::CE_PushButton, &painter, &button, 
-	                          QRect(0,0,w,h), button.palette().active(), sflags);
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_PushButton, &painter, &button, 
+	                          TQRect(0,0,w,h), button.tqpalette().active(), sflags);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -654,11 +654,11 @@ void drawButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int defa
 // Thanks Peter Hartshorn <peter@dimtech.com.au>
 void drawToolbar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	int w1, h1;
-	QStyle::SFlags sflags = stateToSFlags(state) | QStyle::Style_Raised;
+	TQStyle::SFlags sflags = stateToSFlags(state) | TQStyle::Style_Raised;
 
 
 	// Keramik hack...
@@ -668,7 +668,7 @@ void drawToolbar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x,
 	
 	if (w > h)
 	{
-		sflags |= QStyle::Style_Horizontal;
+		sflags |= TQStyle::Style_Horizontal;
 		w1 = w * 3;
 		h1 = h;
 	}
@@ -682,22 +682,22 @@ void drawToolbar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x,
 	    (w < 1) || (h < 1))
 		return;
 
-	QPixmap     pixmap(w1, h1);
-	QPixmap     p(w, h);
-	QPainter    painter(&pixmap);
+	TQPixmap     pixmap(w1, h1);
+	TQPixmap     p(w, h);
+	TQPainter    painter(&pixmap);
 
         if ((backgroundTile) && (!backgroundTile->isNull()))
-                painter.fillRect(0, 0, w1, h1, QBrush(QColor(255,255,255), *backgroundTile));
+                painter.fillRect(0, 0, w1, h1, TQBrush(TQColor(255,255,255), *backgroundTile));
         else
-                painter.fillRect(0, 0, w1, h1, qApp->palette().active().brush(QColorGroup::Background));
+                painter.fillRect(0, 0, w1, h1, tqApp->tqpalette().active().brush(TQColorGroup::Background));
 	
-	qApp->style().drawPrimitive(QStyle::PE_PanelDockWindow, &painter,
-			QRect(0,0,w1,h1), qApp->palette().active(),sflags);
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelDockWindow, &painter,
+			TQRect(0,0,w1,h1), tqApp->tqpalette().active(),sflags);
 
 	if (isKeramik)
 	{
-		qApp->style().drawPrimitive(QStyle::PE_DockWindowSeparator, &painter,
-				QRect(0,0,w1,h1), qApp->palette().active(),sflags);
+		tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_DockWindowSeparator, &painter,
+				TQRect(0,0,w1,h1), tqApp->tqpalette().active(),sflags);
 	}
 
 	bitBlt(&p, 0, 0, &pixmap, 0, 0, w, h);
@@ -709,11 +709,11 @@ void drawToolbar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x,
 
 void drawMenubar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	int w1, h1;
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 
 
 	// Keramik hack...
@@ -723,7 +723,7 @@ void drawMenubar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x,
 	
 	if (w > h)
 	{
-		sflags |= QStyle::Style_Horizontal;
+		sflags |= TQStyle::Style_Horizontal;
 		w1 = w * 3;
 		h1 = h;
 	}
@@ -737,17 +737,17 @@ void drawMenubar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x,
 	    (w < 1) || (h < 1))
 		return;
 
-	QPixmap     pixmap(w1, h1);
-	QPixmap     p(w, h);
-	QPainter    painter(&pixmap);
+	TQPixmap     pixmap(w1, h1);
+	TQPixmap     p(w, h);
+	TQPainter    painter(&pixmap);
 
         if ((backgroundTile) && (!backgroundTile->isNull()))
-                painter.fillRect(0, 0, w1, h1, QBrush(QColor(255,255,255), *backgroundTile));
+                painter.fillRect(0, 0, w1, h1, TQBrush(TQColor(255,255,255), *backgroundTile));
         else
-                painter.fillRect(0, 0, w1, h1, qApp->palette().active().brush(QColorGroup::Background));
+                painter.fillRect(0, 0, w1, h1, tqApp->tqpalette().active().brush(TQColorGroup::Background));
 
-	qApp->style().drawPrimitive(QStyle::PE_PanelMenuBar, &painter,
-			QRect(0,0,w1,h1), qApp->palette().active(),sflags);
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelMenuBar, &painter,
+			TQRect(0,0,w1,h1), tqApp->tqpalette().active(),sflags);
 
 	bitBlt(&p, 0, 0, &pixmap, 0, 0, w, h);
 
@@ -758,27 +758,27 @@ void drawMenubar(GdkWindow* window, GtkStyle* style, GtkStateType state, int x,
 
 void drawTab(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
 	
 	// GTK doesn't tell us if our tab is on the left, right, or middle of the tabbar
 	// So, let's always assume it's in the middle - it looks pretty
-	QTab* tab = new QTab;
+	TQTab* tab = new TQTab;
 	meepTabBar->insertTab(tab,1);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 
 	if (state != GTK_STATE_ACTIVE)
-		sflags = QStyle::Style_Selected;
+		sflags = TQStyle::Style_Selected;
 
-	painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawControl(QStyle::CE_TabBarTab, &painter, meepTabBar, QRect(0,0,w,h), qApp->palette().active(), sflags, QStyleOption(tab));
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_TabBarTab, &painter, meepTabBar, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags, TQStyleOption(tab));
 	
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -789,7 +789,7 @@ void drawTab(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int
 
 void drawVLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int ySource, int yDest)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	int width = style->xthickness;
@@ -800,13 +800,13 @@ void drawVLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, in
 	if ((width < 1) || (height < 1))
 		return;
 
-	QPixmap pixmap(width, height);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(width, height);
+	TQPainter painter(&pixmap);
 
-	painter.fillRect(2, 0, width - 2, height, qApp->palette().active().brush(QColorGroup::Background));
-	painter.setPen( qApp->palette().active().mid() );
+	painter.fillRect(2, 0, width - 2, height, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	painter.setPen( tqApp->tqpalette().active().mid() );
 	painter.drawLine( 0, 0, 0, height );
-	painter.setPen( qApp->palette().active().light() );
+	painter.setPen( tqApp->tqpalette().active().light() );
 	painter.drawLine( 1, 0, 1, height );
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
@@ -816,7 +816,7 @@ void drawVLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, in
 
 void drawHLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int y, int xSource, int xDest)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	int width = abs(xSource-xDest);
@@ -825,13 +825,13 @@ void drawHLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int y, in
 	if ((width < 1) || (height < 1))
 		return;
 
-	QPixmap pixmap(width, height);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(width, height);
+	TQPainter painter(&pixmap);
 
-	painter.fillRect(0, 2, width, height-2, qApp->palette().active().brush(QColorGroup::Background));
-	painter.setPen(qApp->palette().active().mid() );
+	painter.fillRect(0, 2, width, height-2, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	painter.setPen(tqApp->tqpalette().active().mid() );
 	painter.drawLine(0, 0, width, 0);
-	painter.setPen(qApp->palette().active().light());
+	painter.setPen(tqApp->tqpalette().active().light());
 	painter.drawLine(0, 1, width, 1);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
@@ -841,21 +841,21 @@ void drawHLine(GdkWindow* window, GtkStyle* style, GtkStateType state, int y, in
 
 void drawLineEdit(GdkWindow* window, GtkStyle* style, GtkStateType state, int hasFocus, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w, h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w, h);
+	TQPainter painter(&pixmap);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	if (hasFocus)
-		sflags |= QStyle::Style_HasFocus;
+		sflags |= TQStyle::Style_HasFocus;
 	
-	painter.fillRect(0, 0, w, h, qApp->palette().active().base());
-	qApp->style().drawPrimitive(QStyle::PE_PanelLineEdit, &painter, QRect(0, 0, w, h), qApp->palette().active(), sflags, QStyleOption(1,1));
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().base());
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelLineEdit, &painter, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, TQStyleOption(1,1));
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -864,25 +864,25 @@ void drawLineEdit(GdkWindow* window, GtkStyle* style, GtkStateType state, int ha
 
 void drawFrame(GdkWindow* window, GtkStyle* style, GtkStateType state, GtkShadowType shadow_type, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1)) // Caused crash in gaim file transfers window
 		return;
 
-	QPixmap pixmap(w, h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w, h);
+	TQPainter painter(&pixmap);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	if ((shadow_type == GTK_SHADOW_IN) || (shadow_type == GTK_SHADOW_ETCHED_IN))
-		sflags |= QStyle::Style_Sunken;
+		sflags |= TQStyle::Style_Sunken;
 
 	if ((backgroundTile) && (!backgroundTile->isNull()))
-		painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile));
+		painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile));
 	else
-		painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
+		painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
 
-	qApp->style().drawPrimitive(QStyle::PE_Panel, &painter, QRect(0, 0, w, h), qApp->palette().active(), sflags, QStyleOption(2,2) );
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_Panel, &painter, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, TQStyleOption(2,2) );
 	
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -891,26 +891,26 @@ void drawFrame(GdkWindow* window, GtkStyle* style, GtkStateType state, GtkShadow
 
 void drawComboBox(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
-	QComboBox cb(false, 0);
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
+	TQComboBox cb(false, 0);
 	cb.resize(w,h);
 	
-	QStyle::SFlags sflags = stateToSFlags(state);
-	QStyle::SCFlags scflags = QStyle::SC_ComboBoxArrow | QStyle::SC_ComboBoxFrame | QStyle::SC_ComboBoxListBoxPopup;
-	QStyle::SCFlags activeflags = QStyle::SC_None;
+	TQStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SCFlags scflags = TQStyle::SC_ComboBoxArrow | TQStyle::SC_ComboBoxFrame | TQStyle::SC_ComboBoxListBoxPopup;
+	TQStyle::SCFlags activeflags = TQStyle::SC_None;
 
 	if (state == GTK_STATE_PRELIGHT)
-		activeflags = QStyle::Style_MouseOver;
+		activeflags = TQStyle::Style_MouseOver;
 
-	painter.fillRect(0,0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawComplexControl(QStyle::CC_ComboBox, &painter, &cb, QRect(0, 0, w, h), qApp->palette().active(), sflags, scflags, activeflags);
+	painter.fillRect(0,0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawComplexControl(TQStyle::CC_ComboBox, &painter, &cb, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, scflags, activeflags);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -919,26 +919,26 @@ void drawComboBox(GdkWindow* window, GtkStyle* style, GtkStateType state, int x,
 
 void drawCheckBox(GdkWindow* window, GtkStyle* style, GtkStateType state, int checked, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
-	int realH = qApp->style().pixelMetric(QStyle::PM_IndicatorHeight);
-	int realW = qApp->style().pixelMetric(QStyle::PM_IndicatorWidth);
+	int realH = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorHeight);
+	int realW = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorWidth);
 
 	if ((realW < 1) || (realH < 1))
 		return;
 
-	QPixmap pixmap(realW, realH);
-	QPainter painter(&pixmap);
-	QCheckBox checkbox(0);
+	TQPixmap pixmap(realW, realH);
+	TQPainter painter(&pixmap);
+	TQCheckBox checkbox(0);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
-	sflags |= (checked ? QStyle::Style_On : QStyle::Style_Off);
+	TQStyle::SFlags sflags = stateToSFlags(state);
+	sflags |= (checked ? TQStyle::Style_On : TQStyle::Style_Off);
 
-	painter.fillRect(0, 0, realW, realH, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawControl(QStyle::CE_CheckBox, &painter, &checkbox, QRect(0, 0, realW, realH), qApp->palette().active(), sflags);
+	painter.fillRect(0, 0, realW, realH, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_CheckBox, &painter, &checkbox, TQRect(0, 0, realW, realH), tqApp->tqpalette().active(), sflags);
 
-	// Qt checkboxes are usually bigger than GTK wants.
+	// TQt checkboxes are usually bigger than GTK wants.
 	// We cheat, and draw them over the expected area.
 	int xOffset = (realW - w) / 2;
 	int yOffset = (realH - h) / 2;
@@ -950,33 +950,33 @@ void drawCheckBox(GdkWindow* window, GtkStyle* style, GtkStateType state, int ch
 
 void drawMenuCheck(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
-	QCheckBox checkbox(0);
+	TQCheckBox checkbox(0);
 	
 	/* A previous version of the function followed the sizehints exclusively 
 	   Now follow w and h provided by GTK, but if the checkmark is too big we might have to scale it */
 	/*
-	int w1 = checkbox.sizeHint().width();
-	int h1 = checkbox.sizeHint().height(); */
+	int w1 = checkbox.tqsizeHint().width();
+	int h1 = checkbox.tqsizeHint().height(); */
 
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
-	sflags |= QStyle::Style_On;
+	TQStyle::SFlags sflags = stateToSFlags(state);
+	sflags |= TQStyle::Style_On;
 
 	if (fillPixmap && (!fillPixmap->isNull()))
-		painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *fillPixmap));
+		painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *fillPixmap));
 	else if ((backgroundTile) && (!backgroundTile->isNull()))
-                painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile));
+                painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile));
         else
-	painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawPrimitive(QStyle::PE_CheckMark, &painter, QRect(0, 0, w, h), qApp->palette().active(), sflags);
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_CheckMark, &painter, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags);
 	
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -985,32 +985,32 @@ void drawMenuCheck(GdkWindow* window, GtkStyle* style, GtkStateType state, int x
 
 void drawRadioButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int checked, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
-	int realH = qApp->style().pixelMetric(QStyle::PM_IndicatorHeight);
-	int realW = qApp->style().pixelMetric(QStyle::PM_IndicatorWidth);
+	int realH = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorHeight);
+	int realW = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorWidth);
 
 	if ((realW < 1) || (realH < 1))
 		return;
 
-	QPixmap pixmap(realH, realW);
-	QPainter painter(&pixmap);
-	QRadioButton radio(0);
+	TQPixmap pixmap(realH, realW);
+	TQPainter painter(&pixmap);
+	TQRadioButton radio(0);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
-	sflags |= checked ? QStyle::Style_On : QStyle::Style_Off;
+	TQStyle::SFlags sflags = stateToSFlags(state);
+	sflags |= checked ? TQStyle::Style_On : TQStyle::Style_Off;
 
 	if (fillPixmap && (!fillPixmap->isNull()))
-		painter.fillRect(0, 0, realW, realH, QBrush(QColor(255,255,255), *fillPixmap));
+		painter.fillRect(0, 0, realW, realH, TQBrush(TQColor(255,255,255), *fillPixmap));
 	else if ((backgroundTile) && (!backgroundTile->isNull()))
-                painter.fillRect(0, 0, realW, realH, QBrush(QColor(255,255,255), *backgroundTile));
+                painter.fillRect(0, 0, realW, realH, TQBrush(TQColor(255,255,255), *backgroundTile));
         else
-                painter.fillRect(0, 0, realW, realH, qApp->palette().active().brush(QColorGroup::Background));
+                painter.fillRect(0, 0, realW, realH, tqApp->tqpalette().active().brush(TQColorGroup::Background));
 
-	qApp->style().drawControl(QStyle::CE_RadioButton, &painter, &radio, QRect(0,0,realH,realW), qApp->palette().active(), sflags);
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_RadioButton, &painter, &radio, TQRect(0,0,realH,realW), tqApp->tqpalette().active(), sflags);
 
-	// Qt checkboxes are usually bigger than GTK wants.
+	// TQt checkboxes are usually bigger than GTK wants.
 	// We cheat, and draw them over the expected area.
 	int xOffset = (realW - w) / 2;
 	int yOffset = (realH - h) / 2;
@@ -1023,7 +1023,7 @@ void drawRadioButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int
 
 void drawScrollBarSlider(GdkWindow* window, GtkStyle* style, GtkStateType state, int orientation, GtkAdjustment* adj, int x, int y, int w, int h, int offset, int totalExtent)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
@@ -1038,52 +1038,52 @@ void drawScrollBarSlider(GdkWindow* window, GtkStyle* style, GtkStateType state,
 		else
 		    hCorrected = h + 14;
 	}
-	QPixmap pixmap(wCorrected, hCorrected);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(wCorrected, hCorrected);
+	TQPainter painter(&pixmap);
 	
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	if (orientation == GTK_ORIENTATION_HORIZONTAL)
-		sflags |= QStyle::Style_Horizontal;
+		sflags |= TQStyle::Style_Horizontal;
 	
-	qApp->style().drawPrimitive(QStyle::PE_ScrollBarSlider, &painter, QRect(0,0,wCorrected,hCorrected), qApp->palette().active(), sflags);
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_ScrollBarSlider, &painter, TQRect(0,0,wCorrected,hCorrected), tqApp->tqpalette().active(), sflags);
 	
 	// The domino style doesn't draw the entire slider in PE_ScrollBarSlider
 	// We have to draw PE_ScrollBarAddPage and PE_ScrollBarSubPage and piece the bits together
 	if (isDomino && !mozillaFix && !eclipseFix)
 	{
-		QPixmap leftPix, rightPix;
-		QRect leftRect, rightRect;
+		TQPixmap leftPix, rightPix;
+		TQRect leftRect, rightRect;
 		if (orientation == GTK_ORIENTATION_HORIZONTAL)
 		{
-			leftRect = QRect(0, 0, offset-scrollBarSpacingLeft, h);
-			rightRect = QRect(6, 0, totalExtent-offset-w-scrollBarSpacingRight+2, h);
+			leftRect = TQRect(0, 0, offset-scrollBarSpacingLeft, h);
+			rightRect = TQRect(6, 0, totalExtent-offset-w-scrollBarSpacingRight+2, h);
 			leftPix.resize(6 + leftRect.width(), h);
 			rightPix.resize(6 + rightRect.width(), h);
 		}
 		else
 		{
-			leftRect = QRect(0, 0, w, offset-scrollBarSpacingLeft);
-			rightRect = QRect(0, 6, w, totalExtent-offset-h-scrollBarSpacingRight+2);
+			leftRect = TQRect(0, 0, w, offset-scrollBarSpacingLeft);
+			rightRect = TQRect(0, 6, w, totalExtent-offset-h-scrollBarSpacingRight+2);
 			leftPix.resize(w, 6 + leftRect.height());
 			rightPix.resize(w, 6 + rightRect.height());
 		}
 		
-		QPainter dominoPainter(&leftPix);
-		qApp->style().drawPrimitive(QStyle::PE_ScrollBarSubPage, &dominoPainter, leftRect, qApp->palette().active(), sflags);
+		TQPainter dominoPainter(&leftPix);
+		tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_ScrollBarSubPage, &dominoPainter, leftRect, tqApp->tqpalette().active(), sflags);
 		
 		dominoPainter.end();
 		dominoPainter.begin(&rightPix);
-		qApp->style().drawPrimitive(QStyle::PE_ScrollBarAddPage, &dominoPainter, rightRect, qApp->palette().active(), sflags);
+		tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_ScrollBarAddPage, &dominoPainter, rightRect, tqApp->tqpalette().active(), sflags);
 		
 		if (orientation == GTK_ORIENTATION_HORIZONTAL)
 		{
-			bitBlt(&pixmap, 1, 0, &leftPix, leftRect.width(), 0, 6, h, Qt::CopyROP, true);
-			bitBlt(&pixmap, w-7, 0, &rightPix, 0, 0, 7, h, Qt::CopyROP, true);
+			bitBlt(TQT_TQPAINTDEVICE(&pixmap), 1, 0, TQT_TQPAINTDEVICE(&leftPix), leftRect.width(), 0, 6, h, TQt::CopyROP, true);
+			bitBlt(TQT_TQPAINTDEVICE(&pixmap), w-7, 0, TQT_TQPAINTDEVICE(&rightPix), 0, 0, 7, h, TQt::CopyROP, true);
 		}
 		else
 		{
-			bitBlt(&pixmap, 0, 1, &leftPix, 0, leftRect.height(), w, 6, Qt::CopyROP, true);
-			bitBlt(&pixmap, 0, h-7, &rightPix, 0, 0, w, 7, Qt::CopyROP, true);
+			bitBlt(TQT_TQPAINTDEVICE(&pixmap), 0, 1, TQT_TQPAINTDEVICE(&leftPix), 0, leftRect.height(), w, 6, TQt::CopyROP, true);
+			bitBlt(TQT_TQPAINTDEVICE(&pixmap), 0, h-7, TQT_TQPAINTDEVICE(&rightPix), 0, 0, w, 7, TQt::CopyROP, true);
 		}
 	}
 	
@@ -1104,7 +1104,7 @@ void drawScrollBarSlider(GdkWindow* window, GtkStyle* style, GtkStateType state,
 
 void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int orientation, GtkAdjustment* adj, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
@@ -1112,7 +1112,7 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o
 
 	if (scrollBar != 0)
 		delete scrollBar;
-	scrollBar = new QScrollBar(NULL);
+	scrollBar = new TQScrollBar(NULL);
 	
 	scrollBar->resize(w,h);
 
@@ -1129,11 +1129,11 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o
 	scrollBar->setOrientation(orientation ? Qt::Vertical : Qt::Horizontal);
 	
 	
-	QStyle::SFlags sflags = stateToSFlags(state);
-	if (sflags |= QStyle::Style_Down) sflags = QStyle::Style_Enabled;
-	if (orientation == GTK_ORIENTATION_HORIZONTAL) sflags |= QStyle::Style_Horizontal;
+	TQStyle::SFlags sflags = stateToSFlags(state);
+	if (sflags |= TQStyle::Style_Down) sflags = TQStyle::Style_Enabled;
+	if (orientation == GTK_ORIENTATION_HORIZONTAL) sflags |= TQStyle::Style_Horizontal;
 	
-	QPixmap pixmap(w,h);
+	TQPixmap pixmap(w,h);
 	
 	scrollBar->setMinValue(0);
 	scrollBar->setMaxValue(65535);
@@ -1145,9 +1145,9 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o
 
 
 	if (orientation == GTK_ORIENTATION_VERTICAL) {
-		QRect r;
-		r = qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar,
-				scrollBar, QStyle::SC_ScrollBarSlider);
+		TQRect r;
+		r = tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar,
+				scrollBar, TQStyle::SC_ScrollBarSlider);
 		offset = r.y();
 		thumbSize = r.height();
                 if (thumbSize < 0)
@@ -1156,23 +1156,23 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o
 		if (!r.isValid()) // Fix a crash bug in Eclipse where it was trying to draw tiny scrollbars.
 			return;
 
-		QPixmap tmpPixmap(w, h + thumbSize);
-		QPainter painter2(&tmpPixmap);
+		TQPixmap tmpPixmap(w, h + thumbSize);
+		TQPainter painter2(&tmpPixmap);
 		scrollBar->resize(w, h + thumbSize);
 
 		painter2.fillRect(0, 0, w, h + thumbSize,
-				qApp->palette().active().brush(QColorGroup::Background));
-		qApp->style().drawComplexControl(QStyle::CC_ScrollBar,
-				&painter2, scrollBar, QRect(0, 0, w, h+thumbSize),
-				qApp->palette().active(), sflags);
+				tqApp->tqpalette().active().brush(TQColorGroup::Background));
+		tqApp->tqstyle().tqdrawComplexControl(TQStyle::CC_ScrollBar,
+				&painter2, scrollBar, TQRect(0, 0, w, h+thumbSize),
+				tqApp->tqpalette().active(), sflags);
 
-		bitBlt(&pixmap, 0, 0, &tmpPixmap, 0, 0, w, offset, Qt::CopyROP);
+		bitBlt(&pixmap, 0, 0, &tmpPixmap, 0, 0, w, offset, TQt::CopyROP);
 		bitBlt(&pixmap, 0, offset, &tmpPixmap, 0, offset + thumbSize,
-				w, h - offset, Qt::CopyROP);
+				w, h - offset, TQt::CopyROP);
 	} else {
-		QRect r;
-		r = qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar,
-				scrollBar, QStyle::SC_ScrollBarSlider);
+		TQRect r;
+		r = tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar,
+				scrollBar, TQStyle::SC_ScrollBarSlider);
 		offset = r.x();
 		thumbSize = r.width();
 		if (thumbSize < 0)
@@ -1181,19 +1181,19 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o
 		if (!r.isValid()) // Fix a crash bug in Eclipse when it was trying to draw tiny scrollbars.
 			return;
 		
-		QPixmap tmpPixmap(w + thumbSize, h);
-		QPainter painter2(&tmpPixmap);
+		TQPixmap tmpPixmap(w + thumbSize, h);
+		TQPainter painter2(&tmpPixmap);
 		scrollBar->resize(w + thumbSize, h);
 
 		painter2.fillRect(0, 0, w + thumbSize, h,
-				qApp->palette().active().brush(QColorGroup::Background));
-		qApp->style().drawComplexControl(QStyle::CC_ScrollBar,
-				&painter2, scrollBar, QRect(0, 0, w+thumbSize, h),
-				qApp->palette().active(), sflags);
+				tqApp->tqpalette().active().brush(TQColorGroup::Background));
+		tqApp->tqstyle().tqdrawComplexControl(TQStyle::CC_ScrollBar,
+				&painter2, scrollBar, TQRect(0, 0, w+thumbSize, h),
+				tqApp->tqpalette().active(), sflags);
 
-		bitBlt(&pixmap, 0, 0, &tmpPixmap, 0, 0, offset, h, Qt::CopyROP);
+		bitBlt(&pixmap, 0, 0, &tmpPixmap, 0, 0, offset, h, TQt::CopyROP);
 		bitBlt(&pixmap, offset, 0, &tmpPixmap, offset + thumbSize, 0,
-				w - offset, h, Qt::CopyROP);
+				w - offset, h, TQt::CopyROP);
 	}
 	
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
@@ -1203,37 +1203,37 @@ void drawScrollBar(GdkWindow* window, GtkStyle* style, GtkStateType state, int o
 
 void drawToolButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
 	if ((w < 1) || (h < 1))
 		return;
 
-	QToolButton button(NULL);
+	TQToolButton button(NULL);
 	button.resize(w, h);
 	
 	/* 
-	int realW = button.sizeHint().width();
-	int realH = button.sizeHint().height();	 */
+	int realW = button.tqsizeHint().width();
+	int realH = button.tqsizeHint().height();	 */
 	
-	QStyle::SFlags sflags = stateToSFlags(state);
-	QStyle::SCFlags activeflags = QStyle::SC_None;
+	TQStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SCFlags activeflags = TQStyle::SC_None;
 	if (state == GTK_STATE_ACTIVE)
 	{
-		sflags |= QStyle::Style_AutoRaise;
-		activeflags = QStyle::SC_ToolButton;
+		sflags |= TQStyle::Style_AutoRaise;
+		activeflags = TQStyle::SC_ToolButton;
 	}
 	else
-		sflags |= QStyle::Style_AutoRaise | QStyle::Style_Raised;
+		sflags |= TQStyle::Style_AutoRaise | TQStyle::Style_Raised;
 	
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
 	
 	if ((backgroundTile) && (!backgroundTile->isNull()))
-		painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile));
+		painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile));
 	else
-		painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawComplexControl(QStyle::CC_ToolButton, &painter, &button, QRect(0, 0, w, h), qApp->palette().active(), sflags, QStyle::SC_ToolButton, activeflags);
+		painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawComplexControl(TQStyle::CC_ToolButton, &painter, &button, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, TQStyle::SC_ToolButton, activeflags);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1242,20 +1242,20 @@ void drawToolButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int
 
 void drawMenuBarItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w, h);
-	QPainter painter(&pixmap);
-	QMenuItem mi;
-	QMenuBar mb(0);
+	TQPixmap pixmap(w, h);
+	TQPainter painter(&pixmap);
+	TQMenuItem mi;
+	TQMenuBar mb(0);
 	
-	QStyle::SFlags sflags = QStyle::Style_Down | QStyle::Style_Enabled | QStyle::Style_Active | QStyle::Style_HasFocus;
+	TQStyle::SFlags sflags = TQStyle::Style_Down | TQStyle::Style_Enabled | TQStyle::Style_Active | TQStyle::Style_HasFocus;
 
-	qApp->style().drawControl(QStyle::CE_MenuBarItem, &painter, &mb, QRect(0, 0, w, h), qApp->palette().active(), sflags, QStyleOption(&mi));
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_MenuBarItem, &painter, &mb, TQRect(0, 0, w, h), tqApp->tqpalette().active(), sflags, TQStyleOption(&mi));
 	
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1264,23 +1264,23 @@ void drawMenuBarItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int
 
 void drawMenuItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
-	QPopupMenu pm;
-	QMenuData md;
-	QMenuItem* mi = md.findItem(md.insertItem(""));
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
+	TQPopupMenu pm;
+	TQMenuData md;
+	TQMenuItem* mi = md.tqfindItem(md.insertItem(""));
 	
-	QStyleOption opt(mi, 16, 16);
-	QStyle::SFlags sflags = QStyle::Style_Active | QStyle::Style_Enabled;
+	TQStyleOption opt(mi, 16, 16);
+	TQStyle::SFlags sflags = TQStyle::Style_Active | TQStyle::Style_Enabled;
 
-	painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawControl(QStyle::CE_PopupMenuItem, &painter, &pm, QRect(0,0,w,h), qApp->palette().active(), sflags, opt);
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_PopupMenuItem, &painter, &pm, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags, opt);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1289,21 +1289,21 @@ void drawMenuItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int x,
 
 void drawSplitter(GdkWindow* window, GtkStyle* style, GtkStateType state, int orientation, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	// No idea why this works...
-	if (orientation != GTK_ORIENTATION_HORIZONTAL) sflags |= QStyle::Style_Horizontal;
+	if (orientation != GTK_ORIENTATION_HORIZONTAL) sflags |= TQStyle::Style_Horizontal;
 
-	painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawPrimitive(QStyle::PE_Splitter, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags);
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_Splitter, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1312,79 +1312,79 @@ void drawSplitter(GdkWindow* window, GtkStyle* style, GtkStateType state, int or
 
 void drawTabFrame(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h, GtkPositionType pos)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
 		return;
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 		
-	QPixmap pixmap(w, h);
-	QPainter painter(&pixmap);
-	QStyleOption opt(2, 2); // line width
+	TQPixmap pixmap(w, h);
+	TQPainter painter(&pixmap);
+	TQStyleOption opt(2, 2); // line width
 
 	if ((backgroundTile) && (!backgroundTile->isNull()))
-		painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile));
+		painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile));
 	else
-		painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawPrimitive(QStyle::PE_PanelTabWidget, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags, opt);
+		painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelTabWidget, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags, opt);
 	
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
 	g_object_unref(pix);
 	
 	// Drawing tab base
-        int th = qApp->style().pixelMetric(QStyle::PM_TabBarBaseHeight, meepTabBar);
+        int th = tqApp->tqstyle().tqpixelMetric(TQStyle::PM_TabBarBaseHeight, meepTabBar);
 	int tw = w;
 	
 	if ((tw < 1) || (th < 1))
 		return;
 
-        QPixmap pixmap1(tw,th);
-        QPainter painter1(&pixmap1);
+        TQPixmap pixmap1(tw,th);
+        TQPainter painter1(&pixmap1);
 	if ((backgroundTile) && (!backgroundTile->isNull()))
-		painter1.fillRect(0, 0, tw, th, QBrush(QColor(255,255,255), *backgroundTile));
+		painter1.fillRect(0, 0, tw, th, TQBrush(TQColor(255,255,255), *backgroundTile));
 	else
-		painter1.fillRect(0, 0, tw, th, qApp->palette().active().brush(QColorGroup::Background));
+		painter1.fillRect(0, 0, tw, th, tqApp->tqpalette().active().brush(TQColorGroup::Background));
         
 
-        qApp->style().drawPrimitive(QStyle::PE_TabBarBase, &painter1, QRect(0, 0, tw, th), qApp->palette().active(), sflags, QStyleOption(1,1));
+        tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_TabBarBase, &painter1, TQRect(0, 0, tw, th), tqApp->tqpalette().active(), sflags, TQStyleOption(1,1));
 	if (pos == GTK_POS_BOTTOM)
 	{
-		QWMatrix m;
+		TQWMatrix m;
 		m.scale(1, -1);
 		pixmap1 = pixmap1.xForm(m);
 		
 		GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap1.handle());
-		gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y+h+qApp->style().pixelMetric(QStyle::PM_TabBarBaseOverlap, meepTabBar), tw, th);
+		gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y+h+tqApp->tqstyle().tqpixelMetric(TQStyle::PM_TabBarBaseOverlap, meepTabBar), tw, th);
 		g_object_unref(pix);
 	}
 	else
 	{
 		GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap1.handle());
-		gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y-qApp->style().pixelMetric(QStyle::PM_TabBarBaseOverlap, meepTabBar), tw, th);
+		gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y-tqApp->tqstyle().tqpixelMetric(TQStyle::PM_TabBarBaseOverlap, meepTabBar), tw, th);
 		g_object_unref(pix);
 	}
 }
 
 void drawMenu(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w, h);
-	QPainter painter(&pixmap);
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQPixmap pixmap(w, h);
+	TQPainter painter(&pixmap);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 
 	if ((backgroundTile) && (!backgroundTile->isNull()))
-		painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile));
+		painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile));
 	else
-		painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawPrimitive(QStyle::PE_PanelPopup, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags);
+		painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_PanelPopup, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1408,7 +1408,7 @@ void drawMenu(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int
 void drawProgressChunk(GdkWindow * window, GtkStyle * style, GtkStateType state, int x, int y, int w, int h)
 {
 	// This is only for Mozilla/Firefox
-	if (!mozillaFix || !gtkQtEnable)
+	if (!mozillaFix || !gtkTQtEnable)
 		return;
 	
 	if ((w<=1) || (h<=1))
@@ -1418,24 +1418,24 @@ void drawProgressChunk(GdkWindow * window, GtkStyle * style, GtkStateType state,
 	int w2 = isAlloy ? w+4 : w;
 	int h2 = isAlloy ? h+4 : h;
 
-	QProgressBar bar(100, NULL);
+	TQProgressBar bar(100, NULL);
 	bar.resize(w2, h2);
 	bar.setProgress(100);
 	bar.setCenterIndicator(false);
 	bar.setPercentageVisible(false);
-	bar.setFrameStyle(QFrame::NoFrame);
+	bar.setFrameStyle(TQFrame::NoFrame);
 	
 	if ((w2 < 1) || (h2 < 1))
 		return;
 
-	QPixmap pixmap(w2, h2);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w2, h2);
+	TQPainter painter(&pixmap);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	
-	painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
 
-	qApp->style().drawControl(QStyle::CE_ProgressBarContents, &painter, &bar, QRect(0,0,w2,h2), qApp->palette().active(), sflags);
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_ProgressBarContents, &painter, &bar, TQRect(0,0,w2,h2), tqApp->tqpalette().active(), sflags);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	if (isAlloy)
@@ -1447,13 +1447,13 @@ void drawProgressChunk(GdkWindow * window, GtkStyle * style, GtkStateType state,
 
 void drawProgressBar(GdkWindow * window, GtkStyle * style, GtkStateType state, GtkProgressBarOrientation orientation, gfloat percentage, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w<=1) || (h<=1))
 		return; // Trying to draw something that small caused a segdault
 	
-	QProgressBar bar(100, NULL);
+	TQProgressBar bar(100, NULL);
 	if ((orientation == GTK_PROGRESS_BOTTOM_TO_TOP) || (orientation == GTK_PROGRESS_TOP_TO_BOTTOM))
 		bar.resize(h, w);
 	else
@@ -1462,9 +1462,9 @@ void drawProgressBar(GdkWindow * window, GtkStyle * style, GtkStateType state, G
 	bar.setCenterIndicator(false);
 	bar.setPercentageVisible(false);
 
-	QPixmap pixmap = QPixmap::grabWidget(&bar);
+	TQPixmap pixmap = TQPixmap::grabWidget(&bar);
 	
-	QWMatrix matrix;
+	TQWMatrix matrix;
 	switch (orientation)
 	{
 		case GTK_PROGRESS_RIGHT_TO_LEFT: matrix.rotate(180); break;
@@ -1483,10 +1483,10 @@ void drawProgressBar(GdkWindow * window, GtkStyle * style, GtkStateType state, G
 
 void drawSlider(GdkWindow * window, GtkStyle * style, GtkStateType state, GtkAdjustment *adj, int x, int y, int w, int h, GtkOrientation orientation, int inverted)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
-	meepSlider->setBackgroundOrigin(QWidget::ParentOrigin);
+	meepSlider->setBackgroundOrigin(TQWidget::ParentOrigin);
 	
 	meepSlider->setOrientation((orientation == GTK_ORIENTATION_HORIZONTAL) ? Qt::Horizontal : Qt::Vertical);
 	meepSlider->setEnabled(state != GTK_STATE_INSENSITIVE);
@@ -1500,7 +1500,7 @@ void drawSlider(GdkWindow * window, GtkStyle * style, GtkStateType state, GtkAdj
 	else // Inverted sliders... where max is at the left/top and min is at the right/bottom
 		meepSlider->setValue(100-(int)((adj->value-adj->lower)/(adj->upper-adj->lower)*100));
 
-	QPixmap pixmap = QPixmap::grabWidget(meepSlider);
+	TQPixmap pixmap = TQPixmap::grabWidget(meepSlider);
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
 	g_object_unref(pix);
@@ -1508,19 +1508,19 @@ void drawSlider(GdkWindow * window, GtkStyle * style, GtkStateType state, GtkAdj
 
 void drawSpinButton(GdkWindow * window, GtkStyle * style, GtkStateType state, int direction, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w, h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w, h);
+	TQPainter painter(&pixmap);
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	
-	painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawPrimitive((direction ? QStyle::PE_SpinWidgetDown : QStyle::PE_SpinWidgetUp), &painter, QRect(0,0,w,h), qApp->palette().active(), sflags);
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawPrimitive((direction ? TQStyle::PE_SpinWidgetDown : TQStyle::PE_SpinWidgetUp), &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags);
 	
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1529,19 +1529,19 @@ void drawSpinButton(GdkWindow * window, GtkStyle * style, GtkStateType state, in
 
 void drawListHeader(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
 
-	QStyle::SFlags sflags = stateToSFlags(state) | QStyle::Style_Horizontal;
+	TQStyle::SFlags sflags = stateToSFlags(state) | TQStyle::Style_Horizontal;
 
-	painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawPrimitive(QStyle::PE_HeaderSection, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags);
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_HeaderSection, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1551,19 +1551,19 @@ void drawListHeader(GdkWindow* window, GtkStyle* style, GtkStateType state, int
 
 void drawListViewItem(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-        if (!gtkQtEnable)
+        if (!gtkTQtEnable)
                 return;
 
 	if ((w < 1) || (h < 1))
 		return;
 
-        QPixmap     pixmap(w, h);
-        QPainter    painter(&pixmap);
+        TQPixmap     pixmap(w, h);
+        TQPainter    painter(&pixmap);
 
 	/* Get the brush corresponding to highlight color */
-	QBrush brush = qApp->palette().brush(QPalette::Active, QColorGroup::Highlight);
+	TQBrush brush = tqApp->palette().brush(TQPalette::Active, TQColorGroup::Highlight);
 	painter.setBrush(brush);
-	painter.setPen(Qt::NoPen);
+	painter.setPen(TQt::NoPen);
 	painter.drawRect(0, 0, w, h);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
@@ -1573,25 +1573,25 @@ void drawListViewItem(GdkWindow* window, GtkStyle* style, GtkStateType state, in
 
 void drawSquareButton(GdkWindow* window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 
-	QPixmap     pixmap(20, 20);
-	QPainter    painter(&pixmap);
-	QPushButton button(0);
+	TQPixmap     pixmap(20, 20);
+	TQPainter    painter(&pixmap);
+	TQPushButton button(0);
 		
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	if (fillPixmap && (!fillPixmap->isNull()))
-		painter.fillRect(0, 0, 20, 20, QBrush(QColor(255,255,255), *fillPixmap));
+		painter.fillRect(0, 0, 20, 20, TQBrush(TQColor(255,255,255), *fillPixmap));
 	else if ((backgroundTile) && (!backgroundTile->isNull()))
-		painter.fillRect(0, 0, 20, 20, QBrush(QColor(255,255,255), *backgroundTile));
+		painter.fillRect(0, 0, 20, 20, TQBrush(TQColor(255,255,255), *backgroundTile));
 	else
-		painter.fillRect(0, 0, 20, 20, qApp->palette().active().brush(QColorGroup::Background));
+		painter.fillRect(0, 0, 20, 20, tqApp->tqpalette().active().brush(TQColorGroup::Background));
 	
-	qApp->style().drawControl(QStyle::CE_PushButton, &painter, &button,
-					QRect(0,0,20,20), qApp->palette().active(), sflags);
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_PushButton, &painter, &button,
+					TQRect(0,0,20,20), tqApp->tqpalette().active(), sflags);
 	
-	QImage image = pixmap.convertToImage().smoothScale(w,h);
+	TQImage image = pixmap.convertToImage().smoothScale(w,h);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1600,22 +1600,22 @@ void drawSquareButton(GdkWindow* window, GtkStyle* style, GtkStateType state, in
 
 void initDrawTabNG(int count)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	delete meepTabBar;
 	meepTabBar = 0;
-	meepTabBar = new QTabBar(meepWidget);
+	meepTabBar = new TQTabBar(meepWidget);
 	
 	for ( int i = 0; i < count; i++ )
-		meepTabBar->addTab(new QTab);
+		meepTabBar->addTab(new TQTab);
 	
 	return;
 }
 
 void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, int y, int w, int h, GtkNotebook *notebook)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	GtkPositionType tpos = gtk_notebook_get_tab_pos(notebook);
@@ -1632,7 +1632,7 @@ void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, in
 		}
 	}
 	
-	QTab *tab = meepTabBar->tabAt(pos);
+	TQTab *tab = meepTabBar->tabAt(pos);
 	
 	if (!tab)
 	{
@@ -1644,11 +1644,11 @@ void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, in
 		return;
 	}
 	
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	
 	if (state != GTK_STATE_ACTIVE)
 	{
-		sflags = QStyle::Style_Selected;
+		sflags = TQStyle::Style_Selected;
 		if (tpos == GTK_POS_TOP)
 			y += 3;
 		h -= 3;
@@ -1657,21 +1657,21 @@ void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, in
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
 	
 	if ((backgroundTile) && (!backgroundTile->isNull()))
-		painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile));
+		painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile));
 	else
 	
-	painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
-	qApp->style().drawControl(QStyle::CE_TabBarTab, &painter, (QTabBar *)meepTabBar, QRect(0,0,w,h), qApp->palette().active(), sflags, QStyleOption(tab));
+	painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+	tqApp->tqstyle().tqdrawControl(TQStyle::CE_TabBarTab, &painter, (TQTabBar *)meepTabBar, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags, TQStyleOption(tab));
 	
 	painter.end(); // So the pixmap assignment below won't give an error
 	// Account for tab position -- if its in the bottom flip the image
 	if (tpos == GTK_POS_BOTTOM)
 	{
-		QWMatrix m;
+		TQWMatrix m;
 		m.scale(1, -1);
 		pixmap = pixmap.xForm(m);
 	}
@@ -1683,39 +1683,39 @@ void drawTabNG(GdkWindow *window, GtkStyle* style, GtkStateType state, int x, in
 
 void drawArrow(GdkWindow* window, GtkStyle* style, GtkStateType state, GtkArrowType direction, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
 		return;
 
-	QStyle::SFlags sflags = stateToSFlags(state);
+	TQStyle::SFlags sflags = stateToSFlags(state);
 	if (state == GTK_STATE_INSENSITIVE)
-		sflags |= QStyle::Style_Off;
+		sflags |= TQStyle::Style_Off;
 	else if (state == GTK_STATE_PRELIGHT)
-		sflags |= QStyle::Style_On;
+		sflags |= TQStyle::Style_On;
 
-	QStyle::PrimitiveElement element;
+	TQStyle::PrimitiveElement element;
 	switch(direction)
 	{
-		case GTK_ARROW_UP:    element = QStyle::PE_ArrowUp;    break;
-		case GTK_ARROW_DOWN:  element = QStyle::PE_ArrowDown;  break;
-		case GTK_ARROW_LEFT:  element = QStyle::PE_ArrowLeft;  break;
-		case GTK_ARROW_RIGHT: element = QStyle::PE_ArrowRight; break;
+		case GTK_ARROW_UP:    element = TQStyle::PE_ArrowUp;    break;
+		case GTK_ARROW_DOWN:  element = TQStyle::PE_ArrowDown;  break;
+		case GTK_ARROW_LEFT:  element = TQStyle::PE_ArrowLeft;  break;
+		case GTK_ARROW_RIGHT: element = TQStyle::PE_ArrowRight; break;
 	}
 
 	 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
 
 	if (fillPixmap && (!fillPixmap->isNull()))
-		painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *fillPixmap));
+		painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *fillPixmap));
 	else if ((backgroundTile) && (!backgroundTile->isNull()))
-		painter.fillRect(0, 0, w, h, QBrush(QColor(255,255,255), *backgroundTile));
+		painter.fillRect(0, 0, w, h, TQBrush(TQColor(255,255,255), *backgroundTile));
 	else
-		painter.fillRect(0, 0, w, h, qApp->palette().active().brush(QColorGroup::Background));
+		painter.fillRect(0, 0, w, h, tqApp->tqpalette().active().brush(TQColorGroup::Background));
 
-	qApp->style().drawPrimitive(element, &painter, QRect(0,0,w,h), qApp->palette().active(), sflags);
+	tqApp->tqstyle().tqdrawPrimitive(element, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), sflags);
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[state], pix, 0, 0, x, y, w, h);
@@ -1724,18 +1724,18 @@ void drawArrow(GdkWindow* window, GtkStyle* style, GtkStateType state, GtkArrowT
 
 void drawFocusRect(GdkWindow * window, GtkStyle * style, int x, int y, int w, int h)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((w < 1) || (h < 1))
 		return;
 
-	QPixmap pixmap(w,h);
-	QPainter painter(&pixmap);
-	QColor bg(qApp->palette().active().background());
+	TQPixmap pixmap(w,h);
+	TQPainter painter(&pixmap);
+	TQColor bg(tqApp->tqpalette().active().background());
 
 	painter.fillRect(0,0,w,h,bg);
-	qApp->style().drawPrimitive(QStyle::PE_FocusRect, &painter, QRect(0,0,w,h), qApp->palette().active(), QStyle::Style_Default, QStyleOption(bg));
+	tqApp->tqstyle().tqdrawPrimitive(TQStyle::PE_FocusRect, &painter, TQRect(0,0,w,h), tqApp->tqpalette().active(), TQStyle::Style_Default, TQStyleOption(bg));
 
 	GdkPixmap* pix = gdk_pixmap_foreign_new(pixmap.handle());
 	gdk_draw_drawable(window, style->bg_gc[GTK_STATE_NORMAL], pix, 0, 0, x, y, w, h);
@@ -1756,31 +1756,31 @@ GdkGC* alternateBackgroundGc(GtkStyle* style)
 	gdk_colormap_alloc_color(style->colormap, &altBackColor, FALSE, TRUE);
 	
 	GdkGCValues gc_values;
-	GdkGCValuesMask gc_values_mask;
-	gc_values_mask = GDK_GC_FOREGROUND;
+	GdkGCValuesMask gc_values_tqmask;
+	gc_values_tqmask = GDK_GC_FOREGROUND;
 	gc_values.foreground = altBackColor;
 	
-	altBackGC = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
+	altBackGC = (GdkGC*) gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_tqmask);
 	
 	return altBackGC;
 }
 
 
 // Thanks Martin Dvorak of metatheme
-QString parse_rc_string(const QString& defs, const QString& pattern, bool widgetClass = true)
+TQString parse_rc_string(const TQString& defs, const TQString& pattern, bool widgetClass = true)
 {
 	static int dynamic_counter = 0;
 	++dynamic_counter;
 	
-	return "style \"gtk-qt-dynamic-" + QString::number(dynamic_counter) + "\" { " + defs + " } " + (widgetClass ? "widget_class" : "widget") + " \"" + pattern + "\" style \"gtk-qt-dynamic-" + QString::number(dynamic_counter) + "\"\n";
+	return "style \"gtk-qt-dynamic-" + TQString::number(dynamic_counter) + "\" { " + defs + " } " + (widgetClass ? "widget_class" : "widget") + " \"" + pattern + "\" style \"gtk-qt-dynamic-" + TQString::number(dynamic_counter) + "\"\n";
 }
 
-QString doIconMapping(const QString& stockName, const QString& path, int sizes)
+TQString doIconMapping(const TQString& stockName, const TQString& path, int sizes)
 {
-	QString fullPath;
+	TQString fullPath;
 	bool has16 = false, has22 = false, has32 = false;
 
-	for( QStringList::ConstIterator it = iconThemeDirs.begin();
+	for( TQStringList::ConstIterator it = iconThemeDirs.begin();
 			it != iconThemeDirs.end();
 			++it )
 	{
@@ -1798,7 +1798,7 @@ QString doIconMapping(const QString& stockName, const QString& path, int sizes)
 	if (!has16 && !has22 && !has32) return "";
 	
 	// sizes is an addition of 1=16, 2=22 and 4=32
-	QString ret = "stock[\"" + stockName + "\"]={\n";
+	TQString ret = "stock[\"" + stockName + "\"]={\n";
 	
 	if (has22)
 		ret += "\t{ \"22x22/" + path +"\", *, *, \"gtk-large-toolbar\" },\n";
@@ -1827,102 +1827,102 @@ QString doIconMapping(const QString& stockName, const QString& path, int sizes)
 	return ret;
 }
 
-QString colorString(QColor color)
+TQString colorString(TQColor color)
 {
-	QString ret = "{";
-	ret += QString::number(color.red() * 257) + ", ";
-	ret += QString::number(color.green() * 257) + ", ";
-	ret += QString::number(color.blue() * 257) + "}";
+	TQString ret = "{";
+	ret += TQString::number(color.red() * 257) + ", ";
+	ret += TQString::number(color.green() * 257) + ", ";
+	ret += TQString::number(color.blue() * 257) + "}";
 	
 	return ret;
 }
 
-void setColour(QString name, QColor color)
+void setColour(TQString name, TQColor color)
 {
 	gtk_rc_parse_string(parse_rc_string(name + " = " + colorString(color), "*").latin1());
 }
 
-static QStringList iconInheritsDirs( const QString& icondir )
+static TQStringList iconInheritsDirs( const TQString& icondir )
 {
-	QFile index;
+	TQFile index;
 	index.setName( icondir + "index.theme" );
 	if( !index.open( IO_ReadOnly ))
 	{
 		index.setName( icondir + "index.desktop" );
 		if( !index.open( IO_ReadOnly ))
-			return QStringList();
+			return TQStringList();
 	}
 	char buf[ 1024 ];
-	QRegExp reg( "^\\s*Inherits=([^\\n]*)" );
+	TQRegExp reg( "^\\s*Inherits=([^\\n]*)" );
 	for(;;)
 	{
 		if( index.readLine( buf, 1023 ) <= 0 )
 			break;
 		if( reg.search( buf, 0 ) >= 0 )
-			return QStringList::split(",", reg.cap(1));
+			return TQStringList::split(",", reg.cap(1));
 	}
-	return QStringList();
+	return TQStringList();
 }
 
 void setRcProperties(GtkRcStyle* rc_style, int forceRecreate)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
-	if (gtkQtDebug)
+	if (gtkTQtDebug)
 		printf("setRcProperties()\n");
 	
 	gtkRcStyle = rc_style;
 	
 	// Set colors
 	// Normal
-	setColour("fg[NORMAL]",     qApp->palette().active().text());
-	setColour("bg[NORMAL]",     qApp->palette().active().background());
-	setColour("text[NORMAL]",   qApp->palette().active().text());
-	setColour("base[NORMAL]",   qApp->palette().active().base());
+	setColour("fg[NORMAL]",     tqApp->tqpalette().active().text());
+	setColour("bg[NORMAL]",     tqApp->tqpalette().active().background());
+	setColour("text[NORMAL]",   tqApp->tqpalette().active().text());
+	setColour("base[NORMAL]",   tqApp->tqpalette().active().base());
 	
 	// Active (on)
-	setColour("fg[ACTIVE]",     qApp->palette().active().text());
-	setColour("bg[ACTIVE]",     qApp->palette().active().background());
-	setColour("text[ACTIVE]",   qApp->palette().active().text());
-	setColour("base[ACTIVE]",   qApp->palette().active().base());
+	setColour("fg[ACTIVE]",     tqApp->tqpalette().active().text());
+	setColour("bg[ACTIVE]",     tqApp->tqpalette().active().background());
+	setColour("text[ACTIVE]",   tqApp->tqpalette().active().text());
+	setColour("base[ACTIVE]",   tqApp->tqpalette().active().base());
 	
 	// Mouseover
-	setColour("fg[PRELIGHT]",   qApp->palette().active().text()); // menu items - change?
-	setColour("bg[PRELIGHT]",   qApp->palette().active().highlight());
-	setColour("text[PRELIGHT]", qApp->palette().active().text());
-	setColour("base[PRELIGHT]", qApp->palette().active().base());
+	setColour("fg[PRELIGHT]",   tqApp->tqpalette().active().text()); // menu items - change?
+	setColour("bg[PRELIGHT]",   tqApp->tqpalette().active().highlight());
+	setColour("text[PRELIGHT]", tqApp->tqpalette().active().text());
+	setColour("base[PRELIGHT]", tqApp->tqpalette().active().base());
 	
 	// Selected
-	setColour("fg[SELECTED]",   qApp->palette().active().highlightedText());
-	setColour("bg[SELECTED]",   qApp->palette().active().highlight());
-	setColour("text[SELECTED]", qApp->palette().active().highlightedText());
-	setColour("base[SELECTED]", qApp->palette().active().highlight());
+	setColour("fg[SELECTED]",   tqApp->tqpalette().active().highlightedText());
+	setColour("bg[SELECTED]",   tqApp->tqpalette().active().highlight());
+	setColour("text[SELECTED]", tqApp->tqpalette().active().highlightedText());
+	setColour("base[SELECTED]", tqApp->tqpalette().active().highlight());
 	
 	// Disabled
-	setColour("fg[INSENSITIVE]",    qApp->palette().disabled().text());
-	setColour("bg[INSENSITIVE]",    qApp->palette().disabled().background());
-	setColour("text[INSENSITIVE]",  qApp->palette().disabled().text());
-	setColour("base[INSENSITIVE]",  qApp->palette().disabled().background());
+	setColour("fg[INSENSITIVE]",    tqApp->tqpalette().disabled().text());
+	setColour("bg[INSENSITIVE]",    tqApp->tqpalette().disabled().background());
+	setColour("text[INSENSITIVE]",  tqApp->tqpalette().disabled().text());
+	setColour("base[INSENSITIVE]",  tqApp->tqpalette().disabled().background());
 
-	gtk_rc_parse_string(("gtk-button-images = " + QString::number(showIconsOnButtons)).latin1());
+	gtk_rc_parse_string(("gtk-button-images = " + TQString::number(showIconsOnButtons)).latin1());
 	
-	gtk_rc_parse_string(("gtk-toolbar-style = " + QString::number(toolbarStyle)).latin1());
+	gtk_rc_parse_string(("gtk-toolbar-style = " + TQString::number(toolbarStyle)).latin1());
 	
 	// This function takes quite a long time to execute, and is run at the start of every app.
 	// In order to speed it up, we can store the results in a file, along with the name of icon
 	// theme and style.  This file can then be regenerated when the icon theme or style change.
 	
-	QString cacheFilePath = QDir::homeDirPath() + "/.gtk_qt_engine_rc";
-	QFile cacheFile(cacheFilePath);
-	QTextStream stream;
+	TQString cacheFilePath = TQDir::homeDirPath() + "/.gtk_qt_engine_rc";
+	TQFile cacheFile(cacheFilePath);
+	TQTextStream stream;
 	
 	if (!forceRecreate && cacheFile.exists())
 	{
 		cacheFile.open(IO_ReadOnly);
-		stream.setDevice(&cacheFile);
+		stream.setDevice(TQT_TQIODEVICE(&cacheFile));
 		
-		if (stream.readLine() == "# " + iconTheme + ", " + qApp->style().name() + ", " + RC_CACHE_VERSION)
+		if (stream.readLine() == "# " + iconTheme + ", " + tqApp->tqstyle().name() + ", " + RC_CACHE_VERSION)
 		{
 			// This cache matches the current icon theme and style
 			// Let's load it and return
@@ -1935,13 +1935,13 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate)
 	}
 	
 	cacheFile.open(IO_WriteOnly | IO_Truncate);
-	stream.setDevice(&cacheFile);
+	stream.setDevice(TQT_TQIODEVICE(&cacheFile));
 	
-	stream << "# " << iconTheme << ", " << qApp->style().name() << ", " << RC_CACHE_VERSION << "\n\n";
-	stream << "# This file was generated by the Gtk Qt Theme Engine\n";
+	stream << "# " << iconTheme << ", " << tqApp->tqstyle().name() << ", " << RC_CACHE_VERSION << "\n\n";
+	stream << "# This file was generated by the Gtk TQt Theme Engine\n";
 	stream << "# It will be recreated when you change your KDE icon theme or widget style\n\n";
 	
-	QScrollBar sbar(NULL);
+	TQScrollBar sbar(NULL);
 	sbar.setOrientation(Qt::Horizontal);
 	sbar.setValue(1);
 	sbar.resize(200,25);
@@ -1949,53 +1949,53 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate)
 	// The following code determines how many buttons are on a scrollbar
 	// It works by looking at each pixel of the scrollbar's area not taken up by the groove,
 	// and asking the style which subcontrol is at that location.
-	QRect rect = qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar, &sbar, QStyle::SC_ScrollBarGroove);
+	TQRect rect = tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar, &sbar, TQStyle::SC_ScrollBarGroove);
 	
 	bool back1 = false;
 	bool forward1 = false;
 	bool back2 = false;
 	bool forward2 = false;
 	
-	QStyle::SubControl sc = QStyle::SC_None;
-	for (QPoint pos(0,7) ; pos.x()<rect.x() ; pos.setX(pos.x()+1))
+	TQStyle::SubControl sc = TQStyle::SC_None;
+	for (TQPoint pos(0,7) ; pos.x()<rect.x() ; pos.setX(pos.x()+1))
 	{
-		QStyle::SubControl sc2 = qApp->style().querySubControl(QStyle::CC_ScrollBar, &sbar, pos);
+		TQStyle::SubControl sc2 = tqApp->tqstyle().querySubControl(TQStyle::CC_ScrollBar, &sbar, pos);
 		if (sc != sc2)
 		{
-			if (sc2 == QStyle::SC_ScrollBarAddLine) forward1 = true;
-			if (sc2 == QStyle::SC_ScrollBarSubLine) back1 = true;
+			if (sc2 == TQStyle::SC_ScrollBarAddLine) forward1 = true;
+			if (sc2 == TQStyle::SC_ScrollBarSubLine) back1 = true;
 			sc = sc2;
 		}
 	}
-	sc = QStyle::SC_None;
-	for (QPoint pos(rect.x()+rect.width(),7) ; pos.x()<200 ; pos.setX(pos.x()+1))
+	sc = TQStyle::SC_None;
+	for (TQPoint pos(rect.x()+rect.width(),7) ; pos.x()<200 ; pos.setX(pos.x()+1))
 	{
-		QStyle::SubControl sc2 = qApp->style().querySubControl(QStyle::CC_ScrollBar, &sbar, pos);
+		TQStyle::SubControl sc2 = tqApp->tqstyle().querySubControl(TQStyle::CC_ScrollBar, &sbar, pos);
 		if (sc != sc2)
 		{
-			if (sc2 == QStyle::SC_ScrollBarAddLine) forward2 = true;
-			if (sc2 == QStyle::SC_ScrollBarSubLine) back2 = true;
+			if (sc2 == TQStyle::SC_ScrollBarAddLine) forward2 = true;
+			if (sc2 == TQStyle::SC_ScrollBarSubLine) back2 = true;
 			sc = sc2;
 		}
 	}
 	
-	stream << parse_rc_string(QString("GtkScrollbar::has-backward-stepper = ") + (back1 ? "1" : "0"), "*");
-	stream << parse_rc_string(QString("GtkScrollbar::has-forward-stepper = ") + (forward2 ? "1" : "0"), "*");
-	stream << parse_rc_string(QString("GtkScrollbar::has-secondary-forward-stepper = ") + (forward1 ? "1" : "0"), "*");
-	stream << parse_rc_string(QString("GtkScrollbar::has-secondary-backward-stepper = ") + (back2 ? "1" : "0"), "*");
+	stream << parse_rc_string(TQString("GtkScrollbar::has-backward-stepper = ") + (back1 ? "1" : "0"), "*");
+	stream << parse_rc_string(TQString("GtkScrollbar::has-forward-stepper = ") + (forward2 ? "1" : "0"), "*");
+	stream << parse_rc_string(TQString("GtkScrollbar::has-secondary-forward-stepper = ") + (forward1 ? "1" : "0"), "*");
+	stream << parse_rc_string(TQString("GtkScrollbar::has-secondary-backward-stepper = ") + (back2 ? "1" : "0"), "*");
 	
-	stream << parse_rc_string("GtkScrollbar::stepper-size = " + QString::number(qApp->style().querySubControlMetrics(QStyle::CC_ScrollBar, &sbar, QStyle::SC_ScrollBarSubLine).width() - 1), "*");
+	stream << parse_rc_string("GtkScrollbar::stepper-size = " + TQString::number(tqApp->tqstyle().querySubControlMetrics(TQStyle::CC_ScrollBar, &sbar, TQStyle::SC_ScrollBarSubLine).width() - 1), "*");
 	
-	stream << parse_rc_string("GtkScrollbar::min-slider-length = " + QString::number(qApp->style().pixelMetric(QStyle::PM_ScrollBarSliderMin)), "*");
-	stream << parse_rc_string("GtkScrollbar::slider-width = " + QString::number(qApp->style().pixelMetric(QStyle::PM_ScrollBarExtent)-2), "*");
-	stream << parse_rc_string("GtkButton::child-displacement-x = " + QString::number(qApp->style().pixelMetric(QStyle::PM_ButtonShiftHorizontal)), "*");
-	stream << parse_rc_string("GtkButton::child-displacement-y = " + QString::number(qApp->style().pixelMetric(QStyle::PM_ButtonShiftVertical)), "*");
-	QSlider slider(NULL); // To keep BlueCurve happy
-	stream << parse_rc_string("GtkScale::slider-length = " + QString::number(qApp->style().pixelMetric(QStyle::PM_SliderLength, &slider)), "*");
+	stream << parse_rc_string("GtkScrollbar::min-slider-length = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_ScrollBarSliderMin)), "*");
+	stream << parse_rc_string("GtkScrollbar::slider-width = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_ScrollBarExtent)-2), "*");
+	stream << parse_rc_string("GtkButton::child-displacement-x = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_ButtonShiftHorizontal)), "*");
+	stream << parse_rc_string("GtkButton::child-displacement-y = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_ButtonShiftVertical)), "*");
+	TQSlider slider(NULL); // To keep BlueCurve happy
+	stream << parse_rc_string("GtkScale::slider-length = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_SliderLength, &slider)), "*");
 	stream << parse_rc_string("GtkButton::default-border = { 0, 0, 0, 0 }", "*");
 	
-	stream << parse_rc_string("xthickness = " + QString::number(qApp->style().pixelMetric(QStyle::PM_DefaultFrameWidth)), "*.GtkMenu");
-	stream << parse_rc_string("ythickness = " + QString::number(qApp->style().pixelMetric(QStyle::PM_DefaultFrameWidth)), "*.GtkMenu");
+	stream << parse_rc_string("xthickness = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_DefaultFrameWidth)), "*.GtkMenu");
+	stream << parse_rc_string("ythickness = " + TQString::number(tqApp->tqstyle().tqpixelMetric(TQStyle::PM_DefaultFrameWidth)), "*.GtkMenu");
 	stream << parse_rc_string("xthickness = 5", "*.GtkMenu.Gtk*MenuItem");
 	stream << parse_rc_string("xthickness = 3", "*.GtkNotebook");
 	stream << parse_rc_string("ythickness = 3", "*.GtkNotebook");
@@ -2003,7 +2003,7 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate)
 	stream << parse_rc_string("fg[NORMAL] = {0, 0, 0}", "gtk-tooltips.GtkLabel", false);
 	
 	// This one may not work...
-	//insertIntProperty(rc_style, "GtkCheckButton", "indicator-size", qApp->style().pixelMetric(QStyle::PM_IndicatorHeight) );
+	//insertIntProperty(rc_style, "GtkCheckButton", "indicator-size", tqApp->tqstyle().tqpixelMetric(TQStyle::PM_IndicatorHeight) );
 	
 	// For icons
 
@@ -2047,8 +2047,8 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate)
 	stream << doIconMapping("gtk-edit", "actions/gtk-edit.png");  //2.6 
 	stream << doIconMapping("gtk-execute", "actions/exec.png");
 	stream << doIconMapping("gtk-file", "mimetypes/gtk-file.png");
-	stream << doIconMapping("gtk-find", "actions/find.png");
-	stream << doIconMapping("gtk-find-and-replace", "actions/gtk-find-and-replace.png");
+	stream << doIconMapping("gtk-tqfind", "actions/find.png");
+	stream << doIconMapping("gtk-tqfind-and-tqreplace", "actions/gtk-tqfind-and-tqreplace.png");
 	stream << doIconMapping("gtk-floppy", "devices/3floppy_unmount.png");
 	stream << doIconMapping("gtk-fullscreen", "actions/gtk-fullscreen.png");
 	stream << doIconMapping("gtk-goto-bottom", "actions/bottom.png");
@@ -2125,58 +2125,58 @@ void setRcProperties(GtkRcStyle* rc_style, int forceRecreate)
 	gtk_rc_add_default_file(cacheFilePath.latin1());
 }
 
-void addIconThemeDir(const QString& theme)
+void addIconThemeDir(const TQString& theme)
 {
 	// Try to find this theme's directory
-	QString icondir = kdeFindDir("/share/icons/" + theme + "/", "index.theme", "index.desktop");
+	TQString icondir = kdeFindDir("/share/icons/" + theme + "/", "index.theme", "index.desktop");
 	if(icondir.isEmpty())
 		return;
-	if (iconThemeDirs.contains(icondir))
+	if (iconThemeDirs.tqcontains(icondir))
 		return;
 
 	// Add this theme to the list
 	iconThemeDirs.append(icondir);
 
-	// Do it again for any parent themes
-	QStringList parents = iconInheritsDirs(icondir);
-	for ( QStringList::Iterator it=parents.begin() ; it!=parents.end(); ++it)
+	// Do it again for any tqparent themes
+	TQStringList tqparents = iconInheritsDirs(icondir);
+	for ( TQStringList::Iterator it=tqparents.begin() ; it!=tqparents.end(); ++it)
 		addIconThemeDir((*it).stripWhiteSpace());
 }
 
 void setMenuBackground(GtkStyle* style)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if (menuBackgroundPixmap == NULL)
 	{
 		// Get the menu background image
-		menuBackgroundPixmap = new QPixmap(1024, 25); // Meh
-		QPainter painter(menuBackgroundPixmap);
-		QPopupMenu pm;
-		QMenuData md;
-		QMenuItem* mi = md.findItem(md.insertItem(""));
+		menuBackgroundPixmap = new TQPixmap(1024, 25); // Meh
+		TQPainter painter(menuBackgroundPixmap);
+		TQPopupMenu pm;
+		TQMenuData md;
+		TQMenuItem* mi = md.tqfindItem(md.insertItem(""));
 		
-		qApp->style().polish(&pm);
+		tqApp->tqstyle().polish(&pm);
 		
-		QStyleOption opt(mi, 16, 16);
-		QStyle::SFlags sflags = QStyle::Style_Default;
+		TQStyleOption opt(mi, 16, 16);
+		TQStyle::SFlags sflags = TQStyle::Style_Default;
 	
 		if ((backgroundTile) && (!backgroundTile->isNull()))
-			painter.fillRect(0, 0, 1024, 25, QBrush(QColor(255,255,255), *backgroundTile));
+			painter.fillRect(0, 0, 1024, 25, TQBrush(TQColor(255,255,255), *backgroundTile));
 		else
-			painter.fillRect(0, 0, 1024, 25, qApp->palette().active().brush(QColorGroup::Background));
-		qApp->style().drawControl(QStyle::CE_PopupMenuItem, &painter, &pm, QRect(0,0,1024,25), qApp->palette().active(), sflags, opt);
+			painter.fillRect(0, 0, 1024, 25, tqApp->tqpalette().active().brush(TQColorGroup::Background));
+		tqApp->tqstyle().tqdrawControl(TQStyle::CE_PopupMenuItem, &painter, &pm, TQRect(0,0,1024,25), tqApp->tqpalette().active(), sflags, opt);
 		
 		menuBackgroundPixmapGdk = gdk_pixmap_foreign_new(menuBackgroundPixmap->handle());
 	}
 
-	QTENGINE_STYLE(style)->menuBackground = menuBackgroundPixmapGdk;
+	TQTENGINE_STYLE(style)->menuBackground = menuBackgroundPixmapGdk;
 	g_object_ref(menuBackgroundPixmapGdk);
 }
 
 // It has a 'u' damnit
-void setColour(GdkColor* g, QColor q)
+void setColour(GdkColor* g, TQColor q)
 {
 	g->red = q.red() * 257;
 	g->green = q.green() * 257;
@@ -2185,10 +2185,10 @@ void setColour(GdkColor* g, QColor q)
 
 void setColors(GtkStyle* style)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
-	if (gtkQtDebug)
+	if (gtkTQtDebug)
 		printf("setColors()\n");
 	
 	/*gtkStyle = style;*/
@@ -2206,13 +2206,13 @@ void setColors(GtkStyle* style)
 
 void getTextColor(GdkColor *color, GtkStateType state_type)
 {
-	if (!gtkQtEnable)
+	if (!gtkTQtEnable)
 		return;
 	
 	if ((state_type == GTK_STATE_PRELIGHT) || (state_type == GTK_STATE_ACTIVE) || (state_type == GTK_STATE_SELECTED))
-		setColour(color, qApp->palette().active().highlightedText());
+		setColour(color, tqApp->tqpalette().active().highlightedText());
 	else if (state_type == GTK_STATE_NORMAL)
-		setColour(color, qApp->palette().active().text());
+		setColour(color, tqApp->tqpalette().active().text());
 	else if (state_type == GTK_STATE_INSENSITIVE)
-		setColour(color, qApp->palette().disabled().text());
+		setColour(color, tqApp->tqpalette().disabled().text());
 }