Initial import

1 files changed, 1586 insertions, 0 deletions

diff --git a/plugin/simplestyle.cpp b/plugin/simplestyle.cpp
new file mode 100644
index 0000000..08299dc
--- /dev/null
+++ b/plugin/simplestyle.cpp
@@ -0,0 +1,1586 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Timothy Pearson.  All rights reserved.
+**
+** This file is part of the TDE Qt4 style interface
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#define TQT_NO_COMPAT_NAMES
+#include <tqstyle.h>
+#include <tqpixmap.h>
+#include <tqpainter.h>
+#include <tqapplication.h>
+#include <tqprogressbar.h>
+#include <tqtabbar.h>
+#include <tqradiobutton.h>
+#include <tqpopupmenu.h>
+#include <tqmenudata.h>
+#include <tqcombobox.h>
+#include <tqiconset.h>
+#undef Qt
+
+#include <QtGui/QtGui>
+#include <QtGui/QX11Info>
+
+#include "simplestyle.h"
+#include "tdeqt4painter.h"
+
+#define INTEGRATE_WITH_TDE 1
+
+#ifdef INTEGRATE_WITH_TDE
+#undef Q_OBJECT
+#define Q_OBJECT TQ_OBJECT
+#include <kapplication.h>
+#include <kcmdlineargs.h>
+#include <kaboutdata.h>
+#include <kicontheme.h>
+#endif
+
+#define DEBUG_WARNINGS 1
+// #define DEBUG_SPEW 1
+
+inline QColor convertTQt3ToQt4Color(TQColor tqt3color)
+{
+	return QColor(tqt3color.red(), tqt3color.green(), tqt3color.blue());
+}
+
+inline TQColor convertQt4ToTQt3Color(QColor qt4color)
+{
+	return TQColor(qt4color.red(), qt4color.green(), qt4color.blue());
+}
+
+inline QString convertTQt3ToQt4String(TQString tqt3string)
+{
+	return QString::fromUtf8(tqt3string.utf8().data());
+}
+
+inline TQString convertQt4ToTQt3String(QString qt4string)
+{
+	return TQString::fromUtf8(qt4string.toUtf8().data());
+}
+
+inline TQIconSet convertQt4ToTQt3IconSet(QIcon qt4icon)
+{
+	int i=0;
+	int j=0;
+	QIcon::Mode qt4iconmode;
+	TQIconSet::Mode tqt3iconmode;
+	QIcon::State qt4iconstate;
+	TQIconSet::State tqt3iconstate;
+
+	TQIconSet tqt3iconset;
+
+	// Get the maximum icon size stored in the QIcon and generate a pixmap of that size
+	QSize qt4size = qt4icon.actualSize(QSize(32768,32768));
+
+	for (i=0;i<3;i++) {
+		for (j=0;j<2;j++) {
+			if (i==0) {
+				qt4iconmode = QIcon::Normal;
+				tqt3iconmode = TQIconSet::Normal;
+			}
+			if (i==1) {
+				qt4iconmode = QIcon::Disabled;
+				tqt3iconmode = TQIconSet::Disabled;
+			}
+			if (i==2) {
+				qt4iconmode = QIcon::Active;
+				tqt3iconmode = TQIconSet::Active;
+			}
+			if (j==0) {
+				qt4iconstate = QIcon::On;
+				tqt3iconstate = TQIconSet::On;
+			}
+			if (j==1) {
+				qt4iconstate = QIcon::Off;
+				tqt3iconstate = TQIconSet::Off;
+			}
+			QPixmap qt4iconpm = qt4icon.pixmap(qt4size, qt4iconmode, qt4iconstate);
+			TQPixmap tqtPM(qt4iconpm.width(), qt4iconpm.height(), qt4iconpm.depth());
+			QPixmap qtPM = QPixmap::fromX11Pixmap(tqtPM.handle(), QPixmap::ExplicitlyShared);
+			QPainter qt4painter(&qtPM);
+			qt4painter.drawPixmap(0, 0, qt4iconpm);
+			qt4painter.end();
+
+			tqt3iconset.setPixmap(tqtPM, TQIconSet::Automatic, tqt3iconmode, tqt3iconstate);
+		}
+	}
+
+	return tqt3iconset;
+}
+
+inline TQPixmap convertQt4ToTQt3Pixmap(QIcon qt4icon)
+{
+	// Get the maximum icon size stored in the QIcon and generate a pixmap of that size
+	QSize qt4size = qt4icon.actualSize(QSize(32768,32768));
+
+	QPixmap qt4iconpm = qt4icon.pixmap(qt4size);
+	TQPixmap tqtPM(qt4iconpm.width(), qt4iconpm.height(), qt4iconpm.depth());
+	QPixmap qtPM = QPixmap::fromX11Pixmap(tqtPM.handle(), QPixmap::ExplicitlyShared);
+	QPainter qt4painter(&qtPM);
+	qt4painter.drawPixmap(0, 0, qt4iconpm);
+	qt4painter.end();
+
+	return tqtPM;
+}
+
+inline QRect convertTQt3ToQt4Rect(TQRect tqt3rect)
+{
+	return QRect(tqt3rect.x(), tqt3rect.y(), tqt3rect.width(), tqt3rect.height());
+}
+
+inline QBrush convertTQt3ToQt4Brush(TQBrush tqt3brush)
+{
+	QBrush qt4brush;
+	TQt::BrushStyle tqt3brushstyle = tqt3brush.style();
+	Qt::BrushStyle qt4brushstyle;
+
+	switch ( tqt3brushstyle ) {
+		case TQt::NoBrush:
+			qt4brushstyle = Qt::NoBrush;
+			break;
+		case TQt::SolidPattern:
+			qt4brushstyle = Qt::SolidPattern;
+			break;
+		case TQt::Dense1Pattern:
+			qt4brushstyle = Qt::Dense1Pattern;
+			break;
+		case TQt::Dense2Pattern:
+			qt4brushstyle = Qt::Dense2Pattern;
+			break;
+		case TQt::Dense3Pattern:
+			qt4brushstyle = Qt::Dense3Pattern;
+			break;
+		case TQt::Dense4Pattern:
+			qt4brushstyle = Qt::Dense4Pattern;
+			break;
+		case TQt::Dense5Pattern:
+			qt4brushstyle = Qt::Dense5Pattern;
+			break;
+		case TQt::Dense6Pattern:
+			qt4brushstyle = Qt::Dense6Pattern;
+			break;
+		case TQt::Dense7Pattern:
+			qt4brushstyle = Qt::Dense7Pattern;
+			break;
+		case TQt::HorPattern:
+			qt4brushstyle = Qt::HorPattern;
+			break;
+		case TQt::VerPattern:
+			qt4brushstyle = Qt::VerPattern;
+			break;
+		case TQt::CrossPattern:
+			qt4brushstyle = Qt::CrossPattern;
+			break;
+		case TQt::BDiagPattern:
+			qt4brushstyle = Qt::BDiagPattern;
+			break;
+		case TQt::FDiagPattern:
+			qt4brushstyle = Qt::FDiagPattern;
+			break;
+		case TQt::DiagCrossPattern:
+			qt4brushstyle = Qt::DiagCrossPattern;
+			break;
+		case TQt::CustomPattern:
+			qt4brushstyle = Qt::TexturePattern;
+			break;
+		default:
+			qt4brushstyle = Qt::NoBrush;
+#if defined(QT_CHECK_RANGE)
+			tqWarning( "convertTQt3ToQt4Brush: Invalid brush style %d", tqt3brushstyle );
+#endif
+	}
+	qt4brush.setStyle(qt4brushstyle);
+	TQColor qt3color = tqt3brush.color();
+	qt4brush.setColor(QColor(qt3color.red(), qt3color.green(), qt3color.blue(), 255));
+	if (qt4brushstyle == Qt::TexturePattern) {
+		TQPixmap tqtPM = *tqt3brush.pixmap();
+		QPixmap qtPM = QPixmap::fromX11Pixmap(tqtPM.handle(), QPixmap::ImplicitlyShared);
+		qt4brush.setTexture(qtPM);
+	}
+
+	return qt4brush;
+}
+
+inline TQBrush convertQt4ToTQt3Brush(QBrush qt4brush)
+{
+	TQBrush tqt3brush;
+	Qt::BrushStyle qt4brushstyle = qt4brush.style();
+	TQt::BrushStyle tqt3brushstyle;
+
+	switch ( qt4brushstyle ) {
+		case Qt::NoBrush:
+			tqt3brushstyle = TQt::NoBrush;
+			break;
+		case Qt::SolidPattern:
+			tqt3brushstyle = TQt::SolidPattern;
+			break;
+		case Qt::Dense1Pattern:
+			tqt3brushstyle = TQt::Dense1Pattern;
+			break;
+		case Qt::Dense2Pattern:
+			tqt3brushstyle = TQt::Dense2Pattern;
+			break;
+		case Qt::Dense3Pattern:
+			tqt3brushstyle = TQt::Dense3Pattern;
+			break;
+		case Qt::Dense4Pattern:
+			tqt3brushstyle = TQt::Dense4Pattern;
+			break;
+		case Qt::Dense5Pattern:
+			tqt3brushstyle = TQt::Dense5Pattern;
+			break;
+		case Qt::Dense6Pattern:
+			tqt3brushstyle = TQt::Dense6Pattern;
+			break;
+		case Qt::Dense7Pattern:
+			tqt3brushstyle = TQt::Dense7Pattern;
+			break;
+		case Qt::HorPattern:
+			tqt3brushstyle = TQt::HorPattern;
+			break;
+		case Qt::VerPattern:
+			tqt3brushstyle = TQt::VerPattern;
+			break;
+		case Qt::CrossPattern:
+			tqt3brushstyle = TQt::CrossPattern;
+			break;
+		case Qt::BDiagPattern:
+			tqt3brushstyle = TQt::BDiagPattern;
+			break;
+		case Qt::FDiagPattern:
+			tqt3brushstyle = TQt::FDiagPattern;
+			break;
+		case Qt::DiagCrossPattern:
+			tqt3brushstyle = TQt::DiagCrossPattern;
+			break;
+		case Qt::TexturePattern:
+			tqt3brushstyle = TQt::CustomPattern;
+			break;
+		default:
+			tqt3brushstyle = TQt::NoBrush;
+#if defined(QT_CHECK_RANGE)
+			tqWarning( "convertQt4ToTQt3Brush: Invalid brush style %d", tqt3brushstyle );
+#endif
+	}
+	tqt3brush.setStyle(tqt3brushstyle);
+	QColor qt4color = qt4brush.color();
+	tqt3brush.setColor(TQColor(qt4color.red(), qt4color.green(), qt4color.blue()));
+	if (tqt3brushstyle == TQt::CustomPattern) {
+		QPixmap qt4texture = qt4brush.texture();
+		TQPixmap tqtPM(qt4texture.width(), qt4texture.height(), qt4texture.depth());
+		QPixmap qtPM = QPixmap::fromX11Pixmap(tqtPM.handle(), QPixmap::ExplicitlyShared);
+		QPainter qt4painter(&qtPM);
+		qt4painter.drawPixmap(0, 0, qt4texture);
+		qt4painter.end();
+		tqt3brush.setPixmap(tqtPM);
+	}
+
+	return tqt3brush;
+}
+
+inline QPalette convertTQt3ToQt4Palette(TQPalette tqt3palette)
+{
+	int i;
+	QPalette qt4palette;
+
+	// Color groups
+	TQPalette::ColorGroup tqt3cgroup;
+	QPalette::ColorGroup qt4cgroup;
+	TQColor tqt3color;
+	for (i=0;i<3;i++) {
+		if (i == 0) {
+			tqt3cgroup = TQPalette::Disabled;
+			qt4cgroup = QPalette::Disabled;
+		}
+		if (i == 1) {
+			tqt3cgroup = TQPalette::Active;
+			qt4cgroup = QPalette::Active;
+		}
+		if (i == 2) {
+			tqt3cgroup = TQPalette::Inactive;
+			qt4cgroup = QPalette::Inactive;
+		}
+
+		// Brushes
+		qt4palette.setBrush(qt4cgroup, QPalette::Background, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Background)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Foreground, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Foreground)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Base, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Base)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Text, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Text)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Button, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Button)));
+		qt4palette.setBrush(qt4cgroup, QPalette::ButtonText, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::ButtonText)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Light, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Light)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Midlight, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Midlight)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Dark, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Dark)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Mid, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Mid)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Shadow, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Shadow)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Highlight, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Highlight)));
+		qt4palette.setBrush(qt4cgroup, QPalette::HighlightedText, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::HighlightedText)));
+		qt4palette.setBrush(qt4cgroup, QPalette::BrightText, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::BrightText)));
+		qt4palette.setBrush(qt4cgroup, QPalette::Link, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::Link)));
+		qt4palette.setBrush(qt4cgroup, QPalette::LinkVisited, convertTQt3ToQt4Brush(tqt3palette.brush(tqt3cgroup, TQColorGroup::LinkVisited)));
+
+		// Colors
+		qt4palette.setColor(qt4cgroup, QPalette::Background, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Background)));
+		qt4palette.setColor(qt4cgroup, QPalette::Foreground, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Foreground)));
+		qt4palette.setColor(qt4cgroup, QPalette::Base, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Base)));
+		qt4palette.setColor(qt4cgroup, QPalette::Text, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Text)));
+		qt4palette.setColor(qt4cgroup, QPalette::Button, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Button)));
+		qt4palette.setColor(qt4cgroup, QPalette::ButtonText, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::ButtonText)));
+		qt4palette.setColor(qt4cgroup, QPalette::Light, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Light)));
+		qt4palette.setColor(qt4cgroup, QPalette::Midlight, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Midlight)));
+		qt4palette.setColor(qt4cgroup, QPalette::Dark, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Dark)));
+		qt4palette.setColor(qt4cgroup, QPalette::Mid, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Mid)));
+		qt4palette.setColor(qt4cgroup, QPalette::Shadow, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Shadow)));
+		qt4palette.setColor(qt4cgroup, QPalette::Highlight, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Highlight)));
+		qt4palette.setColor(qt4cgroup, QPalette::HighlightedText, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::HighlightedText)));
+		qt4palette.setColor(qt4cgroup, QPalette::BrightText, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::BrightText)));
+		qt4palette.setColor(qt4cgroup, QPalette::Link, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::Link)));
+		qt4palette.setColor(qt4cgroup, QPalette::LinkVisited, convertTQt3ToQt4Color(tqt3palette.color(tqt3cgroup, TQColorGroup::LinkVisited)));
+	}
+
+	return qt4palette;
+}
+
+inline TQPalette convertQt4ToTQt3Palette(QPalette qt4palette)
+{
+	int i;
+	TQPalette tqt3palette;
+
+	// Color groups
+	TQPalette::ColorGroup tqt3cgroup;
+	QPalette::ColorGroup qt4cgroup;
+	TQColor tqt3color;
+	for (i=0;i<3;i++) {
+		if (i == 0) {
+			tqt3cgroup = TQPalette::Disabled;
+			qt4cgroup = QPalette::Disabled;
+		}
+		if (i == 1) {
+			tqt3cgroup = TQPalette::Active;
+			qt4cgroup = QPalette::Active;
+		}
+		if (i == 2) {
+			tqt3cgroup = TQPalette::Inactive;
+			qt4cgroup = QPalette::Inactive;
+		}
+
+		// Brushes
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Background, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Background)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Foreground, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Foreground)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Base, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Base)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Text, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Text)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Button, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Button)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::ButtonText, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::ButtonText)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Light, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Light)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Midlight, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Midlight)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Dark, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Dark)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Mid, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Mid)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Shadow, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Shadow)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Highlight, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Highlight)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::HighlightedText, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::HighlightedText)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::BrightText, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::BrightText)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::Link, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::Link)));
+		tqt3palette.setBrush(tqt3cgroup, TQColorGroup::LinkVisited, convertQt4ToTQt3Brush(qt4palette.brush(qt4cgroup, QPalette::LinkVisited)));
+
+		// Colors
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Background, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Background)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Foreground, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Foreground)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Base, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Base)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Text, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Text)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Button, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Button)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::ButtonText, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::ButtonText)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Light, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Light)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Midlight, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Midlight)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Dark, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Dark)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Mid, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Mid)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Shadow, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Shadow)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Highlight, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Highlight)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::HighlightedText, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::HighlightedText)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::BrightText, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::BrightText)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::Link, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::Link)));
+		tqt3palette.setColor(tqt3cgroup, TQColorGroup::LinkVisited, convertQt4ToTQt3Color(qt4palette.color(qt4cgroup, QPalette::LinkVisited)));
+	}
+
+	return tqt3palette;
+}
+
+inline TQStyle::SFlags convertQt4ToTQt3SFlags(QStyle::State qt4stateflags, TQt3WidgetType wt)
+{
+	// Convert sflags
+	TQStyle::SFlags sflags = 0;
+
+	if (qt4stateflags & QStyle::State_Active) {
+		if (wt != TQT3WT_TQPopupMenu) {
+			sflags = sflags | TQStyle::Style_Active;
+		}
+	}
+	if (qt4stateflags & QStyle::State_AutoRaise) {
+		sflags = sflags | TQStyle::Style_AutoRaise;
+	}
+// 	if (qt4stateflags & QStyle::State_Children) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+	if (qt4stateflags & QStyle::State_DownArrow) {
+		sflags = sflags | TQStyle::Style_Down;
+	}
+// 	if (qt4stateflags & QStyle::State_Editing) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+	if (qt4stateflags & QStyle::State_Enabled) {
+		sflags = sflags | TQStyle::Style_Enabled;
+	}
+// 	if (qt4stateflags & QStyle::State_HasEditFocus) {
+// 		sflags = sflags | TQStyle::Style_HasFocus;
+// 	}
+	if (qt4stateflags & QStyle::State_HasFocus) {
+		sflags = sflags | TQStyle::Style_HasFocus;
+	}
+	if (qt4stateflags & QStyle::State_Horizontal) {
+		sflags = sflags | TQStyle::Style_Horizontal;
+	}
+// 	if (qt4stateflags & QStyle::State_KeyboardFocusChange) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+	if (qt4stateflags & QStyle::State_MouseOver) {
+		sflags = sflags | TQStyle::Style_MouseOver;
+	}
+	if (qt4stateflags & QStyle::State_NoChange) {
+		sflags = sflags | TQStyle::Style_NoChange;
+	}
+	if (qt4stateflags & QStyle::State_Off) {
+		sflags = sflags | TQStyle::Style_Off;
+	}
+	if (qt4stateflags & QStyle::State_On) {
+		sflags = sflags | TQStyle::Style_On;
+	}
+	if (qt4stateflags & QStyle::State_Raised) {
+		sflags = sflags | TQStyle::Style_Raised;
+	}
+// 	if (qt4stateflags & QStyle::State_ReadOnly) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+	if (qt4stateflags & QStyle::State_Selected) {
+		if (wt == TQT3WT_TQPopupMenu) {
+			sflags = sflags | TQStyle::Style_Active;
+		}
+		sflags = sflags | TQStyle::Style_Selected;
+	}
+// 	if (qt4stateflags & QStyle::State_Item) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+// 	if (qt4stateflags & QStyle::State_Open) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+// 	if (qt4stateflags & QStyle::State_Sibling) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+	if (qt4stateflags & QStyle::State_Sunken) {
+		sflags = sflags | TQStyle::Style_Sunken;
+	}
+	if (qt4stateflags & QStyle::State_UpArrow) {
+		sflags = sflags | TQStyle::Style_Up;
+	}
+// 	if (qt4stateflags & QStyle::State_Mini) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+// 	if (qt4stateflags & QStyle::State_Small) {
+// 		sflags = sflags | TQStyle::;
+// 	}
+
+	return sflags;
+}
+
+SimpleStyle::SimpleStyle()
+{
+#ifdef INTEGRATE_WITH_TDE
+	if (!tqApp) {
+		// Initialize KApplication required data structures
+		int argc = 1;
+		char** argv;
+		// Supply it with fake data to keep KApplication happy
+		argv = (char**) malloc(sizeof(char*));
+		argv[0] = (char*) malloc(sizeof(char) * 19);
+		strncpy(argv[0], "SimpleStyle", 19);
+
+		KAboutData aboutData("SimpleStyle", I18N_NOOP("SimpleStyle"), "v0.1",
+			"TDE Qt4 theme engine", KAboutData::License_GPL,
+			"(c) 2012, Timothy Pearson",
+			"message goes here", 0 /* TODO: Website */, "kb9vqf@pearsoncomputing.net");
+		KCmdLineArgs::init(argc, argv, &aboutData);
+
+		// Qt4 can be SO STUPID sometimes...why can't I get the X11 display directly from qApp?!?!??
+		QWidget myhackedwidget;
+		new KApplication(myhackedwidget.x11Info().display());
+	}
+
+	// Set the Qt4 icon set to the TDE icon set
+	QIcon::setThemeName(convertTQt3ToQt4String(KIconTheme::current()));
+#else // INTEGRATE_WITH_TDE
+	if (!tqApp) {
+		// Qt4 can be SO STUPID sometimes...why can't I get the X11 display directly from qApp?!?!??
+		QWidget myhackedwidget;
+		new TQApplication(myhackedwidget.x11Info().display());
+	}
+#endif // INTEGRATE_WITH_TDE
+
+	// Set the Qt4 palette to the TQt3 palette
+	qApp->setPalette(convertTQt3ToQt4Palette(tqApp->palette()));
+
+	// Create interface widgets
+	m_tqt3parent_widget = new TQWidget();
+
+	m_tqt3progressbar_widget = new TQProgressBar(m_tqt3parent_widget);
+	m_tqt3tabbar_widget = new TQTabBar(m_tqt3parent_widget);
+	m_tqt3radiobutton_widget = new TQRadioButton(m_tqt3parent_widget);
+	m_tqt3popupmenu_widget = new TQPopupMenu(m_tqt3parent_widget);
+	m_tqt3combobox_widget = new TQComboBox(m_tqt3parent_widget);
+}
+
+SimpleStyle::~SimpleStyle()
+{
+//	delete tqApp;
+
+	// Delete interface widgets
+	// Widgets are deleted when their parent is deleted...these lines will cause a crash on exit
+// 	delete m_tqt3progressbar_widget;
+// 	delete m_tqt3tabbar_widget;
+// 	delete m_tqt3radiobutton_widget;
+// 	delete m_tqt3popupmenu_widget;
+// 	delete m_tqt3combobox_widget;
+
+	// FIXME
+	// Verify I'm not leaking memory like a sieve when this is commented out!!!
+// 	delete m_tqt3parent_widget;
+}
+
+void SimpleStyle::polish(QPalette &palette)
+{
+	// FIXME
+	// Figure out some way to polish the Qt4 widgets with the Qt3 polish method
+	// This probably involves modifying Qt3 to specify a painter...
+}
+
+void SimpleStyle::polish(QWidget *widget)
+{
+	// HACK
+	// Many TQt3 styles need to be notified when their widgets are moused over
+	// The only way we can really do that here is to force a repaint on mouse entry/mouse exit
+	// I figure if Qt4 programmers and users can put up with Qt4's overall poor raster graphics
+	// performance, they can also put up with this hack...
+        widget->setMouseTracking(true);
+        widget->installEventFilter(this);
+}
+
+void SimpleStyle::unpolish(QWidget *widget)
+{
+	// HACK
+	// See SimpleStyle::polish
+        widget->setMouseTracking(false);
+        widget->removeEventFilter(this);
+}
+
+bool SimpleStyle::eventFilter(QObject *obj, QEvent *ev)
+{
+	// HACK
+	// See SimpleStyle::polish
+	if (!obj->isWidgetType() ) {
+		return false;
+	}
+
+	QWidget* widget = static_cast<QWidget*>(obj);
+
+	if ((ev->type() == QEvent::FocusIn) || (ev->type() == QEvent::FocusOut)
+		 || (ev->type() == QEvent::Enter) || (ev->type() == QEvent::Leave) || (ev->type() == QEvent::Wheel)) {
+		widget->repaint();
+	}
+	else {
+// 		if (dynamic_cast<QTabBar*>(obj)) {
+			if (ev->type() == QEvent::MouseMove) {
+				QTabBar *tabbar = dynamic_cast<QTabBar*>(obj);
+				QMouseEvent *me = dynamic_cast<QMouseEvent*>(ev);
+				if (tabbar && me) {
+					// FIXME
+					// Avoid unnecessary repaints (which otherwise would occour on every
+					// MouseMove event causing high cpu load).
+					// FIXME
+					// Tab highlighting won't work unless we keep the same tabbar object,
+					// and specifically tab objects, while the mouse is being moved within
+					// the tabbar...also the eventFilter method of the style needs to be called...
+
+					bool repaint = true;
+
+// 					QTab *tab = tabbar->selectTab(me->pos() );
+// 					if (hoverTab == tab)
+// 						repaint = false;
+// 					hoverTab = tab;
+
+					if (repaint)
+						tabbar->repaint();
+				}
+			}
+// 		}
+	}
+
+	// Transparently pass the event on to any other handlers
+	return false;
+}
+
+int SimpleStyle::pixelMetric(PixelMetric metric, const QStyleOption *opt, const QWidget *w ) const
+{
+	int retval = 0;
+	TQWidget* interfaceWidget = 0;
+
+	char retswitch = 0;
+	TQStyle::PixelMetric tqt3pixelmetric = TQStyle::PM_CustomBase;
+	switch (metric) {
+		case QStyle::PM_ButtonMargin:
+			tqt3pixelmetric = TQStyle::PM_ButtonMargin;
+			retswitch = 1;
+			break;
+// 		case QStyle::PM_DockWidgetTitleBarButtonMargin:
+// 			tqt3pixelmetric = TQStyle::;
+// 			retswitch = 1;
+// 			break;
+		case QStyle::PM_ButtonDefaultIndicator:
+			tqt3pixelmetric = TQStyle::PM_ButtonDefaultIndicator;
+			retswitch = 1;
+			break;
+		case QStyle::PM_MenuButtonIndicator:
+			tqt3pixelmetric = TQStyle::PM_MenuButtonIndicator;
+			retswitch = 1;
+			break;
+		case QStyle::PM_ButtonShiftHorizontal:
+			tqt3pixelmetric = TQStyle::PM_ButtonShiftHorizontal;
+			retswitch = 1;
+			break;
+		case QStyle::PM_ButtonShiftVertical:
+			tqt3pixelmetric = TQStyle::PM_ButtonShiftVertical;
+			retswitch = 1;
+			break;
+		case QStyle::PM_DefaultFrameWidth:
+			tqt3pixelmetric = TQStyle::PM_DefaultFrameWidth;
+			retswitch = 1;
+			break;
+		case QStyle::PM_SpinBoxFrameWidth:
+			tqt3pixelmetric = TQStyle::PM_SpinBoxFrameWidth;
+			retswitch = 1;
+			break;
+// 		case QStyle::PM_ComboBoxFrameWidth:
+// 			tqt3pixelmetric = TQStyle::PM_ComboBoxFrameWidth;
+// 			retswitch = 1;
+// 			break;
+		case QStyle::PM_MDIFrameWidth:
+			tqt3pixelmetric = TQStyle::PM_MDIFrameWidth;
+			retswitch = 1;
+			break;
+// 		case QStyle::PM_MdiSubWindowFrameWidth:
+// 			tqt3pixelmetric = TQStyle::PM_MdiSubWindowFrameWidth;
+// 			retswitch = 1;
+// 			break;
+		case QStyle::PM_MDIMinimizedWidth:
+			tqt3pixelmetric = TQStyle::PM_MDIMinimizedWidth;
+			retswitch = 1;
+			break;
+// 		case QStyle::PM_MdiSubWindowMinimizedWidth:
+// 			tqt3pixelmetric = TQStyle::PM_MdiSubWindowMinimizedWidth;
+// 			retswitch = 1;
+// 			break;
+		case QStyle::PM_LayoutLeftMargin:
+			retval = 0;
+			retswitch = 2;
+			break;
+		case QStyle::PM_LayoutTopMargin:
+			retval = 0;
+			retswitch = 2;
+			break;
+		case QStyle::PM_LayoutRightMargin:
+			retval = 0;
+			retswitch = 2;
+			break;
+		case QStyle::PM_LayoutBottomMargin:
+			retval = 0;
+			retswitch = 2;
+			break;
+		case QStyle::PM_LayoutHorizontalSpacing:
+			retval = 0;
+			retswitch = 2;
+			break;
+		case QStyle::PM_LayoutVerticalSpacing:
+			retval = 0;
+			retswitch = 2;
+			break;
+		case QStyle::PM_MaximumDragDistance:
+			tqt3pixelmetric = TQStyle::PM_MaximumDragDistance;
+			retswitch = 1;
+			break;
+		case QStyle::PM_ScrollBarExtent:
+			tqt3pixelmetric = TQStyle::PM_ScrollBarExtent;
+			retswitch = 1;
+			break;
+		case QStyle::PM_ScrollBarSliderMin:
+			tqt3pixelmetric = TQStyle::PM_ScrollBarSliderMin;
+			retswitch = 1;
+			break;
+		case QStyle::PM_SliderThickness:
+			tqt3pixelmetric = TQStyle::PM_SliderThickness;
+			retswitch = 1;
+			break;
+		case QStyle::PM_SliderControlThickness:
+			tqt3pixelmetric = TQStyle::PM_SliderControlThickness;
+			retswitch = 1;
+			break;
+		case QStyle::PM_SliderLength:
+			tqt3pixelmetric = TQStyle::PM_SliderLength;
+			retswitch = 1;
+			break;
+		case QStyle::PM_SliderTickmarkOffset:
+			tqt3pixelmetric = TQStyle::PM_SliderTickmarkOffset;
+			retswitch = 1;
+			break;
+		case QStyle::PM_SliderSpaceAvailable:
+			tqt3pixelmetric = TQStyle::PM_SliderSpaceAvailable;
+			retswitch = 1;
+			break;
+		case QStyle::PM_DockWidgetSeparatorExtent:
+			tqt3pixelmetric = TQStyle::PM_DockWindowSeparatorExtent;
+			retswitch = 1;
+			break;
+		case QStyle::PM_DockWidgetHandleExtent:
+			tqt3pixelmetric = TQStyle::PM_DockWindowHandleExtent;
+			retswitch = 1;
+			break;
+		case QStyle::PM_DockWidgetFrameWidth:
+			tqt3pixelmetric = TQStyle::PM_DockWindowFrameWidth;
+			retswitch = 1;
+			break;
+// 		case QStyle::PM_DockWidgetTitleMargin:
+// 			tqt3pixelmetric = TQStyle::PM_DockWindowTitleMargin;
+// 			retswitch = 1;
+// 			break;
+		case QStyle::PM_MenuBarPanelWidth:
+			tqt3pixelmetric = TQStyle::PM_MenuBarFrameWidth;
+			retswitch = 1;
+			break;
+		case QStyle::PM_MenuBarItemSpacing:
+			tqt3pixelmetric = TQStyle::PM_MenuBarItemSpacing;
+			retswitch = 1;
+			break;
+// 		case QStyle::PM_MenuBarHMargin:
+// 			tqt3pixelmetric = TQStyle::PM_MenuBarHMargin;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_MenuBarVMargin:
+// 			tqt3pixelmetric = TQStyle::PM_MenuBarVMargin;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ToolBarFrameWidth:
+// 			tqt3pixelmetric = TQStyle::PM_ToolBarFrameWidth;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ToolBarHandleExtent:
+// 			tqt3pixelmetric = TQStyle::PM_ToolBarHandleExtent;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ToolBarItemMargin:
+// 			tqt3pixelmetric = TQStyle::PM_ToolBarItemMargin;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ToolBarItemSpacing:
+// 			tqt3pixelmetric = TQStyle::PM_ToolBarItemSpacing;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ToolBarSeparatorExtent:
+// 			tqt3pixelmetric = TQStyle::PM_ToolBarSeparatorExtent;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ToolBarExtensionExtent:
+// 			tqt3pixelmetric = TQStyle::PM_ToolBarExtensionExtent;
+// 			retswitch = 1;
+// 			break;
+		case QStyle::PM_TabBarTabOverlap:
+			tqt3pixelmetric = TQStyle::PM_TabBarTabOverlap;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			retswitch = 1;
+			break;
+		case QStyle::PM_TabBarTabHSpace:
+			tqt3pixelmetric = TQStyle::PM_TabBarTabHSpace;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			retswitch = 1;
+			break;
+		case QStyle::PM_TabBarTabVSpace:
+			tqt3pixelmetric = TQStyle::PM_TabBarTabVSpace;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			retswitch = 1;
+			break;
+		case QStyle::PM_TabBarBaseHeight:
+			tqt3pixelmetric = TQStyle::PM_TabBarBaseHeight;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			retswitch = 1;
+			break;
+		case QStyle::PM_TabBarBaseOverlap:
+			tqt3pixelmetric = TQStyle::PM_TabBarBaseOverlap;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			retswitch = 1;
+			break;
+		case QStyle::PM_TabBarScrollButtonWidth:
+			tqt3pixelmetric = TQStyle::PM_TabBarScrollButtonWidth;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			retswitch = 1;
+			break;
+		case QStyle::PM_TabBarTabShiftHorizontal:
+			tqt3pixelmetric = TQStyle::PM_TabBarTabShiftHorizontal;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			retswitch = 1;
+			break;
+		case QStyle::PM_TabBarTabShiftVertical:
+			tqt3pixelmetric = TQStyle::PM_TabBarTabShiftVertical;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			retswitch = 1;
+			break;
+		case QStyle::PM_ProgressBarChunkWidth:
+			tqt3pixelmetric = TQStyle::PM_ProgressBarChunkWidth;
+			retswitch = 1;
+			break;
+		case QStyle::PM_SplitterWidth:
+			tqt3pixelmetric = TQStyle::PM_SplitterWidth;
+			retswitch = 1;
+			break;
+		case QStyle::PM_TitleBarHeight:
+			tqt3pixelmetric = TQStyle::PM_TitleBarHeight;
+			retswitch = 1;
+			break;
+		case QStyle::PM_IndicatorWidth:
+			tqt3pixelmetric = TQStyle::PM_IndicatorWidth;
+			retswitch = 1;
+			break;
+		case QStyle::PM_IndicatorHeight:
+			tqt3pixelmetric = TQStyle::PM_IndicatorHeight;
+			retswitch = 1;
+			break;
+		case QStyle::PM_ExclusiveIndicatorWidth:
+			tqt3pixelmetric = TQStyle::PM_ExclusiveIndicatorWidth;
+			retswitch = 1;
+			break;
+		case QStyle::PM_ExclusiveIndicatorHeight:
+			tqt3pixelmetric = TQStyle::PM_ExclusiveIndicatorHeight;
+			retswitch = 1;
+			break;
+// 		case QStyle::PM_MenuPanelWidth:
+// 			retval = 0;
+// 			retswitch = 2;
+// 			break;
+		case QStyle::PM_MenuHMargin:
+			retval = 0;
+			retswitch = 2;
+			break;
+		case QStyle::PM_MenuVMargin:
+			retval = 0;
+			retswitch = 2;
+			break;
+// 		case QStyle::PM_MenuScrollerHeight:
+// 			tqt3pixelmetric = TQStyle::PM_MenuScrollerHeight;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_MenuTearoffHeight:
+// 			tqt3pixelmetric = TQStyle::PM_MenuTearoffHeight;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_MenuDesktopFrameWidth:
+// 			tqt3pixelmetric = TQStyle::PM_MenuDesktopFrameWidth;
+// 			retswitch = 1;
+// 			break;
+		case QStyle::PM_CheckListButtonSize:
+			tqt3pixelmetric = TQStyle::PM_CheckListButtonSize;
+			retswitch = 1;
+			break;
+		case QStyle::PM_CheckListControllerSize:
+			tqt3pixelmetric = TQStyle::PM_CheckListControllerSize;
+			retswitch = 1;
+			break;
+		case QStyle::PM_HeaderMarkSize:
+			tqt3pixelmetric = TQStyle::PM_HeaderMarkSize;
+			retswitch = 1;
+			break;
+		case QStyle::PM_HeaderGripMargin:
+			tqt3pixelmetric = TQStyle::PM_HeaderGripMargin;
+			retswitch = 1;
+			break;
+		case QStyle::PM_HeaderMargin:
+			tqt3pixelmetric = TQStyle::PM_HeaderMargin;
+			retswitch = 1;
+			break;
+// 		case QStyle::PM_SpinBoxSliderHeight:
+// 			tqt3pixelmetric = TQStyle::PM_SpinBoxSliderHeight;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ToolBarIconSize:
+// 			tqt3pixelmetric = TQStyle::PM_ToolBarIconSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_SmallIconSize:
+// 			tqt3pixelmetric = TQStyle::PM_SmallIconSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_LargeIconSize:
+// 			tqt3pixelmetric = TQStyle::PM_LargeIconSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_FocusFrameHMargin:
+// 			tqt3pixelmetric = TQStyle::PM_FocusFrameHMargin;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_FocusFrameVMargin:
+// 			tqt3pixelmetric = TQStyle::PM_FocusFrameVMargin;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_IconViewIconSize:
+// 			tqt3pixelmetric = TQStyle::PM_IconViewIconSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ListViewIconSize:
+// 			tqt3pixelmetric = TQStyle::PM_ListViewIconSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ToolTipLabelFrameWidth:
+// 			tqt3pixelmetric = TQStyle::PM_ToolTipLabelFrameWidth;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_CheckBoxLabelSpacing:
+// 			tqt3pixelmetric = TQStyle::PM_CheckBoxLabelSpacing;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_RadioButtonLabelSpacing:
+// 			tqt3pixelmetric = TQStyle::PM_RadioButtonLabelSpacing;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_TabBarIconSize:
+// 			tqt3pixelmetric = TQStyle::PM_TabBarIconSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_SizeGripSize:
+// 			tqt3pixelmetric = TQStyle::PM_SizeGripSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_MessageBoxIconSize:
+// 			tqt3pixelmetric = TQStyle::PM_MessageBoxIconSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_ButtonIconSize:
+// 			tqt3pixelmetric = TQStyle::PM_ButtonIconSize;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_TextCursorWidth:
+// 			tqt3pixelmetric = TQStyle::PM_TextCursorWidth;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_TabBar_ScrollButtonOverlap:
+// 			tqt3pixelmetric = TQStyle::PM_TabBar_ScrollButtonOverlap;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_TabCloseIndicatorWidth:
+// 			tqt3pixelmetric = TQStyle::PM_TabCloseIndicatorWidth;
+// 			retswitch = 1;
+// 			break;
+// 		case QStyle::PM_TabCloseIndicatorHeight:
+// 			tqt3pixelmetric = TQStyle::PM_TabCloseIndicatorHeight;
+// 			retswitch = 1;
+// 			break;
+		default:
+#ifdef DEBUG_WARNINGS
+			printf("No metrics for Qt4 element %d\n\r", metric); fflush(stdout);
+#endif
+			retval = 0;
+	}
+
+	if (retswitch == 1) {
+		retval = tqApp->style().pixelMetric(tqt3pixelmetric, interfaceWidget);
+	}
+	else {
+// 		if (retswitch == 2) {
+// 			// retval was already set
+// 		}
+// 		else {
+			// Tell Qt4 to get the information
+			retval = QCommonStyle::pixelMetric(metric, opt, w);
+// 		}
+	}
+
+	return retval;
+}
+
+TQWidget* SimpleStyle::initializeInterfaceWidget(TQt3WidgetType wt, const QWidget* w) const
+{
+	int i;
+	TQWidget* interfaceWidget = 0;
+
+	// Qt4 interface widget pointers
+	const QTabBar* qt4tabbar_widget = 0;
+	const QRadioButton* qt4radiobutton_widget = 0;
+	const QMenu* qt4menu_widget = 0;
+	const QProgressBar* qt4progressbar_widget = 0;
+	const QComboBox* qt4combobox_widget = 0;
+
+	TQTabBar::Shape tqt3tbshape = TQTabBar::RoundedAbove;
+
+	switch (wt) {
+		case TQT3WT_TQProgressBar:
+			interfaceWidget = m_tqt3progressbar_widget;
+			// Copy over all widget attributes
+			qt4progressbar_widget = static_cast<const QProgressBar*>(w);
+			m_tqt3progressbar_widget->setGeometry(0, 0, qt4progressbar_widget->width(), qt4progressbar_widget->height());
+			m_tqt3progressbar_widget->setProgress(qt4progressbar_widget->value()-qt4progressbar_widget->minimum(),qt4progressbar_widget->maximum()-qt4progressbar_widget->minimum());
+			if (qt4progressbar_widget->orientation() != Qt::Horizontal) {
+				// Qt3 cannot draw vertical progress bars
+#ifdef DEBUG_WARNINGS
+				printf("No rules to draw vertical Qt4 progress bar\n\r"); fflush(stdout);
+				interfaceWidget = 0;
+#endif
+			}
+			break;
+		case TQT3WT_TQTabBar:
+			interfaceWidget = m_tqt3tabbar_widget;
+			// Copy over all widget attributes
+			qt4tabbar_widget = static_cast<const QTabBar*>(w);
+			m_tqt3tabbar_widget->setGeometry(0, 0, qt4tabbar_widget->width(), qt4tabbar_widget->height());
+			// Clear out tabbar
+			for (i=0;i<m_tqt3tabbar_widget->count();i++) {
+				m_tqt3tabbar_widget->removeTab(m_tqt3tabbar_widget->tabAt(i));
+			}
+			// Copy over all tabs
+			for (i=0;i<qt4tabbar_widget->count();i++) {
+				if (qt4tabbar_widget->tabIcon(i).isNull()) {
+					TQTab* newTab = new TQTab(convertQt4ToTQt3String(qt4tabbar_widget->tabText(i)));
+					m_tqt3tabbar_widget->insertTab(newTab, i);
+					newTab->setIdentifier(i);
+				}
+				else {
+					TQTab* newTab = new TQTab(convertQt4ToTQt3IconSet(qt4tabbar_widget->tabIcon(i)), convertQt4ToTQt3String(qt4tabbar_widget->tabText(i)));
+					m_tqt3tabbar_widget->insertTab(newTab, i);
+					newTab->setIdentifier(i);
+				}
+			}
+			m_tqt3tabbar_widget->setCurrentTab(qt4tabbar_widget->currentIndex());
+			switch (qt4tabbar_widget->shape()) {
+				case QTabBar::RoundedNorth:
+					tqt3tbshape = TQTabBar::RoundedAbove;
+					break;
+				case QTabBar::RoundedSouth:
+					tqt3tbshape = TQTabBar::RoundedBelow;
+					break;
+				case QTabBar::TriangularNorth:
+					tqt3tbshape = TQTabBar::TriangularAbove;
+					break;
+				case QTabBar::TriangularSouth:
+					tqt3tbshape = TQTabBar::TriangularBelow;
+					break;
+				default:
+					// Qt3 cannot draw other tab shapes
+#ifdef DEBUG_WARNINGS
+					printf("No rules to draw Qt4 tab shape %d\n\r", qt4tabbar_widget->shape()); fflush(stdout);
+					interfaceWidget = 0;
+#endif
+			}
+			m_tqt3tabbar_widget->setShape(tqt3tbshape);
+			break;
+		case TQT3WT_TQRadioButton:
+			interfaceWidget = m_tqt3radiobutton_widget;
+			// Copy over all widget attributes
+			qt4radiobutton_widget = static_cast<const QRadioButton*>(w);
+			m_tqt3radiobutton_widget->setGeometry(0, 0, qt4radiobutton_widget->width(), qt4radiobutton_widget->height());
+			m_tqt3radiobutton_widget->setText(convertQt4ToTQt3String(qt4radiobutton_widget->text()));
+			m_tqt3radiobutton_widget->setDown(qt4radiobutton_widget->isDown());
+			break;
+		case TQT3WT_TQComboBox:
+			interfaceWidget = m_tqt3combobox_widget;
+			// Copy over all widget attributes
+			qt4combobox_widget = static_cast<const QComboBox*>(w);
+			m_tqt3combobox_widget->setGeometry(0, 0, qt4combobox_widget->width(), qt4combobox_widget->height());
+			// Clear out all combobox items
+			m_tqt3combobox_widget->clear();
+
+			for (i=0;i<qt4combobox_widget->count();i++) {
+				if (qt4combobox_widget->itemIcon(i).isNull()) {
+					m_tqt3combobox_widget->insertItem(convertQt4ToTQt3String(qt4combobox_widget->itemText(i)), i);
+				}
+				else {
+					m_tqt3combobox_widget->insertItem(convertQt4ToTQt3Pixmap(qt4combobox_widget->itemIcon(i)), convertQt4ToTQt3String(qt4combobox_widget->itemText(i)), i);
+				}
+			}
+			m_tqt3combobox_widget->setEditable(qt4combobox_widget->isEditable());
+			break;
+		case TQT3WT_TQPopupMenu:
+			interfaceWidget = m_tqt3popupmenu_widget;
+			// Copy over all widget attributes
+			qt4menu_widget = static_cast<const QMenu*>(w);
+			m_tqt3popupmenu_widget->setGeometry(0, 0, qt4menu_widget->width(), qt4menu_widget->height());
+			// Clear out menu
+			m_tqt3popupmenu_widget->clear();
+			m_tqt3popupmenu_widget->setCheckable(false);
+			// Copy over all menu items
+			QList<QAction*> qt4menuactions = qt4menu_widget->actions();
+			QAction* currentAction = 0;
+			for (i=0; i<qt4menuactions.size();++i) {
+				currentAction = qt4menuactions.at(i);
+				if (currentAction) {
+					if (currentAction->isSeparator()) {
+						m_tqt3popupmenu_widget->insertSeparator(i);
+					}
+					else {
+						if (currentAction->icon().isNull()) {
+							m_tqt3popupmenu_widget->insertItem(convertQt4ToTQt3String(currentAction->text()), i, i);
+						}
+						else {
+							m_tqt3popupmenu_widget->insertItem(convertQt4ToTQt3IconSet(currentAction->icon()), convertQt4ToTQt3String(currentAction->text()), i, i);
+						}
+						// FIXME
+						// Handle pixmaps, etc.
+					}
+					m_tqt3popupmenu_widget->setItemEnabled(i, currentAction->isEnabled());
+					m_tqt3popupmenu_widget->setItemChecked(i, currentAction->isChecked());
+					m_tqt3popupmenu_widget->setItemVisible(i, currentAction->isVisible());
+					if (currentAction->isCheckable()) {
+						m_tqt3popupmenu_widget->setCheckable(true);
+					}
+				}
+			}
+			break;
+	}
+
+	return interfaceWidget;
+}
+
+QRect SimpleStyle::subElementRect(SubElement element, const QStyleOption *opt, const QWidget *w) const
+{
+	TQStyle::SFlags sflags = 0;
+
+	bool can_override = true;
+	TQStyle::SubRect tqtSR;
+
+	TQWidget* interfaceWidget = 0;
+	QRect retRect;
+
+	switch (element) {
+		case SE_ComboBoxFocusRect:
+			tqtSR = TQStyle::SR_ComboBoxFocusRect;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQComboBox, w);
+			if (interfaceWidget == 0) {
+				can_override = false;
+			}
+			break;
+		default:
+#ifdef DEBUG_WARNINGS
+			printf("No rules to obtain Qt4 subelement rect %d\n\r", element); fflush(stdout);
+#endif
+			can_override = false;
+	}
+
+	if (can_override) {
+		// Instruct TQt3 to obtain the subelement rect information
+		retRect = convertTQt3ToQt4Rect(tqApp->style().subRect(tqtSR, interfaceWidget));
+
+#ifdef DEBUG_WARNINGS
+#ifdef DEBUG_SPEW
+		printf("Used Qt3 subelement rect %d to handle Qt4 subelement rect %d\n\r", tqtSR, control); fflush(stdout);
+#endif
+#endif
+	}
+	else {
+		// Tell Qt4 to obtain the subelement rect information
+		retRect = QCommonStyle::subElementRect(element, opt, w);
+	}
+
+	return retRect;
+}
+
+void SimpleStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *opt, QPainter *p, const QWidget *w) const
+{
+	TQStyle::SFlags sflags = 0;
+
+	bool can_override = true;
+	TQStyle::ComplexControl tqtCC;
+	TQStyle::SCFlags subControl = TQStyle::SC_All;
+	TQStyle::SCFlags subControlActive = TQStyle::SC_None;
+
+	TQWidget* interfaceWidget = 0;
+	TQStyleOption tqt3opt(TQStyleOption::Default);
+
+	// Determine the correct color group
+	sflags = convertQt4ToTQt3SFlags(opt->state, TQT3WT_NONE);
+	TQPalette tqt3palette = convertQt4ToTQt3Palette(opt->palette);
+	TQColorGroup tqt3colorgroup;
+	if (sflags & TQStyle::Style_Enabled) {
+		if (sflags & TQStyle::Style_Active) {
+			tqt3colorgroup = tqt3palette.active();
+		}
+		else {
+			tqt3colorgroup = tqt3palette.inactive();
+		}
+	}
+	else {
+		tqt3colorgroup = tqt3palette.disabled();
+	}
+
+	switch (control) {
+		case CC_ComboBox:
+			tqtCC = TQStyle::CC_ComboBox;
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQComboBox, w);
+			if (interfaceWidget == 0) {
+				can_override = false;
+			}
+			break;
+		default:
+#ifdef DEBUG_WARNINGS
+			printf("No rules to draw Qt4 complex control %d\n\r", control); fflush(stdout);
+#endif
+			can_override = false;
+	}
+
+	if (can_override) {
+		// Construct a Qt3 paint device on the Qt4 painter
+		TDEQt4PaintDevice qt4pd(p);
+
+		TQPainter tqtPainter(&qt4pd);
+
+		// Instruct TQt3 to draw the complex control
+		tqApp->style().drawComplexControl(tqtCC, &tqtPainter, interfaceWidget, TQRect(opt->rect.x(), opt->rect.y(), opt->rect.width(), opt->rect.height()), tqt3colorgroup, sflags, subControl, subControlActive, tqt3opt);
+
+		tqtPainter.end();
+
+#ifdef DEBUG_WARNINGS
+#ifdef DEBUG_SPEW
+		printf("Used Qt3 complex control %d to draw Qt4 complex control %d\n\r", tqtCE, control); fflush(stdout);
+#endif
+#endif
+	}
+	else {
+		// Tell Qt4 to draw it
+		QCommonStyle::drawComplexControl(control, opt, p, w);
+	}
+}
+
+void SimpleStyle::drawControl(ControlElement element, const QStyleOption *opt, QPainter *p, const QWidget *w) const
+{
+	int i;
+	TQStyle::SFlags sflags = 0;
+
+	bool can_override = true;
+	TQStyle::ControlElement tqtCE;
+
+	bool draw_second_element = false;
+	TQStyle::ControlElement tqtCE_element2;
+
+	bool draw_third_element = false;
+	TQStyle::ControlElement tqtCE_element3;
+
+	TQWidget* interfaceWidget = 0;
+	TQStyleOption tqt3opt(TQStyleOption::Default);
+	TQStyleOption tqt3opt_element2(TQStyleOption::Default);
+	TQStyleOption tqt3opt_element3(TQStyleOption::Default);
+
+	TQTab* drawingTab = 0;
+	int estimated_tab_index;
+
+	TQMenuItem* drawingItem = 0;
+	QAction* drawingAction = 0;
+	QList<QAction*> qt4menuactions;
+	int tqt3tabwidth = 0;
+	int tqt3iconwidth = 0;
+
+	TQRect tqt3elementrect(opt->rect.x(), opt->rect.y(), opt->rect.width(), opt->rect.height());
+	TQRect tqt3element2rect = tqt3elementrect;
+	TQRect tqt3element3rect = tqt3elementrect;
+
+	// Determine the correct color group
+	sflags = convertQt4ToTQt3SFlags(opt->state, TQT3WT_NONE);
+	TQPalette tqt3palette = convertQt4ToTQt3Palette(opt->palette);
+	TQColorGroup tqt3colorgroup;
+	if (sflags & TQStyle::Style_Enabled) {
+		if (sflags & TQStyle::Style_Active) {
+			tqt3colorgroup = tqt3palette.active();
+		}
+		else {
+			tqt3colorgroup = tqt3palette.inactive();
+		}
+	}
+	else {
+		tqt3colorgroup = tqt3palette.disabled();
+	}
+
+	switch (element) {
+		case QStyle::CE_ProgressBar:
+			// Unlike Qt3, QStyle::CE_ProgressBar draws the bar, the groove, and the label
+			tqtCE = TQStyle::CE_ProgressBarContents;
+			draw_second_element = true;
+			tqtCE_element2 = TQStyle::CE_ProgressBarGroove;
+			draw_third_element = true;
+			tqtCE_element3 = TQStyle::CE_ProgressBarLabel;
+			sflags = convertQt4ToTQt3SFlags(opt->state, TQT3WT_TQProgressBar);
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQProgressBar, w);
+			if (interfaceWidget == 0) {
+				can_override = false;
+			}
+			break;
+		case QStyle::CE_ProgressBarContents:
+			tqtCE = TQStyle::CE_ProgressBarContents;
+			sflags = convertQt4ToTQt3SFlags(opt->state, TQT3WT_TQProgressBar);
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQProgressBar, w);
+			if (interfaceWidget == 0) {
+				can_override = false;
+			}
+			break;
+		case QStyle::CE_TabBarTab:
+			// Unlike Qt3, QStyle::CE_TabBarTab draws both the tab and the label
+			tqtCE = TQStyle::CE_TabBarTab;
+			draw_second_element = true;
+			tqtCE_element2 = TQStyle::CE_TabBarLabel;
+			sflags = convertQt4ToTQt3SFlags(opt->state, TQT3WT_TQTabBar);
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQTabBar, w);
+			if (interfaceWidget == 0) {
+				can_override = false;
+			}
+			else {
+				// Convert the QStyleOption to the proper TQStyleOption
+				// In other words, figure out which TQt3 tab is currently being drawn
+				// Qt4 makes this really, really hard...
+				// I have to guess based on the Qt4 position of the tab in the tab bar, which may or may not work 100% in all cases
+				drawingTab = 0;
+				estimated_tab_index = static_cast<const QTabBar*>(w)->tabAt(QPoint(opt->rect.x(), opt->rect.y()));
+				drawingTab = m_tqt3tabbar_widget->tabAt(estimated_tab_index);
+
+				if (drawingTab) {
+					tqt3opt = TQStyleOption(drawingTab);
+					tqt3opt_element2 = TQStyleOption(drawingTab);
+				}
+
+				// HACK
+				// Qt4 is BUSTED YET AGAIN
+				// Grrrrr....
+				// The PM_TabBarTabOverlap enum is present, BUT IS NOT IMPLEMENTED, in Qt4 (!??!?)
+				// Many TDE styles use overlapping tabs, and expect to draw outside their horizontal boundaries by PM_TabBarTabOverlap pixels
+				// At the very least we need to expand the drawing rect by that amount, even if the drawing gets clipped, otherwise
+				// those styles will show badly broken tabs with missing chunks and added lines.
+				tqt3tabwidth = tqApp->style().pixelMetric(TQStyle::PM_TabBarTabOverlap, interfaceWidget);
+				if (tqt3tabwidth > 0) {
+					tqt3elementrect = TQRect(tqt3elementrect.x()-tqt3tabwidth, tqt3elementrect.y(), tqt3elementrect.width()+(tqt3tabwidth*1), tqt3elementrect.height());
+				}
+			}
+			break;
+#if 0
+		case CE_RadioButton:
+			// Unlike Qt3, QStyle::CE_RadioButton draws the button, the label, and the focus rectangle
+			tqtCE = TQStyle::CE_RadioButton;
+			draw_second_element = true;
+			tqtCE_element2 = TQStyle::CE_RadioButtonLabel;
+			sflags = convertQt4ToTQt3SFlags(opt->state, TQT3WT_TQRadioButton);
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQRadioButton, w);
+			if (interfaceWidget == 0) {
+				can_override = false;
+			}
+			break;
+#endif
+		case CE_MenuItem:
+			tqtCE = TQStyle::CE_PopupMenuItem;
+			sflags = convertQt4ToTQt3SFlags(opt->state, TQT3WT_TQPopupMenu);
+			interfaceWidget = initializeInterfaceWidget(TQT3WT_TQPopupMenu, w);
+			if (interfaceWidget == 0) {
+				can_override = false;
+			}
+			else {
+				// Convert the QStyleOption to the proper TQStyleOption
+				// In other words, figure out which TQt3 menu item is currently being drawn
+				// Qt4 makes this really, really hard...
+				// I have to guess based on the Qt4 position of the item in the menu, which may or may not work 100% in all cases
+				drawingItem = 0;
+				drawingAction = static_cast<const QMenu*>(w)->actionAt(QPoint(opt->rect.x(), opt->rect.y()));
+				qt4menuactions = static_cast<const QMenu*>(w)->actions();
+				for (i=0; i<qt4menuactions.size();++i) {
+					if (qt4menuactions.at(i) == drawingAction) {
+						drawingItem = m_tqt3popupmenu_widget->findItem(m_tqt3popupmenu_widget->idAt(i));
+					}
+				}
+
+				if (drawingItem) {
+					tqt3tabwidth = static_cast<const QStyleOptionMenuItem*>(opt)->tabWidth;
+					tqt3iconwidth = static_cast<const QStyleOptionMenuItem*>(opt)->maxIconWidth;
+					tqt3opt = TQStyleOption(drawingItem, tqt3iconwidth, tqt3tabwidth);
+				}
+			}
+			break;
+		case QStyle::CE_TabBarTabShape:
+			// Ignore request as Qt3 has no equivalent
+			can_override = false;
+			break;
+		default:
+#ifdef DEBUG_WARNINGS
+			printf("No rules to draw Qt4 control %d\n\r", element); fflush(stdout);
+#endif
+			can_override = false;
+	}
+
+	if (can_override) {
+		// Construct a Qt3 paint device on the Qt4 painter
+		TDEQt4PaintDevice qt4pd(p);
+
+		TQPainter tqtPainter(&qt4pd);
+
+		// Instruct TQt3 to draw the control
+		// FIXME
+		// Implement sflags and QStyleOption
+		tqApp->style().drawControl(tqtCE, &tqtPainter, interfaceWidget, tqt3elementrect, tqt3colorgroup, sflags, tqt3opt);
+		if (draw_second_element == true) {
+			tqApp->style().drawControl(tqtCE_element2, &tqtPainter, interfaceWidget, tqt3element2rect, tqt3colorgroup, sflags, tqt3opt_element2);
+		}
+		if (draw_third_element == true) {
+			tqApp->style().drawControl(tqtCE_element3, &tqtPainter, interfaceWidget, tqt3element3rect, tqt3colorgroup, sflags, tqt3opt_element3);
+		}
+
+		tqtPainter.end();
+
+#ifdef DEBUG_WARNINGS
+#ifdef DEBUG_SPEW
+		printf("Used Qt3 control %d to draw Qt4 control %d\n\r", tqtCE, element); fflush(stdout);
+#endif
+#endif
+	}
+	else {
+		// Tell Qt4 to draw it
+		QCommonStyle::drawControl(element, opt, p, w);
+	}
+}
+
+#define NO_QT3_EQUIVALENT can_override = false;
+
+void SimpleStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w) const
+{
+	// Construct a Qt3 paint device translator on the Qt4 painter
+	TDEQt4PaintDevice qt4pd(p);
+
+	// Open a painter on the paint device translator
+	TQPainter tqtPainter(&qt4pd);
+
+	bool can_override = true;
+	TQStyle::PrimitiveElement tqtPE;
+	TQStyleOption tqt3opt(TQStyleOption::Default);
+
+	// NOTE: Qt3 seems to combine PE_FrameMenu and PE_PanelMenu into PE_PanelPopup
+
+	switch (pe) {
+		case QStyle::PE_Frame:
+			tqtPE = TQStyle::PE_Panel;
+			tqt3opt = TQStyleOption(static_cast<const QStyleOptionFrame*>(opt)->lineWidth, static_cast<const QStyleOptionFrame*>(opt)->midLineWidth);
+			break;
+		case QStyle::PE_FrameMenu:
+			tqtPE = TQStyle::PE_PanelPopup;
+			tqt3opt = TQStyleOption(static_cast<const QStyleOptionFrame*>(opt)->lineWidth, static_cast<const QStyleOptionFrame*>(opt)->midLineWidth);
+			break;
+		case QStyle::PE_PanelButtonBevel:
+			tqtPE = TQStyle::PE_ButtonBevel;
+			break;
+		case QStyle::PE_FrameGroupBox:
+			tqtPE = TQStyle::PE_GroupBoxFrame;
+			tqt3opt = TQStyleOption(static_cast<const QStyleOptionFrame*>(opt)->lineWidth, static_cast<const QStyleOptionFrame*>(opt)->midLineWidth);
+			break;
+		case QStyle::PE_FrameFocusRect:
+			tqtPE = TQStyle::PE_FocusRect;
+			break;
+		case QStyle::PE_FrameButtonTool:
+			tqtPE = TQStyle::PE_ButtonTool;
+			break;
+		case QStyle::PE_FrameTabBarBase:
+			NO_QT3_EQUIVALENT
+			break;
+		case QStyle::PE_FrameTabWidget:
+			tqtPE = TQStyle::PE_PanelTabWidget;
+			break;
+		case QStyle::PE_PanelButtonCommand:
+			tqtPE = TQStyle::PE_ButtonCommand;
+			break;
+		case QStyle::PE_IndicatorProgressChunk:
+			tqtPE = TQStyle::PE_ProgressBarChunk;
+			break;
+		case QStyle::PE_IndicatorArrowDown:
+			tqtPE = TQStyle::PE_ArrowDown;
+			break;
+		case QStyle::PE_IndicatorArrowLeft:
+			tqtPE = TQStyle::PE_ArrowLeft;
+			break;
+		case QStyle::PE_IndicatorArrowRight:
+			tqtPE = TQStyle::PE_ArrowRight;
+			break;
+		case QStyle::PE_IndicatorArrowUp:
+			tqtPE = TQStyle::PE_ArrowUp;
+			break;
+		case QStyle::PE_IndicatorCheckBox:
+			tqtPE = TQStyle::PE_Indicator;
+			break;
+		case QStyle::PE_IndicatorRadioButton:
+			tqtPE = TQStyle::PE_ExclusiveIndicator;
+			break;
+		case QStyle::PE_PanelMenu:
+			tqtPE = TQStyle::PE_PanelPopup;
+			break;
+		case QStyle::PE_PanelButtonTool:
+			tqtPE = TQStyle::PE_ButtonTool;
+			break;
+		case QStyle::PE_IndicatorTabTear:
+			NO_QT3_EQUIVALENT
+			break;
+		default:
+#ifdef DEBUG_WARNINGS
+			printf("No rules to draw Qt4 element %d\n\r", pe); fflush(stdout);
+#endif
+			can_override = false;
+	}
+
+	// Convert the style flags
+	TQStyle::SFlags sflags = convertQt4ToTQt3SFlags(opt->state, TQT3WT_NONE);
+
+	// Determine the correct color group
+	TQPalette tqt3palette = convertQt4ToTQt3Palette(opt->palette);
+	TQColorGroup tqt3colorgroup;
+	if (sflags & TQStyle::Style_Enabled) {
+		if (sflags & TQStyle::Style_Active) {
+			tqt3colorgroup = tqt3palette.active();
+		}
+		else {
+			tqt3colorgroup = tqt3palette.inactive();
+		}
+	}
+	else {
+		tqt3colorgroup = tqt3palette.disabled();
+	}
+
+
+	if (can_override) {
+		// Construct a Qt3 paint device on the Qt4 painter
+		TDEQt4PaintDevice qt4pd(p);
+
+		TQPainter tqtPainter(&qt4pd);
+
+		// Instruct TQt3 to draw the primitive
+		tqApp->style().drawPrimitive(tqtPE, &tqtPainter, TQRect(opt->rect.x(), opt->rect.y(), opt->rect.width(), opt->rect.height()), tqt3colorgroup, sflags, tqt3opt);
+		tqtPainter.end();
+
+#ifdef DEBUG_WARNINGS
+#ifdef DEBUG_SPEW
+		printf("Used Qt3 element %d to draw Qt4 element %d\n\r", tqtPE, pe); fflush(stdout);
+#endif
+#endif
+	}
+	else {
+		// Tell Qt4 to draw it
+		QCommonStyle::drawPrimitive(pe, opt, p, w);
+	}
+}