Trinity Qt initial conversion

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebindings@1157645 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

3 files changed, 384 insertions, 384 deletions

diff --git a/qtruby/rubylib/qtruby/Qt.cpp b/qtruby/rubylib/qtruby/Qt.cpp
index 342863e6..37cfd637 100644
--- a/qtruby/rubylib/qtruby/Qt.cpp
+++ b/qtruby/rubylib/qtruby/Qt.cpp
@@ -21,19 +21,19 @@
 #include <stdio.h>
 #include <stdarg.h>
 
-#include <qglobal.h>
-#include <qregexp.h>
-#include <qstring.h>
-#include <qptrdict.h>
-#include <qintdict.h>
-#include <qapplication.h>
-#include <qmetaobject.h>
+#include <tqglobal.h>
+#include <tqregexp.h>
+#include <tqstring.h>
+#include <tqptrdict.h>
+#include <tqintdict.h>
+#include <tqapplication.h>
+#include <tqmetaobject.h>
 #include <private/qucomextra_p.h>
-#include <qvariant.h>
-#include <qcursor.h>
-#include <qobjectlist.h>
-#include <qsignalslotimp.h>
-#include <qcstring.h>
+#include <tqvariant.h>
+#include <tqcursor.h>
+#include <tqobjectlist.h>
+#include <tqsignalslotimp.h>
+#include <tqcstring.h>
 
 #undef DEBUG
 #ifndef __USE_POSIX
@@ -76,13 +76,13 @@ int do_debug = qtdb_gc;
 int do_debug = qtdb_none;
 #endif
 
-QPtrDict<VALUE> pointer_map(2179);
+TQPtrDict<VALUE> pointer_map(2179);
 int object_count = 0;
 
-QAsciiDict<Smoke::Index> methcache(2179);
-QAsciiDict<Smoke::Index> classcache(2179);
+TQAsciiDict<Smoke::Index> methcache(2179);
+TQAsciiDict<Smoke::Index> classcache(2179);
 // Maps from a classname in the form Qt::Widget to an int id
-QIntDict<char> classname(2179);
+TQIntDict<char> classname(2179);
 
 extern "C" {
 VALUE qt_module = Qnil;
@@ -138,7 +138,7 @@ void *value_to_ptr(VALUE ruby_value) {  // ptr on success, null on fail
 VALUE getPointerObject(void *ptr);
 
 bool isQObject(Smoke *smoke, Smoke::Index classId) {
-    if(qstrcmp(smoke->classes[classId].className, "QObject") == 0)
+    if(qstrcmp(smoke->classes[classId].className, "TQObject") == 0)
 	return true;
     for(Smoke::Index *p = smoke->inheritanceList + smoke->classes[classId].parents;
 	*p;
@@ -431,7 +431,7 @@ public:
 	if(_called) return;
 	_called = true;
 		
-	QString className(_smoke->className(method().classId));
+	TQString className(_smoke->className(method().classId));
 	
 	if (	! className.endsWith(_smoke->methodNames[method().name])
 			&& TYPE(_target) != T_DATA 
@@ -471,10 +471,10 @@ public:
     }
 };
 
-class UnencapsulatedQObject : public QObject {
+class UnencapsulatedQObject : public TQObject {
 public:
-    QConnectionList *public_receivers(int signal) const { return receivers(signal); }
-    void public_activate_signal(QConnectionList *clist, QUObject *o) { activate_signal(clist, o); }
+    TQConnectionList *public_receivers(int signal) const { return receivers(signal); }
+    void public_activate_signal(TQConnectionList *clist, QUObject *o) { activate_signal(clist, o); }
 };
 
 class EmitSignal : public Marshall {
@@ -487,7 +487,7 @@ class EmitSignal : public Marshall {
     Smoke::Stack _stack;
     bool _called;
 public:
-    EmitSignal(QObject *qobj, int id, int items, VALUE args, VALUE *sp) :
+    EmitSignal(TQObject *qobj, int id, int items, VALUE args, VALUE *sp) :
     _qobj((UnencapsulatedQObject*)qobj), _id(id), _sp(sp), _items(items),
     _cur(-1), _called(false)
     {
@@ -511,7 +511,7 @@ public:
 	if(_called) return;
 	_called = true;
 
-	QConnectionList *clist = _qobj->public_receivers(_id);
+	TQConnectionList *clist = _qobj->public_receivers(_id);
 	if(!clist) return;
 
 	QUObject *o = new QUObject[_items + 1];
@@ -532,7 +532,7 @@ public:
 		static_QUType_charstar.set(po, (char*)si->s_voidp);
 		break;
 	      case xmoc_QString:
-		static_QUType_QString.set(po, *(QString*)si->s_voidp);
+		static_QUType_QString.set(po, *(TQString*)si->s_voidp);
 		break;
 	      default:
 		{
@@ -778,7 +778,7 @@ public:
 
 	if (do_debug & qtdb_virtual) {
 		Smoke::Method & meth = smoke->methods[method];
-		QCString signature(smoke->methodNames[meth.name]);
+		TQCString signature(smoke->methodNames[meth.name]);
 		signature += "(";
 
 		for (int i = 0; i < meth.numArgs; i++) {
@@ -876,19 +876,19 @@ set_obj_info(const char * className, smokeruby_object * o)
 		o->classId = (int)*r;
 	}
 
-	// If the instance is a subclass of QObject, then check to see if the
-	// className from its QMetaObject is in the Smoke library. If not then
+	// If the instance is a subclass of TQObject, then check to see if the
+	// className from its TQMetaObject is in the Smoke library. If not then
 	// create a Ruby class for it dynamically. Remove the first letter from 
 	// any class names beginning with 'Q' or 'K' and put them under the Qt:: 
 	// or KDE:: modules respectively.
-	if (isDerivedFrom(o->smoke, o->classId, o->smoke->idClass("QObject"))) {
-		QObject * qobject = (QObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QObject"));
-		QMetaObject * meta = qobject->metaObject();
+	if (isDerivedFrom(o->smoke, o->classId, o->smoke->idClass("TQObject"))) {
+		TQObject * qobject = (TQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
+		TQMetaObject * meta = qobject->metaObject();
 		int classId = o->smoke->idClass(meta->className());
 		// The class isn't in the Smoke lib..
 		if (classId == 0) {
 			VALUE new_klass = Qnil;
-			QString className(meta->className());
+			TQString className(meta->className());
 			// The konsolePart class is in kdebase, and so it can't be in the Smoke library.
 			// This hack instantiates a Ruby KDE::KonsolePart instance
 			if (className == "konsolePart") {
@@ -908,7 +908,7 @@ set_obj_info(const char * className, smokeruby_object * o)
 			}
 
 			// Add a Qt::Object.metaObject method which will do dynamic despatch on the
-			// metaObject() virtual method so that the true QMetaObject of the class 
+			// metaObject() virtual method so that the true TQMetaObject of the class 
 			// is returned, rather than for the one for the parent class that is in
 			// the Smoke library.
 			rb_define_method(klass, "metaObject", (VALUE (*) (...)) qobject_metaobject, 0);
@@ -1012,24 +1012,24 @@ receivers_qobject(VALUE self)
 		
 	smokeruby_object * o = 0;
     Data_Get_Struct(self, smokeruby_object, o);	
-	UnencapsulatedQObject * qobject = (UnencapsulatedQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QObject"));
+	UnencapsulatedQObject * qobject = (UnencapsulatedQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
 	VALUE result = rb_hash_new();
-	QStrList signalNames = qobject->metaObject()->signalNames(true);
+	TQStrList signalNames = qobject->metaObject()->signalNames(true);
 	
 	for (int sig = 0; sig < qobject->metaObject()->numSignals(true); sig++) {
-		QConnectionList * clist = qobject->public_receivers(sig);
+		TQConnectionList * clist = qobject->public_receivers(sig);
 		if (clist != 0) {
 			VALUE name = rb_str_new2(signalNames.at(sig));
 			VALUE members = rb_ary_new();
 			
-			for (	QConnection * connection = clist->first(); 
+			for (	TQConnection * connection = clist->first(); 
 					connection != 0; 
 					connection = clist->next() ) 
 			{
 				VALUE obj = getPointerObject(connection);
 				if (obj == Qnil) {
 					smokeruby_object * c = ALLOC(smokeruby_object);
-					c->classId = o->smoke->idClass("QConnection");
+					c->classId = o->smoke->idClass("TQConnection");
 					c->smoke = o->smoke;
 					c->ptr = connection;
 					c->allocated = false;
@@ -1046,36 +1046,36 @@ receivers_qobject(VALUE self)
 	return result;
 }
 
-// Takes a variable name and a QProperty with QVariant value, and returns a '
+// Takes a variable name and a QProperty with TQVariant value, and returns a '
 // variable=value' pair with the value in ruby inspect style
 static QCString
-inspectProperty(Smoke * smoke, const QMetaProperty * property, const char * name, QVariant & value)
+inspectProperty(Smoke * smoke, const TQMetaProperty * property, const char * name, TQVariant & value)
 {
 	if (property->isEnumType()) {
-		QMetaObject * metaObject = *(property->meta);
-		return QCString().sprintf(	" %s=%s::%s",
+		TQMetaObject * metaObject = *(property->meta);
+		return TQCString().sprintf(	" %s=%s::%s",
 									name,
 									smoke->binding->className(smoke->idClass(metaObject->className())), 
 									property->valueToKey(value.toInt()) );
 	}
 	
 	switch (value.type()) {
-	case QVariant::String:
-	case QVariant::CString:
+	case TQVariant::String:
+	case TQVariant::CString:
 	{
 		if (value.toString().isNull()) {
-			return QCString().sprintf(" %s=nil", name); 
+			return TQCString().sprintf(" %s=nil", name); 
 		} else {
-			return QCString().sprintf(	" %s=\"%s\"", 
+			return TQCString().sprintf(	" %s=\"%s\"", 
 										name, 
 										value.toString().latin1() );
 		}
 	}
 		
-	case QVariant::Bool:
+	case TQVariant::Bool:
 	{
-		QString rubyName;
-		QRegExp name_re("^(is|has)(.)(.*)");
+		TQString rubyName;
+		TQRegExp name_re("^(is|has)(.)(.*)");
 		
 		if (name_re.search(name) != -1) {
 			rubyName = name_re.cap(2).lower() + name_re.cap(3) + "?";
@@ -1083,86 +1083,86 @@ inspectProperty(Smoke * smoke, const QMetaProperty * property, const char * name
 			rubyName = name;
 		}
 		
-		return QCString().sprintf(" %s=%s", rubyName.latin1(), value.toString().latin1());
+		return TQCString().sprintf(" %s=%s", rubyName.latin1(), value.toString().latin1());
 	}
 			
-	case QVariant::Color:
+	case TQVariant::Color:
 	{
-		QColor c = value.toColor();
-		return QCString().sprintf(" %s=#<Qt::Color:0x0 %s>", name, c.name().latin1());
+		TQColor c = value.toColor();
+		return TQCString().sprintf(" %s=#<Qt::Color:0x0 %s>", name, c.name().latin1());
 	}
 			
-	case QVariant::Cursor:
+	case TQVariant::Cursor:
 	{
-		QCursor c = value.toCursor();
-		return QCString().sprintf(" %s=#<Qt::Cursor:0x0 shape=%d>", name, c.shape());
+		TQCursor c = value.toCursor();
+		return TQCString().sprintf(" %s=#<Qt::Cursor:0x0 shape=%d>", name, c.shape());
 	}
 	
-	case QVariant::Double:
+	case TQVariant::Double:
 	{
-		return QCString().sprintf(" %s=%.4f", name, value.toDouble());
+		return TQCString().sprintf(" %s=%.4f", name, value.toDouble());
 	}
 	
-	case QVariant::Font:
+	case TQVariant::Font:
 	{
-		QFont f = value.toFont();
-		return QCString().sprintf(	" %s=#<Qt::Font:0x0 family=%s, pointSize=%d, weight=%d, italic=%s, bold=%s, underline=%s, strikeOut=%s>", 
+		TQFont f = value.toFont();
+		return TQCString().sprintf(	" %s=#<Qt::Font:0x0 family=%s, pointSize=%d, weight=%d, italic=%s, bold=%s, underline=%s, strikeOut=%s>", 
 									name, 
 									f.family().latin1(), f.pointSize(), f.weight(), 
 									f.italic() ? "true" : "false", f.bold() ? "true" : "false",
 									f.underline() ? "true" : "false", f.strikeOut() ? "true" : "false" );
 	}
 	
-	case QVariant::Point:
+	case TQVariant::Point:
 	{
-		QPoint p = value.toPoint();
-		return QCString().sprintf(	" %s=#<Qt::Point:0x0 x=%d, y=%d>", 
+		TQPoint p = value.toPoint();
+		return TQCString().sprintf(	" %s=#<Qt::Point:0x0 x=%d, y=%d>", 
 									name, 
 									p.x(), p.y() );
 	}
 	
-	case QVariant::Rect:
+	case TQVariant::Rect:
 	{
-		QRect r = value.toRect();
-		return QCString().sprintf(	" %s=#<Qt::Rect:0x0 left=%d, right=%d, top=%d, bottom=%d>", 
+		TQRect r = value.toRect();
+		return TQCString().sprintf(	" %s=#<Qt::Rect:0x0 left=%d, right=%d, top=%d, bottom=%d>", 
 									name, 
 									r.left(), r.right(), r.top(), r.bottom() );
 	}
 	
-	case QVariant::Size:
+	case TQVariant::Size:
 	{
-		QSize s = value.toSize();
-		return QCString().sprintf(	" %s=#<Qt::Size:0x0 width=%d, height=%d>", 
+		TQSize s = value.toSize();
+		return TQCString().sprintf(	" %s=#<Qt::Size:0x0 width=%d, height=%d>", 
 									name, 
 									s.width(), s.height() );
 	}
 	
-	case QVariant::SizePolicy:
+	case TQVariant::SizePolicy:
 	{
-		QSizePolicy s = value.toSizePolicy();
-		return QCString().sprintf(	" %s=#<Qt::SizePolicy:0x0 horData=%d, verData=%d>", 
+		TQSizePolicy s = value.toSizePolicy();
+		return TQCString().sprintf(	" %s=#<Qt::SizePolicy:0x0 horData=%d, verData=%d>", 
 									name, 
 									s.horData(), s.verData() );
 	}
 	
-	case QVariant::Brush:
-	case QVariant::ColorGroup:
-	case QVariant::Image:
-	case QVariant::Palette:
-	case QVariant::Pixmap:
-	case QVariant::Region:
+	case TQVariant::Brush:
+	case TQVariant::ColorGroup:
+	case TQVariant::Image:
+	case TQVariant::Palette:
+	case TQVariant::Pixmap:
+	case TQVariant::Region:
 	{
-		return QCString().sprintf(" %s=#<Qt::%s:0x0>", name, value.typeName() + 1);
+		return TQCString().sprintf(" %s=#<Qt::%s:0x0>", name, value.typeName() + 1);
 	}
 	
 	default:
-		return QCString().sprintf(	" %s=%s", 
+		return TQCString().sprintf(	" %s=%s", 
 									name, 
 									(value.isNull() || value.toString().isNull()) ? "nil" : value.toString().latin1() );
 	}
 }
 
-// Retrieves the properties for a QObject and returns them as 'name=value' pairs
+// Retrieves the properties for a TQObject and returns them as 'name=value' pairs
 // in a ruby inspect string. For example:
 //
 //		#<Qt::HBoxLayout:0x30139030 name=unnamed, margin=0, spacing=0, resizeMode=3>
@@ -1181,14 +1181,14 @@ inspect_qobject(VALUE self)
 	
 	smokeruby_object * o = 0;
     Data_Get_Struct(self, smokeruby_object, o);	
-	QObject * qobject = (QObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QObject"));
+	TQObject * qobject = (TQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
 	
-	QCString value_list;
-	value_list.append(QCString().sprintf(" name=\"%s\"", qobject->name()));
+	TQCString value_list;
+	value_list.append(TQCString().sprintf(" name=\"%s\"", qobject->name()));
 	
 	if (qobject->isWidgetType()) {
-		QWidget * w = (QWidget *) qobject;
-		value_list.append(QCString().sprintf(	", x=%d, y=%d, width=%d, height=%d", 
+		TQWidget * w = (TQWidget *) qobject;
+		value_list.append(TQCString().sprintf(	", x=%d, y=%d, width=%d, height=%d", 
 												w->x(),
 												w->y(),
 												w->width(),
@@ -1201,7 +1201,7 @@ inspect_qobject(VALUE self)
 	return inspect_str;
 }
 
-// Retrieves the properties for a QObject and pretty_prints them as 'name=value' pairs
+// Retrieves the properties for a TQObject and pretty_prints them as 'name=value' pairs
 // For example:
 //
 //		#<Qt::HBoxLayout:0x30139030
@@ -1226,13 +1226,13 @@ pretty_print_qobject(VALUE self, VALUE pp)
 	
 	smokeruby_object * o = 0;
     Data_Get_Struct(self, smokeruby_object, o);	
-	UnencapsulatedQObject * qobject = (UnencapsulatedQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QObject"));
-	QStrList names = qobject->metaObject()->propertyNames(true);
+	UnencapsulatedQObject * qobject = (UnencapsulatedQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
+	TQStrList names = qobject->metaObject()->propertyNames(true);
 	
-	QCString value_list;		
+	TQCString value_list;		
 	
 	if (qobject->parent() != 0) {
-		QCString parentInspectString;
+		TQCString parentInspectString;
 		VALUE obj = getPointerObject(qobject->parent());
 		if (obj != Qnil) {
 			VALUE parent_inspect_str = rb_funcall(obj, rb_intern("to_s"), 0, 0);	
@@ -1243,8 +1243,8 @@ pretty_print_qobject(VALUE self, VALUE pp)
 		}
 		
 		if (qobject->parent()->isWidgetType()) {
-			QWidget * w = (QWidget *) qobject->parent();
-			value_list = QCString().sprintf(	"  parent=%s name=\"%s\", x=%d, y=%d, width=%d, height=%d>,\n", 
+			TQWidget * w = (TQWidget *) qobject->parent();
+			value_list = TQCString().sprintf(	"  parent=%s name=\"%s\", x=%d, y=%d, width=%d, height=%d>,\n", 
 												parentInspectString.data(),
 												w->name(),
 												w->x(),
@@ -1252,7 +1252,7 @@ pretty_print_qobject(VALUE self, VALUE pp)
 												w->width(),
 												w->height() );
 		} else {
-			value_list = QCString().sprintf(	"  parent=%s name=\"%s\">,\n", 
+			value_list = TQCString().sprintf(	"  parent=%s name=\"%s\">,\n", 
 												parentInspectString.data(),
 												qobject->parent()->name() );
 		}
@@ -1261,23 +1261,23 @@ pretty_print_qobject(VALUE self, VALUE pp)
 	}
 	
 	if (qobject->children() != 0) {
-		value_list = QCString().sprintf("  children=Array (%d element(s)),\n", qobject->children()->count());
+		value_list = TQCString().sprintf("  children=Array (%d element(s)),\n", qobject->children()->count());
 		rb_funcall(pp, rb_intern("text"), 1, rb_str_new2(value_list.data()));
 	}
 	
-	value_list = QCString("  metaObject=#<Qt::MetaObject:0x0");
-	value_list.append(QCString().sprintf(" className=%s", qobject->metaObject()->className()));
+	value_list = TQCString("  metaObject=#<Qt::MetaObject:0x0");
+	value_list.append(TQCString().sprintf(" className=%s", qobject->metaObject()->className()));
 	
 	if (qobject->metaObject()->superClass() != 0) {
-		value_list.append(QCString().sprintf(", superClass=#<Qt::MetaObject:0x0>", qobject->metaObject()->superClass()));
+		value_list.append(TQCString().sprintf(", superClass=#<Qt::MetaObject:0x0>", qobject->metaObject()->superClass()));
 	}		
 	
 	if (qobject->metaObject()->numSignals() > 0) {
-		value_list.append(QCString().sprintf(", signalNames=Array (%d element(s))", qobject->metaObject()->numSignals()));
+		value_list.append(TQCString().sprintf(", signalNames=Array (%d element(s))", qobject->metaObject()->numSignals()));
 	}		
 	
 	if (qobject->metaObject()->numSlots() > 0) {
-		value_list.append(QCString().sprintf(", slotNames=Array (%d element(s))", qobject->metaObject()->numSlots()));
+		value_list.append(TQCString().sprintf(", slotNames=Array (%d element(s))", qobject->metaObject()->numSlots()));
 	}
 	
 	value_list.append(">,\n");
@@ -1285,14 +1285,14 @@ pretty_print_qobject(VALUE self, VALUE pp)
 				
 	int signalCount = 0;
 	for (int sig = 0; sig < qobject->metaObject()->numSignals(true); sig++) {
-		QConnectionList * clist = qobject->public_receivers(sig);
+		TQConnectionList * clist = qobject->public_receivers(sig);
 		if (clist != 0) {
 			signalCount++;
 		}
 	}
 	
 	if (signalCount > 0) {
-		value_list = QCString().sprintf(" receivers=Hash (%d element(s)),\n", signalCount);
+		value_list = TQCString().sprintf(" receivers=Hash (%d element(s)),\n", signalCount);
 		rb_funcall(pp, rb_intern("text"), 1, rb_str_new2(value_list.data()));
 	}		
 	
@@ -1300,8 +1300,8 @@ pretty_print_qobject(VALUE self, VALUE pp)
 	const char * name = names.first();
 	
 	if (name != 0) {
-		QVariant value = qobject->property(name);
-		const QMetaProperty * property = qobject->metaObject()->property(index, true);
+		TQVariant value = qobject->property(name);
+		const TQMetaProperty * property = qobject->metaObject()->property(index, true);
 		value_list = " " + inspectProperty(o->smoke, property, name, value);
 		rb_funcall(pp, rb_intern("text"), 1, rb_str_new2(value_list.data()));
 		index++;
@@ -1335,8 +1335,8 @@ static VALUE
 qobject_metaobject(VALUE self)
 {
 	smokeruby_object * o = value_obj_info(self);
-	QObject * qobject = (QObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QObject"));
-	QMetaObject * meta = qobject->metaObject();
+	TQObject * qobject = (TQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
+	TQMetaObject * meta = qobject->metaObject();
 	VALUE obj = getPointerObject(meta);
 	if (obj != Qnil) {
 		return obj;
@@ -1344,7 +1344,7 @@ qobject_metaobject(VALUE self)
 
 	smokeruby_object  * m = (smokeruby_object *) malloc(sizeof(smokeruby_object));
 	m->smoke = o->smoke;
-	m->classId = m->smoke->idClass("QMetaObject");
+	m->classId = m->smoke->idClass("TQMetaObject");
 	m->ptr = meta;
 	m->allocated = false;
 	obj = set_obj_info("Qt::MetaObject", m);
@@ -1359,15 +1359,15 @@ static Smoke::Index new_qvariant_qmap = 0;
 
 	if (new_qvariant_qlist == 0) {
 		Smoke::Index nameId = qt_Smoke->idMethodName("QVariant?");
-		Smoke::Index meth = qt_Smoke->findMethod(qt_Smoke->idClass("QVariant"), nameId);
+		Smoke::Index meth = qt_Smoke->findMethod(qt_Smoke->idClass("TQVariant"), nameId);
 		Smoke::Index i = qt_Smoke->methodMaps[meth].method;
 		i = -i;		// turn into ambiguousMethodList index
 		while (qt_Smoke->ambiguousMethodList[i] != 0) {
 			const char * argType = qt_Smoke->types[qt_Smoke->argumentList[qt_Smoke->methods[qt_Smoke->ambiguousMethodList[i]].args]].name;
 
-			if (qstrcmp(argType, "const QValueList<QVariant>&" ) == 0) {
+			if (qstrcmp(argType, "const TQValueList<TQVariant>&" ) == 0) {
 				new_qvariant_qlist = qt_Smoke->ambiguousMethodList[i];
-			} else if (qstrcmp(argType, "const QMap<QString,QVariant>&" ) == 0) {
+			} else if (qstrcmp(argType, "const TQMap<TQString,TQVariant>&" ) == 0) {
 				new_qvariant_qmap = qt_Smoke->ambiguousMethodList[i];
 			}
 
@@ -1394,13 +1394,13 @@ static Smoke::Index new_qvariant_qmap = 0;
 	return rb_call_super(argc, argv);
 }
 
-static QCString *
+static TQCString *
 find_cached_selector(int argc, VALUE * argv, VALUE klass, const char * methodName)
 {
     // Look in the cache
-static QCString * mcid = 0;
+static TQCString * mcid = 0;
 	if (mcid == 0) {
-		mcid = new QCString();
+		mcid = new TQCString();
 	}
 	*mcid = rb_class2name(klass);
 	*mcid += ';';
@@ -1436,9 +1436,9 @@ method_missing(int argc, VALUE * argv, VALUE self)
     VALUE klass = rb_funcall(self, rb_intern("class"), 0);
 
 	// Look for 'thing?' methods, and try to match isThing() or hasThing() in the Smoke runtime
-static QString * pred = 0;
+static TQString * pred = 0;
 	if (pred == 0) {
-		pred = new QString();
+		pred = new TQString();
 	}
 	
 	*pred = methodName;
@@ -1452,11 +1452,11 @@ static QString * pred = 0;
 		pred->replace(pred->length() - 1, 1, "");
 		
 		pred->replace(0, 1, pred->at(0).upper());
-		pred->replace(0, 0, QString("is"));
+		pred->replace(0, 0, TQString("is"));
 		Smoke::Index meth = o->smoke->findMethod(o->smoke->classes[o->classId].className, pred->latin1());
 		
 		if (meth == 0) {
-			pred->replace(0, 2, QString("has"));
+			pred->replace(0, 2, TQString("has"));
 			meth = o->smoke->findMethod(o->smoke->classes[o->classId].className, pred->latin1());
 		}
 		
@@ -1475,7 +1475,7 @@ static QString * pred = 0;
     }
 
 	{
-		QCString * mcid = find_cached_selector(argc+3, temp_stack, klass, methodName);
+		TQCString * mcid = find_cached_selector(argc+3, temp_stack, klass, methodName);
 
 		if (_current_method == -1) {
 			// Find the C++ method to call. Do that from Ruby for now
@@ -1505,22 +1505,22 @@ static QString * pred = 0;
 					smokeruby_object *o = value_obj_info(self);
 					if (	o != 0 
 							&& o->ptr != 0 
-							&& isDerivedFrom(o->smoke, o->classId, o->smoke->idClass("QObject")) )
+							&& isDerivedFrom(o->smoke, o->classId, o->smoke->idClass("TQObject")) )
 					{
-						QObject * qobject = (QObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QObject"));
-static QString * prop = 0;
+						TQObject * qobject = (TQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
+static TQString * prop = 0;
 						if (prop == 0) {
-							prop = new QString();
+							prop = new TQString();
 						}
 						
 						*prop = rb_id2name(SYM2ID(argv[0]));
-						QMetaObject * meta = qobject->metaObject();
+						TQMetaObject * meta = qobject->metaObject();
 						if (argc == 1) {
 							if (prop->endsWith("?")) {
 								prop->replace(0, 1, pred->at(0).upper());
-								prop->replace(0, 0, QString("is"));
+								prop->replace(0, 0, TQString("is"));
 								if (meta->findProperty(prop->latin1(), true) == -1) {
-									prop->replace(0, 2, QString("has"));
+									prop->replace(0, 2, TQString("has"));
 								}
 							}
 
@@ -1568,7 +1568,7 @@ class_method_missing(int argc, VALUE * argv, VALUE klass)
     }
 
     {
-		QCString * mcid = find_cached_selector(argc+3, temp_stack, klass, methodName);
+		TQCString * mcid = find_cached_selector(argc+3, temp_stack, klass, methodName);
 
 		if (_current_method == -1) {
 			VALUE retval = rb_funcall2(qt_internal_module, rb_intern("do_method_missing"), argc+3, temp_stack);
@@ -1581,9 +1581,9 @@ class_method_missing(int argc, VALUE * argv, VALUE klass)
 	}
 
     if (_current_method == -1) {
-static QRegExp * rx = 0;
+static TQRegExp * rx = 0;
 		if (rx == 0) {
-			rx = new QRegExp("[a-zA-Z]+");
+			rx = new TQRegExp("[a-zA-Z]+");
 		}
 
 		if (rx->search(methodName) == -1) {
@@ -1629,7 +1629,7 @@ class LCDRange < Qt::Widget
 		init()
 		...
 
-For a case such as the above, the QWidget can't be instantiated until
+For a case such as the above, the TQWidget can't be instantiated until
 the initializer has been run up to the point where 'super(parent, name)'
 is called. Only then, can the number and type of arguments passed to the
 constructor be known. However, the rest of the intializer
@@ -1637,7 +1637,7 @@ can't be run until 'self' is a proper T_DATA object with a wrapped C++
 instance.
 
 The solution is to run the initialize code twice. First, only up to the
-'super(parent, name)' call, where the QWidget would get instantiated in
+'super(parent, name)' call, where the TQWidget would get instantiated in
 initialize_qt(). And then rb_throw() jumps out of the
 initializer returning the wrapped object as a result.
 
@@ -1674,7 +1674,7 @@ initialize_qt(int argc, VALUE * argv, VALUE self)
 	{ 
 		// Put this in a C block so that the mcid will be de-allocated at the end of the block,
 		// rather than on f'n exit, to avoid the longjmp problem described below
-		QCString * mcid = find_cached_selector(argc+4, temp_stack, klass, rb_class2name(klass));
+		TQCString * mcid = find_cached_selector(argc+4, temp_stack, klass, rb_class2name(klass));
 
 		if (_current_method == -1) {
 			retval = rb_funcall2(qt_internal_module, rb_intern("do_method_missing"), argc+4, temp_stack);
@@ -1777,7 +1777,7 @@ getmetainfo(VALUE self, int &offset, int &index)
 
     smokeruby_object *ometa = value_obj_info(metaObject_value);
     if(!ometa) return 0;
-    QMetaObject *metaobject = (QMetaObject*)ometa->ptr;
+    TQMetaObject *metaobject = (TQMetaObject*)ometa->ptr;
 
     offset = metaobject->signalOffset();
 
@@ -1796,7 +1796,7 @@ getslotinfo(VALUE self, int id, char *&slotname, int &index, bool isSignal = fal
     smokeruby_object *ometa = value_obj_info(metaObject_value);
     if(!ometa) return Qnil;
 
-    QMetaObject *metaobject = (QMetaObject*)ometa->ptr;
+    TQMetaObject *metaobject = (TQMetaObject*)ometa->ptr;
 
     int offset = isSignal ? metaobject->signalOffset() : metaobject->slotOffset();
 
@@ -1819,10 +1819,10 @@ static VALUE
 qt_signal(int argc, VALUE * argv, VALUE self)
 {
 	smokeruby_object *o = value_obj_info(self);
-    QObject *qobj = (QObject*)o->smoke->cast(
+    TQObject *qobj = (TQObject*)o->smoke->cast(
 	o->ptr,
 	o->classId,
-	o->smoke->idClass("QObject")
+	o->smoke->idClass("TQObject")
     );
     if(qobj->signalsBlocked()) return Qfalse;
 
@@ -1853,10 +1853,10 @@ qt_invoke(int /*argc*/, VALUE * argv, VALUE self)
     }
 
     smokeruby_object *o = value_obj_info(self);
-    (void) (QObject*)o->smoke->cast(
+    (void) (TQObject*)o->smoke->cast(
 	o->ptr,
 	o->classId,
-	o->smoke->idClass("QObject")
+	o->smoke->idClass("TQObject")
     );
 
     // Now, I need to find out if this means me
@@ -1883,10 +1883,10 @@ qt_invoke(int /*argc*/, VALUE * argv, VALUE self)
 			o->smoke->classes[o->classId].className );
     }
 
-    QString name(slotname);
-static QRegExp * rx = 0;
+    TQString name(slotname);
+static TQRegExp * rx = 0;
 	if (rx == 0) {
-		rx = new QRegExp("\\(.*");
+		rx = new TQRegExp("\\(.*");
 	}
 	name.replace(*rx, "");
 
@@ -1951,8 +1951,8 @@ getIsa(VALUE /*self*/, VALUE classId)
     return parents_list;
 }
 
-// Return the class name of a QObject. Note that the name will be in the 
-// form of Qt::Widget rather than QWidget. Is this a bug or a feature?
+// Return the class name of a TQObject. Note that the name will be in the 
+// form of Qt::Widget rather than TQWidget. Is this a bug or a feature?
 static VALUE
 class_name(VALUE self)
 {
@@ -1986,7 +1986,7 @@ qbytearray_data(VALUE self)
 	if (o == 0 || o->ptr == 0) {
 		return Qnil;
 	}
-	QByteArray * dataArray = (QByteArray*) o->ptr;
+	TQByteArray * dataArray = (TQByteArray*) o->ptr;
 	return rb_str_new(dataArray->data(), (long) dataArray->size());
 }
 
@@ -1997,7 +1997,7 @@ qbytearray_size(VALUE self)
 	if (o == 0 || o->ptr == 0) {
 		return Qnil;
 	}
-	QByteArray * dataArray = (QByteArray*) o->ptr;
+	TQByteArray * dataArray = (TQByteArray*) o->ptr;
 	return UINT2NUM(dataArray->size());
 }
 
@@ -2008,7 +2008,7 @@ qbytearray_setRawData(VALUE self, VALUE data)
 	if (o == 0 || o->ptr == 0) {
 		return Qnil;
 	}
-	QByteArray * dataArray = (QByteArray*) o->ptr;
+	TQByteArray * dataArray = (TQByteArray*) o->ptr;
 	dataArray->setRawData(StringValuePtr(data), RSTRING(data)->len);
 	return self;
 }
@@ -2050,7 +2050,7 @@ setMocType(VALUE /*self*/, VALUE ptr, VALUE idx_value, VALUE name_value, VALUE s
 	arg[idx].argType = xmoc_double;
     else if(qstrcmp(static_type, "char*") == 0)
 	arg[idx].argType = xmoc_charstar;
-    else if(qstrcmp(static_type, "QString") == 0)
+    else if(qstrcmp(static_type, "TQString") == 0)
 	arg[idx].argType = xmoc_QString;
     return Qtrue;
 }
@@ -2164,8 +2164,8 @@ make_QUParameter(VALUE /*self*/, VALUE name_value, VALUE type_value, VALUE /*ext
 	p->type = &static_QUType_double;
     else if(qstrcmp(type, "char*") == 0 || qstrcmp(type, "const char*") == 0)
 	p->type = &static_QUType_charstar;
-    else if(qstrcmp(type, "QString") == 0 || qstrcmp(type, "QString&") == 0 ||
-	    qstrcmp(type, "const QString") == 0 || qstrcmp(type, "const QString&") == 0)
+    else if(qstrcmp(type, "TQString") == 0 || qstrcmp(type, "TQString&") == 0 ||
+	    qstrcmp(type, "const TQString") == 0 || qstrcmp(type, "const TQString&") == 0)
 	p->type = &static_QUType_QString;
     else
 	p->type = &static_QUType_ptr;
@@ -2252,8 +2252,8 @@ make_metaObject(VALUE /*self*/, VALUE className_value, VALUE parent, VALUE slot_
     	rb_raise(rb_eRuntimeError, "Cannot create metaObject\n");
     }
     
-	QMetaObject *meta = QMetaObject::new_metaobject(
-	className, (QMetaObject*)po->ptr,
+	TQMetaObject *meta = TQMetaObject::new_metaobject(
+	className, (TQMetaObject*)po->ptr,
 	(const QMetaData*)slot_tbl, slot_count,	// slots
 	(const QMetaData*)signal_tbl, signal_count,	// signals
 	0, 0,	// properties
@@ -2262,7 +2262,7 @@ make_metaObject(VALUE /*self*/, VALUE className_value, VALUE parent, VALUE slot_
 
     smokeruby_object * o = (smokeruby_object *) malloc(sizeof(smokeruby_object));
     o->smoke = qt_Smoke;
-    o->classId = qt_Smoke->idClass("QMetaObject");
+    o->classId = qt_Smoke->idClass("TQMetaObject");
     o->ptr = meta;
     o->allocated = true;
 
@@ -2534,9 +2534,9 @@ findAllMethods(int argc, VALUE * argv, VALUE /*self*/)
 static VALUE
 findAllMethodNames(VALUE /*self*/, VALUE result, VALUE classid, VALUE flags_value)
 {
-	QRegExp predicate_re("^(is|has)(.)(.*)");
-	QRegExp set_re("^(set)([A-Z])(.*)");
-	QRegExp op_re("operator(.*)(([-%~/+|&*])|(>>)|(<<)|(&&)|(\\|\\|)|(\\*\\*))=$");
+	TQRegExp predicate_re("^(is|has)(.)(.*)");
+	TQRegExp set_re("^(set)([A-Z])(.*)");
+	TQRegExp op_re("operator(.*)(([-%~/+|&*])|(>>)|(<<)|(&&)|(\\|\\|)|(\\*\\*))=$");
 
 	unsigned short flags = (unsigned short) NUM2UINT(flags_value);
 	if (classid != Qnil) {
@@ -2658,10 +2658,10 @@ static VALUE
 kde_package_to_class(const char * package, VALUE base_class)
 {
 	VALUE klass = Qnil;
-	QString packageName(package);
-static QRegExp * scope_op = 0;
+	TQString packageName(package);
+static TQRegExp * scope_op = 0;
 	if (scope_op == 0) {
-		scope_op = new QRegExp("^([^:]+)::([^:]+)$");
+		scope_op = new TQRegExp("^([^:]+)::([^:]+)$");
 	 }
 
 	if (packageName.startsWith("KDE::ConfigSkeleton::ItemEnum::")) {
@@ -2718,7 +2718,7 @@ static QRegExp * scope_op = 0;
 		VALUE module = rb_define_module(scope_op->cap(1).latin1());
 		klass = rb_define_class_under(module, scope_op->cap(2).latin1(), base_class);
 	} else if (	packageName.startsWith("K") 
-				&& packageName.mid(1, 1).contains(QRegExp("[A-Z]")) == 1 ) 
+				&& packageName.mid(1, 1).contains(TQRegExp("[A-Z]")) == 1 ) 
 	{
 		klass = rb_define_class_under(kde_module, package+strlen("K"), base_class);
 	} else {
@@ -2735,13 +2735,13 @@ create_qobject_class(VALUE /*self*/, VALUE package_value)
     const char *package = StringValuePtr(package_value);
 	VALUE klass;
 	
-	if (QString(package).startsWith("Qt::")) {
+	if (TQString(package).startsWith("Qt::")) {
     	klass = rb_define_class_under(qt_module, package+strlen("Qt::"), qt_base_class);
 		if (qstrcmp(package, "Qt::Application") == 0) {
 			rb_define_singleton_method(klass, "new", (VALUE (*) (...)) new_qapplication, -1);
 			rb_define_method(klass, "ARGV", (VALUE (*) (...)) qapplication_argv, 0);
 		}
-	} else if (QString(package).startsWith("Qext::")) {
+	} else if (TQString(package).startsWith("Qext::")) {
 		if (qext_scintilla_module == Qnil) {
 			qext_scintilla_module = rb_define_module("Qext");
 		}
@@ -2767,9 +2767,9 @@ create_qt_class(VALUE /*self*/, VALUE package_value)
     const char *package = StringValuePtr(package_value);
 	VALUE klass;
 	
-	if (QString(package).startsWith("Qt::")) {
+	if (TQString(package).startsWith("Qt::")) {
     	klass = rb_define_class_under(qt_module, package+strlen("Qt::"), qt_base_class);
-	} else if (QString(package).startsWith("Qext::")) {
+	} else if (TQString(package).startsWith("Qext::")) {
 		if (qext_scintilla_module == Qnil) {
 			qext_scintilla_module = rb_define_module("Qext");
 		}
diff --git a/qtruby/rubylib/qtruby/handlers.cpp b/qtruby/rubylib/qtruby/handlers.cpp
index 6bddf50c..e6cf263c 100644
--- a/qtruby/rubylib/qtruby/handlers.cpp
+++ b/qtruby/rubylib/qtruby/handlers.cpp
@@ -7,21 +7,21 @@
  *                                                                         *
  ***************************************************************************/
 
-#include <qstring.h>
-#include <qregexp.h>
-#include <qapplication.h>
-#include <qcanvas.h>
-#include <qlistview.h>
-#include <qiconview.h>
-#include <qtable.h>
-#include <qpopupmenu.h>
-#include <qlayout.h>
-#include <qmetaobject.h>
-#include <qvaluelist.h>
-#include <qobjectlist.h>
-#include <qtextcodec.h>
-#include <qhostaddress.h>
-#include <qpair.h>
+#include <tqstring.h>
+#include <tqregexp.h>
+#include <tqapplication.h>
+#include <tqcanvas.h>
+#include <tqlistview.h>
+#include <tqiconview.h>
+#include <tqtable.h>
+#include <tqpopupmenu.h>
+#include <tqlayout.h>
+#include <tqmetaobject.h>
+#include <tqvaluelist.h>
+#include <tqobjectlist.h>
+#include <tqtextcodec.h>
+#include <tqhostaddress.h>
+#include <tqpair.h>
 
 #include <private/qucomextra_p.h>
 
@@ -70,16 +70,16 @@ set_kde_resolve_classname(const char * (*kde_resolve_classname) (Smoke*, int, vo
 };
 
 void
-mark_qobject_children(QObject * qobject)
+mark_qobject_children(TQObject * qobject)
 {
 	VALUE obj;
 	
-	const QObjectList *l = qobject->children();
+	const TQObjectList *l = qobject->children();
 	if (l == 0) {
 		return;
 	}
-	QObjectListIt it( *l ); // iterate over the children
-	QObject *child;
+	TQObjectListIt it( *l ); // iterate over the children
+	TQObject *child;
 
 	while ( (child = it.current()) != 0 ) {
 		++it;
@@ -103,10 +103,10 @@ smokeruby_mark(void * p)
 	if(do_debug & qtdb_gc) qWarning("Checking for mark (%s*)%p\n", className, o->ptr);
 		
     if(o->ptr && o->allocated) {
-		if (isDerivedFromByName(o->smoke, className, "QListView")) {
-			QListView * listview = (QListView *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QListView"));
-			QListViewItemIterator it(listview);
-			QListViewItem *item;
+		if (isDerivedFromByName(o->smoke, className, "TQListView")) {
+			TQListView * listview = (TQListView *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQListView"));
+			TQListViewItemIterator it(listview);
+			TQListViewItem *item;
 
 			while ( (item = it.current()) != 0 ) {
 				++it;
@@ -119,9 +119,9 @@ smokeruby_mark(void * p)
 			return;
 		}
 		
-		if (isDerivedFromByName(o->smoke, className, "QTable")) {
-			QTable * table = (QTable *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QTable"));
-			QTableItem *item;
+		if (isDerivedFromByName(o->smoke, className, "TQTable")) {
+			TQTable * table = (TQTable *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQTable"));
+			TQTableItem *item;
 
 			for ( int row = 0; row < table->numRows(); row++ ) {
 				for ( int col = 0; col < table->numCols(); col++ ) {
@@ -136,10 +136,10 @@ smokeruby_mark(void * p)
 			return;		
 		}
 		
-		if (isDerivedFromByName(o->smoke, className, "QCanvas")) {
-			QCanvas * canvas = (QCanvas *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QCanvas"));
-    		QCanvasItemList list = canvas->allItems();
-    		for ( QCanvasItemList::iterator it = list.begin(); it != list.end(); ++it ) {
+		if (isDerivedFromByName(o->smoke, className, "TQCanvas")) {
+			TQCanvas * canvas = (TQCanvas *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQCanvas"));
+    		TQCanvasItemList list = canvas->allItems();
+    		for ( TQCanvasItemList::iterator it = list.begin(); it != list.end(); ++it ) {
 				obj = getPointerObject(*it);
 				if (obj != Qnil) {
 					if(do_debug & qtdb_gc) qWarning("Marking (%s*)%p -> %p\n", className, *it, (void*)obj);
@@ -149,19 +149,19 @@ smokeruby_mark(void * p)
 			return;
 		}
 
-		if (isDerivedFromByName(o->smoke, className, "QCanvasItem")) {
-			QCanvasItem * item = (QCanvasItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QCanvasItem"));
-			QCanvas * canvas = item->canvas();
+		if (isDerivedFromByName(o->smoke, className, "TQCanvasItem")) {
+			TQCanvasItem * item = (TQCanvasItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQCanvasItem"));
+			TQCanvas * canvas = item->canvas();
 			obj = getPointerObject(canvas);
 			if (obj != Qnil) {
-				if(do_debug & qtdb_gc) qWarning("Marking (%s*)%p -> %p\n", "QCanvas", canvas, (void*)obj);
+				if(do_debug & qtdb_gc) qWarning("Marking (%s*)%p -> %p\n", "TQCanvas", canvas, (void*)obj);
 				rb_gc_mark(obj);
 			}
 			return;
 		}
 		
-		if (isDerivedFromByName(o->smoke, className, "QObject")) {
-			QObject * qobject = (QObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QObject"));
+		if (isDerivedFromByName(o->smoke, className, "TQObject")) {
+			TQObject * qobject = (TQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
 			mark_qobject_children(qobject);
 			return;
 		}
@@ -184,63 +184,63 @@ smokeruby_free(void * p)
 	unmapPointer(o, o->classId, 0);
 	object_count --;
 	
-	if (	qstrcmp(className, "QObject") == 0
-			|| qstrcmp(className, "QListBoxItem") == 0
-			|| qstrcmp(className, "QStyleSheetItem") == 0
+	if (	qstrcmp(className, "TQObject") == 0
+			|| qstrcmp(className, "TQListBoxItem") == 0
+			|| qstrcmp(className, "TQStyleSheetItem") == 0
 			|| qstrcmp(className, "KCommand") == 0
 			|| qstrcmp(className, "KNamedCommand") == 0
 			|| qstrcmp(className, "KMacroCommand") == 0
 			|| qstrcmp(className, "KAboutData") == 0
 			|| qstrcmp(className, "KCmdLineArgs") == 0
-			|| qstrcmp(className, "QSqlCursor") == 0 )
+			|| qstrcmp(className, "TQSqlCursor") == 0 )
 	{
 		// Don't delete instances of these classes for now
 		free(o);
 		return;
-	} else if (isDerivedFromByName(o->smoke, className, "QLayoutItem")) {
-		QLayoutItem * item = (QLayoutItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QLayoutItem"));
+	} else if (isDerivedFromByName(o->smoke, className, "TQLayoutItem")) {
+		TQLayoutItem * item = (TQLayoutItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQLayoutItem"));
 		if (item->layout() != 0 || item->widget() != 0 || item->spacerItem() != 0) {
 			free(o);
 			return;
 		}
-	} else if (qstrcmp(className, "QIconViewItem") == 0) {
-		QIconViewItem * item = (QIconViewItem *) o->ptr;
+	} else if (qstrcmp(className, "TQIconViewItem") == 0) {
+		TQIconViewItem * item = (TQIconViewItem *) o->ptr;
 		if (item->iconView() != 0) {
 			free(o);
 			return;
 		}
-	} else if (qstrcmp(className, "QCheckListItem") == 0) {
-		QCheckListItem * item = (QCheckListItem *) o->ptr;
+	} else if (qstrcmp(className, "TQCheckListItem") == 0) {
+		TQCheckListItem * item = (TQCheckListItem *) o->ptr;
 		if (item->parent() != 0 || item->listView() != 0) {
 			free(o);
 			return;
 		}
-	} else if (qstrcmp(className, "QListViewItem") == 0) {
-		QListViewItem * item = (QListViewItem *) o->ptr;
+	} else if (qstrcmp(className, "TQListViewItem") == 0) {
+		TQListViewItem * item = (TQListViewItem *) o->ptr;
 		if (item->parent() != 0 || item->listView() != 0) {
 			free(o);
 			return;
 		}
-	} else if (isDerivedFromByName(o->smoke, className, "QTableItem")) {
-		QTableItem * item = (QTableItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QTableItem"));
+	} else if (isDerivedFromByName(o->smoke, className, "TQTableItem")) {
+		TQTableItem * item = (TQTableItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQTableItem"));
 		if (item->table() != 0) {
 			free(o);
 			return;
 		}
-	} else if (qstrcmp(className, "QPopupMenu") == 0) {
-		QPopupMenu * item = (QPopupMenu *) o->ptr;
+	} else if (qstrcmp(className, "TQPopupMenu") == 0) {
+		TQPopupMenu * item = (TQPopupMenu *) o->ptr;
 		if (item->parentWidget(false) != 0) {
 			free(o);
 			return;
 		}
-	} else if (isDerivedFromByName(o->smoke, className, "QWidget")) {
-		QWidget * qwidget = (QWidget *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QWidget"));
+	} else if (isDerivedFromByName(o->smoke, className, "TQWidget")) {
+		TQWidget * qwidget = (TQWidget *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQWidget"));
 		if (qwidget->parentWidget(true) != 0) {
 			free(o);
 			return;
 		}
-	} else if (isDerivedFromByName(o->smoke, className, "QObject")) {
-		QObject * qobject = (QObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("QObject"));
+	} else if (isDerivedFromByName(o->smoke, className, "TQObject")) {
+		TQObject * qobject = (TQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
 		if (qobject->parent() != 0) {
 			free(o);
 			return;
@@ -273,65 +273,65 @@ smokeruby_free(void * p)
 static const char *
 resolve_classname(Smoke* smoke, int classId, void * ptr)
 {
-	if (isDerivedFromByName(smoke, smoke->classes[classId].className, "QEvent")) {
-		QEvent * qevent = (QEvent *) smoke->cast(ptr, classId, smoke->idClass("QEvent"));
+	if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQEvent")) {
+		TQEvent * qevent = (TQEvent *) smoke->cast(ptr, classId, smoke->idClass("TQEvent"));
 		switch (qevent->type()) {
-		case QEvent::ChildInserted:
-		case QEvent::ChildRemoved:
+		case TQEvent::ChildInserted:
+		case TQEvent::ChildRemoved:
 			return "Qt::ChildEvent";
-		case QEvent::Close:
+		case TQEvent::Close:
 			return "Qt::CloseEvent";
-		case QEvent::ContextMenu:
+		case TQEvent::ContextMenu:
 			return "Qt::ContextMenuEvent";
-//		case QEvent::User:
+//		case TQEvent::User:
 //			return "Qt::CustomEvent";
-		case QEvent::DragEnter:
+		case TQEvent::DragEnter:
 			return "Qt::DragEnterEvent";
-		case QEvent::DragLeave:
+		case TQEvent::DragLeave:
 			return "Qt::DragLeaveEvent";
-		case QEvent::DragMove:
+		case TQEvent::DragMove:
 			return "Qt::DragMoveEvent";
-		case QEvent::DragResponse:
+		case TQEvent::DragResponse:
 			return "Qt::DragResponseEvent";
-		case QEvent::Drop:
+		case TQEvent::Drop:
 			return "Qt::DropEvent";
-		case QEvent::FocusIn:
-		case QEvent::FocusOut:
+		case TQEvent::FocusIn:
+		case TQEvent::FocusOut:
 			return "Qt::FocusEvent";
-		case QEvent::Hide:
+		case TQEvent::Hide:
 			return "Qt::HideEvent";
-		case QEvent::KeyPress:
-		case QEvent::KeyRelease:
+		case TQEvent::KeyPress:
+		case TQEvent::KeyRelease:
 			return "Qt::KeyEvent";
-		case QEvent::IMStart:
-		case QEvent::IMCompose:
-		case QEvent::IMEnd:
+		case TQEvent::IMStart:
+		case TQEvent::IMCompose:
+		case TQEvent::IMEnd:
 			return "Qt::IMEvent";
-		case QEvent::MouseButtonPress:
-		case QEvent::MouseButtonRelease:
-		case QEvent::MouseButtonDblClick:
-		case QEvent::MouseMove:
+		case TQEvent::MouseButtonPress:
+		case TQEvent::MouseButtonRelease:
+		case TQEvent::MouseButtonDblClick:
+		case TQEvent::MouseMove:
 			return "Qt::MouseEvent";
-		case QEvent::Move:
+		case TQEvent::Move:
 			return "Qt::MoveEvent";
-		case QEvent::Paint:
+		case TQEvent::Paint:
 			return "Qt::PaintEvent";
-		case QEvent::Resize:
+		case TQEvent::Resize:
 			return "Qt::ResizeEvent";
-		case QEvent::Show:
+		case TQEvent::Show:
 			return "Qt::ShowEvent";
-	//	case QEvent::Tablet:
+	//	case TQEvent::Tablet:
 	//		 return "Qt::TabletEvent";
-		case QEvent::Timer:
+		case TQEvent::Timer:
 			return "Qt::TimerEvent";
-		case QEvent::Wheel:
+		case TQEvent::Wheel:
 			return "Qt::WheelEvent";
 		default:
 			break;
 		}
-	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "QObject")) {
-		QObject * qobject = (QObject *) smoke->cast(ptr, classId, smoke->idClass("QObject"));
-		QMetaObject * meta = qobject->metaObject();
+	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQObject")) {
+		TQObject * qobject = (TQObject *) smoke->cast(ptr, classId, smoke->idClass("TQObject"));
+		TQMetaObject * meta = qobject->metaObject();
 
 		while (meta != 0) {
 			Smoke::Index classId = smoke->idClass(meta->className());
@@ -341,30 +341,30 @@ resolve_classname(Smoke* smoke, int classId, void * ptr)
 
 			meta = meta->superClass();
 		}
-	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "QCanvasItem")) {
-		QCanvasItem * qcanvasitem = (QCanvasItem *) smoke->cast(ptr, classId, smoke->idClass("QCanvasItem"));
+	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQCanvasItem")) {
+		TQCanvasItem * qcanvasitem = (TQCanvasItem *) smoke->cast(ptr, classId, smoke->idClass("TQCanvasItem"));
 		switch (qcanvasitem->rtti()) {
-		case QCanvasItem::Rtti_Sprite:
+		case TQCanvasItem::Rtti_Sprite:
 			return "Qt::CanvasSprite";
-		case QCanvasItem::Rtti_PolygonalItem:
+		case TQCanvasItem::Rtti_PolygonalItem:
 			return "Qt::CanvasPolygonalItem";
-		case QCanvasItem::Rtti_Text:
+		case TQCanvasItem::Rtti_Text:
 			return "Qt::CanvasText";
-		case QCanvasItem::Rtti_Polygon:
+		case TQCanvasItem::Rtti_Polygon:
 			return "Qt::CanvasPolygon";
-		case QCanvasItem::Rtti_Rectangle:
+		case TQCanvasItem::Rtti_Rectangle:
 			return "Qt::CanvasRectangle";
-		case QCanvasItem::Rtti_Ellipse:
+		case TQCanvasItem::Rtti_Ellipse:
 			return "Qt::CanvasEllipse";
-		case QCanvasItem::Rtti_Line:
+		case TQCanvasItem::Rtti_Line:
 			return "Qt::CanvasLine";
-		case QCanvasItem::Rtti_Spline:
+		case TQCanvasItem::Rtti_Spline:
 			return "Qt::CanvasSpline";
 		default:
 			break;
 		}
-	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "QListViewItem")) {
-		QListViewItem * item = (QListViewItem *) smoke->cast(ptr, classId, smoke->idClass("QListViewItem"));
+	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQListViewItem")) {
+		TQListViewItem * item = (TQListViewItem *) smoke->cast(ptr, classId, smoke->idClass("TQListViewItem"));
 		switch (item->rtti()) {
 		case 0:
 			return "Qt::ListViewItem";
@@ -374,8 +374,8 @@ resolve_classname(Smoke* smoke, int classId, void * ptr)
 			return "Qt::ListViewItem";
 			break;
 		}
-	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "QTableItem")) {
-		QTableItem * item = (QTableItem *) smoke->cast(ptr, classId, smoke->idClass("QTableItem"));
+	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQTableItem")) {
+		TQTableItem * item = (TQTableItem *) smoke->cast(ptr, classId, smoke->idClass("TQTableItem"));
 		switch (item->rtti()) {
 		case 0:
 			return "Qt::TableItem";
@@ -803,41 +803,41 @@ void marshall_ucharP(Marshall *m) {
 }
 
 static const char * KCODE = 0;
-static QTextCodec *codec = 0;
+static TQTextCodec *codec = 0;
 
 static void 
 init_codec() {
 	VALUE temp = rb_gv_get("$KCODE");
 	KCODE = StringValuePtr(temp);
 	if (qstrcmp(KCODE, "EUC") == 0) {
-		codec = QTextCodec::codecForName("eucJP");
+		codec = TQTextCodec::codecForName("eucJP");
 	} else if (qstrcmp(KCODE, "SJIS") == 0) {
-		codec = QTextCodec::codecForName("Shift-JIS");
+		codec = TQTextCodec::codecForName("Shift-JIS");
 	}
 }
 
-QString* 
+TQString* 
 qstringFromRString(VALUE rstring) {
 	if (KCODE == 0) {
 		init_codec();
 	}
 	
-	QString *	s;
+	TQString *	s;
 	if (qstrcmp(KCODE, "UTF8") == 0)
-		s = new QString(QString::fromUtf8(StringValuePtr(rstring), RSTRING(rstring)->len));
+		s = new TQString(TQString::fromUtf8(StringValuePtr(rstring), RSTRING(rstring)->len));
 	else if (qstrcmp(KCODE, "EUC") == 0)
-		s = new QString(codec->toUnicode(StringValuePtr(rstring)));
+		s = new TQString(codec->toUnicode(StringValuePtr(rstring)));
 	else if (qstrcmp(KCODE, "SJIS") == 0)
-		s = new QString(codec->toUnicode(StringValuePtr(rstring)));
+		s = new TQString(codec->toUnicode(StringValuePtr(rstring)));
 	else if(qstrcmp(KCODE, "NONE") == 0)
-		s = new QString(QString::fromLatin1(StringValuePtr(rstring)));
+		s = new TQString(TQString::fromLatin1(StringValuePtr(rstring)));
 	else
-		s = new QString(QString::fromLocal8Bit(StringValuePtr(rstring), RSTRING(rstring)->len));
+		s = new TQString(TQString::fromLocal8Bit(StringValuePtr(rstring), RSTRING(rstring)->len));
 	return s;
 }
 
 VALUE 
-rstringFromQString(QString * s) {
+rstringFromQString(TQString * s) {
 	if (KCODE == 0) {
 		init_codec();
 	}
@@ -858,11 +858,11 @@ static void marshall_QString(Marshall *m) {
 	switch(m->action()) {
 	case Marshall::FromVALUE:
 	{
-		QString* s = 0;
+		TQString* s = 0;
 		if ( *(m->var()) != Qnil) {
 			s = qstringFromRString(*(m->var()));
 		} else {
-			s = new QString(QString::null);
+			s = new TQString(TQString::null);
 		}
 		
 		m->item().s_voidp = s;
@@ -881,7 +881,7 @@ static void marshall_QString(Marshall *m) {
 	break;
 	case Marshall::ToVALUE:
 	{
-		QString *s = (QString*)m->item().s_voidp;
+		TQString *s = (TQString*)m->item().s_voidp;
 		if (s != 0) {
 			if (s->isNull()) {
 				*(m->var()) = Qnil;
@@ -902,8 +902,8 @@ static void marshall_QString(Marshall *m) {
     }
 }
 
-// The only way to convert a QChar to a QString is to
-// pass a QChar to a QString constructor. However,
+// The only way to convert a TQChar to a TQString is to
+// pass a TQChar to a TQString constructor. However,
 // QStrings aren't in the QtRuby api, so add this
 // convenience method 'Qt::Char.to_s' to get a ruby
 // string from a Qt::Char.
@@ -915,8 +915,8 @@ qchar_to_s(VALUE self)
 		return Qnil;
 	}
 
-	QChar * qchar = (QChar*) o->ptr;
-	QString s(*qchar);
+	TQChar * qchar = (TQChar*) o->ptr;
+	TQString s(*qchar);
 	return rstringFromQString(&s);
 }
 
@@ -938,13 +938,13 @@ static void marshall_QCString(Marshall *m) {
     switch(m->action()) {
       case Marshall::FromVALUE:
 	{
-	    QCString *s = 0;
+	    TQCString *s = 0;
 	    VALUE rv = *(m->var());
 	    if (rv == Qnil) {
-		s = new QCString(); 
+		s = new TQCString(); 
         } else {
-		// Add 1 to the ruby string length to allow for a QCString '\0' terminator
-		s = new QCString(StringValuePtr(*(m->var())), RSTRING(*(m->var()))->len + 1); 
+		// Add 1 to the ruby string length to allow for a TQCString '\0' terminator
+		s = new TQCString(StringValuePtr(*(m->var())), RSTRING(*(m->var()))->len + 1); 
 		}
 	    m->item().s_voidp = s;
 	    
@@ -960,7 +960,7 @@ static void marshall_QCString(Marshall *m) {
 	break;
       case Marshall::ToVALUE:
 	{
-	    QCString *s = (QCString*)m->item().s_voidp;
+	    TQCString *s = (TQCString*)m->item().s_voidp;
 	    if(s && (const char *) *s != 0) {
 		*(m->var()) = rb_str_new2((const char *)*s);
 //                const char * p = (const char *)*s;
@@ -968,7 +968,7 @@ static void marshall_QCString(Marshall *m) {
 //                if(not_ascii(p,len))
 //                {
 //                  #if PERL_VERSION == 6 && PERL_SUBVERSION == 0
-//                  QTextCodec* c = QTextCodec::codecForMib(106); // utf8
+//                  TQTextCodec* c = TQTextCodec::codecForMib(106); // utf8
 //                  if(c->heuristicContentMatch(p,len) >= 0)
 //                  #else
 //                  if(is_utf8_string((U8 *)p,len))
@@ -1208,12 +1208,12 @@ void marshall_QStringList(Marshall *m) {
 	    }
 
 	    int count = RARRAY(list)->len;
-	    QStringList *stringlist = new QStringList;
+	    TQStringList *stringlist = new QStringList;
 
 	    for(long i = 0; i < count; i++) {
 		VALUE item = rb_ary_entry(list, i);
 		if(TYPE(item) != T_STRING) {
-		    stringlist->append(QString());
+		    stringlist->append(TQString());
 		    continue;
 		}
 		stringlist->append(*(qstringFromRString(item)));
@@ -1225,7 +1225,7 @@ void marshall_QStringList(Marshall *m) {
 		
 		if (stringlist != 0 && !m->type().isConst()) {
 			rb_ary_clear(list);
-			for(QStringList::Iterator it = stringlist->begin(); it != stringlist->end(); ++it)
+			for(TQStringList::Iterator it = stringlist->begin(); it != stringlist->end(); ++it)
 		    	rb_ary_push(list, rstringFromQString(&(*it)));
 		}
 			
@@ -1235,14 +1235,14 @@ void marshall_QStringList(Marshall *m) {
       }
       case Marshall::ToVALUE: 
 	{
-	    QStringList *stringlist = static_cast<QStringList *>(m->item().s_voidp);
+	    TQStringList *stringlist = static_cast<TQStringList *>(m->item().s_voidp);
 	    if(!stringlist) {
 		*(m->var()) = Qnil;
 		break;
 	    }
 
 	    VALUE av = rb_ary_new();
-	    for(QStringList::Iterator it = stringlist->begin(); it != stringlist->end(); ++it) {
+	    for(TQStringList::Iterator it = stringlist->begin(); it != stringlist->end(); ++it) {
 		VALUE rv = rstringFromQString(&(*it));
 		rb_ary_push(av, rv);
 	    }
@@ -1270,15 +1270,15 @@ void marshall_QStrList(Marshall *m) {
 	    }
 
 	    int count = RARRAY(list)->len;
-	    QStrList *stringlist = new QStrList;
+	    TQStrList *stringlist = new QStrList;
 
 	    for(long i = 0; i < count; i++) {
 		VALUE item = rb_ary_entry(list, i);
 		if(TYPE(item) != T_STRING) {
-		    stringlist->append(QString());
+		    stringlist->append(TQString());
 		    continue;
 		}
-		stringlist->append(QString::fromUtf8(StringValuePtr(item), RSTRING(item)->len));
+		stringlist->append(TQString::fromUtf8(StringValuePtr(item), RSTRING(item)->len));
 	    }
 
 	    m->item().s_voidp = stringlist;
@@ -1297,7 +1297,7 @@ void marshall_QStrList(Marshall *m) {
       }
       case Marshall::ToVALUE: 
 	{
-	    QStrList *stringlist = static_cast<QStrList *>(m->item().s_voidp);
+	    TQStrList *stringlist = static_cast<TQStrList *>(m->item().s_voidp);
 	    if(!stringlist) {
 		*(m->var()) = Qnil;
 		break;
@@ -1422,7 +1422,7 @@ void marshall_QValueListInt(Marshall *m) {
 		break;
 	    }
 	    int count = RARRAY(list)->len;
-	    QValueList<int> *valuelist = new QValueList<int>;
+	    TQValueList<int> *valuelist = new TQValueList<int>;
 	    long i;
 	    for(i = 0; i < count; i++) {
 		VALUE item = rb_ary_entry(list, i);
@@ -1438,7 +1438,7 @@ void marshall_QValueListInt(Marshall *m) {
 
 		if (!m->type().isConst()) {
 			rb_ary_clear(list);
-			for(QValueListIterator<int> it = valuelist->begin();
+			for(TQValueListIterator<int> it = valuelist->begin();
 				it != valuelist->end();
 				++it)
 				rb_ary_push(list, INT2NUM((int)*it));
@@ -1451,7 +1451,7 @@ void marshall_QValueListInt(Marshall *m) {
 	break;
       case Marshall::ToVALUE:
 	{
-	    QValueList<int> *valuelist = (QValueList<int>*)m->item().s_voidp;
+	    TQValueList<int> *valuelist = (TQValueList<int>*)m->item().s_voidp;
 	    if(!valuelist) {
 		*(m->var()) = Qnil;
 		break;
@@ -1459,7 +1459,7 @@ void marshall_QValueListInt(Marshall *m) {
 
 	    VALUE av = rb_ary_new();
 
-	    for(QValueListIterator<int> it = valuelist->begin();
+	    for(TQValueListIterator<int> it = valuelist->begin();
 		it != valuelist->end();
 		++it)
 		rb_ary_push(av, INT2NUM(*it));
@@ -1508,7 +1508,7 @@ void marshall_QMapQStringQString(Marshall *m) {
 		break;
 	    }
 		
-		QMap<QString,QString> * map = new QMap<QString,QString>;
+		TQMap<TQString,TQString> * map = new TQMap<TQString,TQString>;
 		
 		// Convert the ruby hash to an array of key/value arrays
 		VALUE temp = rb_funcall(hash, rb_intern("to_a"), 0);
@@ -1516,7 +1516,7 @@ void marshall_QMapQStringQString(Marshall *m) {
 		for (long i = 0; i < RARRAY(temp)->len; i++) {
 			VALUE key = rb_ary_entry(rb_ary_entry(temp, i), 0);
 			VALUE value = rb_ary_entry(rb_ary_entry(temp, i), 1);
-			(*map)[QString(StringValuePtr(key))] = QString(StringValuePtr(value));
+			(*map)[TQString(StringValuePtr(key))] = TQString(StringValuePtr(value));
 		}
 	    
 		m->item().s_voidp = map;
@@ -1528,7 +1528,7 @@ void marshall_QMapQStringQString(Marshall *m) {
 	break;
       case Marshall::ToVALUE:
 	{
-	    QMap<QString,QString> *map = (QMap<QString,QString>*)m->item().s_voidp;
+	    TQMap<TQString,TQString> *map = (TQMap<TQString,TQString>*)m->item().s_voidp;
 	    if(!map) {
 		*(m->var()) = Qnil;
 		break;
@@ -1536,9 +1536,9 @@ void marshall_QMapQStringQString(Marshall *m) {
 		
 	    VALUE hv = rb_hash_new();
 			
-		QMap<QString,QString>::Iterator it;
+		TQMap<TQString,TQString>::Iterator it;
 		for (it = map->begin(); it != map->end(); ++it) {
-			rb_hash_aset(hv, rstringFromQString((QString*)&(it.key())), rstringFromQString((QString*) &(it.data())));
+			rb_hash_aset(hv, rstringFromQString((TQString*)&(it.key())), rstringFromQString((TQString*) &(it.data())));
         }
 		
 		*(m->var()) = hv;
@@ -1564,7 +1564,7 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 		break;
 	    }
 		
-		QMap<QString,QVariant> * map = new QMap<QString,QVariant>;
+		TQMap<TQString,TQVariant> * map = new TQMap<TQString,TQVariant>;
 		
 		// Convert the ruby hash to an array of key/value arrays
 		VALUE temp = rb_funcall(hash, rb_intern("to_a"), 0);
@@ -1574,7 +1574,7 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 			VALUE value = rb_ary_entry(rb_ary_entry(temp, i), 1);
 			
 			smokeruby_object *o = value_obj_info(value);
-			if (!o || !o->ptr || o->classId != o->smoke->idClass("QVariant")) {
+			if (!o || !o->ptr || o->classId != o->smoke->idClass("TQVariant")) {
 				// If the value isn't a Qt::Variant, then try and construct
 				// a Qt::Variant from it
 				value = rb_funcall(qvariant_class, rb_intern("new"), 1, value);
@@ -1585,9 +1585,9 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 			}
 
 			void * ptr = o->ptr;
-			ptr = o->smoke->cast(ptr, o->classId, o->smoke->idClass("QVariant"));
+			ptr = o->smoke->cast(ptr, o->classId, o->smoke->idClass("TQVariant"));
 			
-			(*map)[QString(StringValuePtr(key))] = (QVariant)*(QVariant*)ptr;
+			(*map)[TQString(StringValuePtr(key))] = (TQVariant)*(TQVariant*)ptr;
 		}
 	    
 		m->item().s_voidp = map;
@@ -1599,7 +1599,7 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 	break;
       case Marshall::ToVALUE:
 	{
-	    QMap<QString,QVariant> *map = (QMap<QString,QVariant>*)m->item().s_voidp;
+	    TQMap<TQString,TQVariant> *map = (TQMap<TQString,TQVariant>*)m->item().s_voidp;
 	    if(!map) {
 		*(m->var()) = Qnil;
 		break;
@@ -1607,21 +1607,21 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 		
 	    VALUE hv = rb_hash_new();
 			
-		QMap<QString,QVariant>::Iterator it;
+		TQMap<TQString,TQVariant>::Iterator it;
 		for (it = map->begin(); it != map->end(); ++it) {
-			void *p = new QVariant(it.data());
+			void *p = new TQVariant(it.data());
 			VALUE obj = getPointerObject(p);
 				
 			if (obj == Qnil) {
 				smokeruby_object  * o = ALLOC(smokeruby_object);
-				o->classId = m->smoke()->idClass("QVariant");
+				o->classId = m->smoke()->idClass("TQVariant");
 				o->smoke = m->smoke();
 				o->ptr = p;
 				o->allocated = true;
 				obj = set_obj_info("Qt::Variant", o);
 			}
 			
-			rb_hash_aset(hv, rstringFromQString((QString*)&(it.key())), obj);
+			rb_hash_aset(hv, rstringFromQString((TQString*)&(it.key())), obj);
         }
 		
 		*(m->var()) = hv;
@@ -1739,26 +1739,26 @@ void marshall_QPairintint(Marshall *m) {
 #define DEF_LIST_MARSHALLER(ListIdent,ItemList,Item,Itr) namespace { char ListIdent##STR[] = #Item; };  \
         Marshall::HandlerFn marshall_##ListIdent = marshall_ItemList<Item,ItemList,Itr,ListIdent##STR>;
 
-#include <qcanvas.h>
-#include <qdir.h>
-#include <qobjectlist.h>
-#include <qwidgetlist.h>
-#include <qdockwindow.h>
-#include <qnetworkprotocol.h>
-#include <qtoolbar.h>
-#include <qtabbar.h>
+#include <tqcanvas.h>
+#include <tqdir.h>
+#include <tqobjectlist.h>
+#include <tqwidgetlist.h>
+#include <tqdockwindow.h>
+#include <tqnetworkprotocol.h>
+#include <tqtoolbar.h>
+#include <tqtabbar.h>
 
 #if QT_VERSION >= 0x030200
-DEF_LIST_MARSHALLER( QPtrListQNetworkOperation, QPtrList<QNetworkOperation>, QNetworkOperation, QPtrListStdIterator<QNetworkOperation> )
-DEF_LIST_MARSHALLER( QPtrListQToolBar, QPtrList<QToolBar>, QToolBar, QPtrListStdIterator<QToolBar> )
-DEF_LIST_MARSHALLER( QPtrListQTab, QPtrList<QTab>, QTab, QPtrListStdIterator<QTab> )
-DEF_LIST_MARSHALLER( QPtrListQDockWindow, QPtrList<QDockWindow>, QDockWindow, QPtrListStdIterator<QDockWindow> )
-DEF_LIST_MARSHALLER( QFileInfoList, QFileInfoList, QFileInfo, QFileInfoList::Iterator )
-DEF_LIST_MARSHALLER( QObjectList, QObjectList, QObject, QPtrListStdIterator<QObject> )
-DEF_LIST_MARSHALLER( QWidgetList, QWidgetList, QWidget, QPtrListStdIterator<QWidget> )
+DEF_LIST_MARSHALLER( QPtrListQNetworkOperation, TQPtrList<TQNetworkOperation>, TQNetworkOperation, TQPtrListStdIterator<TQNetworkOperation> )
+DEF_LIST_MARSHALLER( QPtrListQToolBar, TQPtrList<TQToolBar>, TQToolBar, TQPtrListStdIterator<TQToolBar> )
+DEF_LIST_MARSHALLER( QPtrListQTab, TQPtrList<TQTab>, TQTab, TQPtrListStdIterator<TQTab> )
+DEF_LIST_MARSHALLER( QPtrListQDockWindow, TQPtrList<TQDockWindow>, TQDockWindow, TQPtrListStdIterator<TQDockWindow> )
+DEF_LIST_MARSHALLER( QFileInfoList, QFileInfoList, TQFileInfo, QFileInfoList::Iterator )
+DEF_LIST_MARSHALLER( TQObjectList, TQObjectList, TQObject, TQPtrListStdIterator<TQObject> )
+DEF_LIST_MARSHALLER( TQWidgetList, TQWidgetList, TQWidget, TQPtrListStdIterator<TQWidget> )
 #endif
 
-DEF_LIST_MARSHALLER( QCanvasItemList, QCanvasItemList, QCanvasItem, QValueListIterator<QCanvasItem*> )
+DEF_LIST_MARSHALLER( TQCanvasItemList, TQCanvasItemList, TQCanvasItem, TQValueListIterator<TQCanvasItem*> )
 
 template <class Item, class ItemList, class ItemListIterator, const char *ItemSTR >
 void marshall_ValueItemList(Marshall *m) {
@@ -1778,9 +1778,9 @@ void marshall_ValueItemList(Marshall *m) {
                 // TODO do type checking!
 		smokeruby_object *o = value_obj_info(item);
 
-		// Special case for the QValueList<QVariant> type
-		if (	qstrcmp(ItemSTR, "QVariant") == 0 
-				&& (!o || !o->ptr || o->classId != o->smoke->idClass("QVariant")) ) 
+		// Special case for the TQValueList<TQVariant> type
+		if (	qstrcmp(ItemSTR, "TQVariant") == 0 
+				&& (!o || !o->ptr || o->classId != o->smoke->idClass("TQVariant")) ) 
 		{
 			// If the value isn't a Qt::Variant, then try and construct
 			// a Qt::Variant from it
@@ -1871,27 +1871,27 @@ void marshall_ValueItemList(Marshall *m) {
 #define DEF_VALUELIST_MARSHALLER(ListIdent,ItemList,Item,Itr) namespace dummy { char ListIdent##STR[] = #Item; };  \
         Marshall::HandlerFn marshall_##ListIdent = marshall_ValueItemList<Item,ItemList,Itr,dummy::ListIdent##STR>;
 
-DEF_VALUELIST_MARSHALLER( QVariantList, QValueList<QVariant>, QVariant, QValueList<QVariant>::Iterator )
-DEF_VALUELIST_MARSHALLER( QPixmapList, QValueList<QPixmap>, QPixmap, QValueList<QPixmap>::Iterator )
-DEF_VALUELIST_MARSHALLER( QIconDragItemList, QValueList<QIconDragItem>, QIconDragItem, QValueList<QIconDragItem>::Iterator )
-DEF_VALUELIST_MARSHALLER( QImageTextKeyLangList, QValueList<QImageTextKeyLang>, QImageTextKeyLang, QValueList<QImageTextKeyLang>::Iterator )
-DEF_VALUELIST_MARSHALLER( QUrlInfoList, QValueList<QUrlInfo>, QUrlInfo, QValueList<QUrlInfo>::Iterator )
-DEF_VALUELIST_MARSHALLER( QTranslatorMessageList, QValueList<QTranslatorMessage>, QTranslatorMessage, QValueList<QTranslatorMessage>::Iterator )
-DEF_VALUELIST_MARSHALLER( QHostAddressList, QValueList<QHostAddress>, QHostAddress, QValueList<QHostAddress>::Iterator )
+DEF_VALUELIST_MARSHALLER( QVariantList, TQValueList<TQVariant>, TQVariant, TQValueList<TQVariant>::Iterator )
+DEF_VALUELIST_MARSHALLER( QPixmapList, TQValueList<TQPixmap>, TQPixmap, TQValueList<TQPixmap>::Iterator )
+DEF_VALUELIST_MARSHALLER( QIconDragItemList, TQValueList<TQIconDragItem>, TQIconDragItem, TQValueList<TQIconDragItem>::Iterator )
+DEF_VALUELIST_MARSHALLER( QImageTextKeyLangList, TQValueList<TQImageTextKeyLang>, TQImageTextKeyLang, TQValueList<TQImageTextKeyLang>::Iterator )
+DEF_VALUELIST_MARSHALLER( QUrlInfoList, TQValueList<TQUrlInfo>, TQUrlInfo, TQValueList<TQUrlInfo>::Iterator )
+DEF_VALUELIST_MARSHALLER( QTranslatorMessageList, TQValueList<QTranslatorMessage>, QTranslatorMessage, TQValueList<QTranslatorMessage>::Iterator )
+DEF_VALUELIST_MARSHALLER( QHostAddressList, TQValueList<TQHostAddress>, TQHostAddress, TQValueList<TQHostAddress>::Iterator )
 
 TypeHandler Qt_handlers[] = {
-    { "QString", marshall_QString },
-    { "QString&", marshall_QString },
-    { "QString*", marshall_QString },
-    { "QCString", marshall_QCString },
-    { "QCString&", marshall_QCString },
-    { "QCString*", marshall_QCString },
-    { "QStringList", marshall_QStringList },
-    { "QStringList&", marshall_QStringList },
-    { "QStringList*", marshall_QStringList },
-    { "QStrList", marshall_QStrList },
-    { "QStrList&", marshall_QStrList },
-    { "QStrList*", marshall_QStrList },
+    { "TQString", marshall_QString },
+    { "TQString&", marshall_QString },
+    { "TQString*", marshall_QString },
+    { "TQCString", marshall_QCString },
+    { "TQCString&", marshall_QCString },
+    { "TQCString*", marshall_QCString },
+    { "TQStringList", marshall_QStringList },
+    { "TQStringList&", marshall_QStringList },
+    { "TQStringList*", marshall_QStringList },
+    { "TQStrList", marshall_QStrList },
+    { "TQStrList&", marshall_QStrList },
+    { "TQStrList*", marshall_QStrList },
     { "long long int", marshall_longlong },
     { "long long int&", marshall_longlong },
     { "Q_INT64", marshall_longlong },
@@ -1919,39 +1919,39 @@ TypeHandler Qt_handlers[] = {
     { "QUObject*", marshall_QUObject },
     { "const QCOORD*", marshall_QCOORD_array },
     { "void", marshall_void },
-    { "QValueList<int>", marshall_QValueListInt },
-    { "QValueList<int>&", marshall_QValueListInt },
-    { "QValueList<QVariant>", marshall_QVariantList },
-    { "QValueList<QVariant>&", marshall_QVariantList },
-    { "QValueList<QPixmap>", marshall_QPixmapList },
-    { "QValueList<QIconDragItem>&", marshall_QIconDragItemList },
-    { "QValueList<QImageTextKeyLang>", marshall_QImageTextKeyLangList },
-    { "QValueList<QUrlInfo>&", marshall_QUrlInfoList },
-    { "QValueList<QTranslatorMessage>", marshall_QTranslatorMessageList },
-    { "QValueList<QHostAddress>", marshall_QHostAddressList },
-    { "QCanvasItemList", marshall_QCanvasItemList },
-    { "QMap<QString,QString>", marshall_QMapQStringQString },
-    { "QMap<QString,QString>&", marshall_QMapQStringQString },
-    { "QMap<QString,QVariant>", marshall_QMapQStringQVariant },
-    { "QMap<QString,QVariant>&", marshall_QMapQStringQVariant },
+    { "TQValueList<int>", marshall_QValueListInt },
+    { "TQValueList<int>&", marshall_QValueListInt },
+    { "TQValueList<TQVariant>", marshall_QVariantList },
+    { "TQValueList<TQVariant>&", marshall_QVariantList },
+    { "TQValueList<TQPixmap>", marshall_QPixmapList },
+    { "TQValueList<TQIconDragItem>&", marshall_QIconDragItemList },
+    { "TQValueList<TQImageTextKeyLang>", marshall_QImageTextKeyLangList },
+    { "TQValueList<TQUrlInfo>&", marshall_QUrlInfoList },
+    { "TQValueList<QTranslatorMessage>", marshall_QTranslatorMessageList },
+    { "TQValueList<TQHostAddress>", marshall_QHostAddressList },
+    { "TQCanvasItemList", marshall_TQCanvasItemList },
+    { "TQMap<TQString,TQString>", marshall_QMapQStringQString },
+    { "TQMap<TQString,TQString>&", marshall_QMapQStringQString },
+    { "TQMap<TQString,TQVariant>", marshall_QMapQStringQVariant },
+    { "TQMap<TQString,TQVariant>&", marshall_QMapQStringQVariant },
 #if QT_VERSION >= 0x030200
-    { "QWidgetList", marshall_QWidgetList },
-    { "QWidgetList*", marshall_QWidgetList },
-    { "QWidgetList&", marshall_QWidgetList },
-    { "QObjectList*", marshall_QObjectList },
-    { "QObjectList&", marshall_QObjectList },
+    { "TQWidgetList", marshall_TQWidgetList },
+    { "TQWidgetList*", marshall_TQWidgetList },
+    { "TQWidgetList&", marshall_TQWidgetList },
+    { "TQObjectList*", marshall_TQObjectList },
+    { "TQObjectList&", marshall_TQObjectList },
     { "QFileInfoList*", marshall_QFileInfoList },
-    { "QPtrList<QToolBar>", marshall_QPtrListQToolBar },
-    { "QPtrList<QTab>*", marshall_QPtrListQTab },
-    { "QPtrList<QDockWindow>", marshall_QPtrListQDockWindow },
-    { "QPtrList<QDockWindow>*", marshall_QPtrListQDockWindow },
-    { "QPtrList<QNetworkOperation>", marshall_QPtrListQNetworkOperation },
-    { "QPtrList<QNetworkOperation>&", marshall_QPtrListQNetworkOperation },
+    { "TQPtrList<TQToolBar>", marshall_QPtrListQToolBar },
+    { "TQPtrList<TQTab>*", marshall_QPtrListQTab },
+    { "TQPtrList<TQDockWindow>", marshall_QPtrListQDockWindow },
+    { "TQPtrList<TQDockWindow>*", marshall_QPtrListQDockWindow },
+    { "TQPtrList<TQNetworkOperation>", marshall_QPtrListQNetworkOperation },
+    { "TQPtrList<TQNetworkOperation>&", marshall_QPtrListQNetworkOperation },
 #endif
     { 0, 0 }
 };
 
-QAsciiDict<TypeHandler> type_handlers(199);
+TQAsciiDict<TypeHandler> type_handlers(199);
 
 void install_handlers(TypeHandler *h) {
     while(h->name) {
diff --git a/qtruby/rubylib/qtruby/smokeruby.h b/qtruby/rubylib/qtruby/smokeruby.h
index 8f152c10..dd3b81bb 100644
--- a/qtruby/rubylib/qtruby/smokeruby.h
+++ b/qtruby/rubylib/qtruby/smokeruby.h
@@ -15,7 +15,7 @@
 #endif
 #include "ruby.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 #include "qtruby.h"
 #include "marshall.h"
@@ -288,7 +288,7 @@ public:
  * Type handling by moc is simple.
  *
  * If the type name matches /^(?:const\s+)?\Q$types\E&?$/, use the
- * static_QUType, where $types is join('|', qw(bool int double char* QString);
+ * static_QUType, where $types is join('|', qw(bool int double char* TQString);
  *
  * Everything else is passed as a pointer! There are types which aren't
  * Smoke::tf_ptr but will have to be passed as a pointer. Make sure to keep