Initial TQt conversion

1 files changed, 262 insertions, 262 deletions

diff --git a/qtruby/rubylib/qtruby/handlers.cpp b/qtruby/rubylib/qtruby/handlers.cpp
index e6cf263c..3cb04df8 100644
--- a/qtruby/rubylib/qtruby/handlers.cpp
+++ b/qtruby/rubylib/qtruby/handlers.cpp
@@ -70,16 +70,16 @@ set_kde_resolve_classname(const char * (*kde_resolve_classname) (Smoke*, int, vo
 };
 
 void
-mark_qobject_children(TQObject * qobject)
+mark_qobject_children(TTQObject * qobject)
 {
 	VALUE obj;
 	
-	const TQObjectList *l = qobject->children();
+	const TTQObjectList *l = qobject->children();
 	if (l == 0) {
 		return;
 	}
-	TQObjectListIt it( *l ); // iterate over the children
-	TQObject *child;
+	TTQObjectListIt it( *l ); // iterate over the children
+	TTQObject *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, "TQListView")) {
-			TQListView * listview = (TQListView *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQListView"));
-			TQListViewItemIterator it(listview);
-			TQListViewItem *item;
+		if (isDerivedFromByName(o->smoke, className, "TTQListView")) {
+			TTQListView * listview = (TTQListView *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQListView"));
+			TTQListViewItemIterator it(listview);
+			TTQListViewItem *item;
 
 			while ( (item = it.current()) != 0 ) {
 				++it;
@@ -119,9 +119,9 @@ smokeruby_mark(void * p)
 			return;
 		}
 		
-		if (isDerivedFromByName(o->smoke, className, "TQTable")) {
-			TQTable * table = (TQTable *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQTable"));
-			TQTableItem *item;
+		if (isDerivedFromByName(o->smoke, className, "TTQTable")) {
+			TTQTable * table = (TTQTable *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQTable"));
+			TTQTableItem *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, "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 ) {
+		if (isDerivedFromByName(o->smoke, className, "TTQCanvas")) {
+			TTQCanvas * canvas = (TTQCanvas *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQCanvas"));
+    		TTQCanvasItemList list = canvas->allItems();
+    		for ( TTQCanvasItemList::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, "TQCanvasItem")) {
-			TQCanvasItem * item = (TQCanvasItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQCanvasItem"));
-			TQCanvas * canvas = item->canvas();
+		if (isDerivedFromByName(o->smoke, className, "TTQCanvasItem")) {
+			TTQCanvasItem * item = (TTQCanvasItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQCanvasItem"));
+			TTQCanvas * canvas = item->canvas();
 			obj = getPointerObject(canvas);
 			if (obj != Qnil) {
-				if(do_debug & qtdb_gc) qWarning("Marking (%s*)%p -> %p\n", "TQCanvas", canvas, (void*)obj);
+				if(do_debug & qtdb_gc) qWarning("Marking (%s*)%p -> %p\n", "TTQCanvas", canvas, (void*)obj);
 				rb_gc_mark(obj);
 			}
 			return;
 		}
 		
-		if (isDerivedFromByName(o->smoke, className, "TQObject")) {
-			TQObject * qobject = (TQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
+		if (isDerivedFromByName(o->smoke, className, "TTQObject")) {
+			TTQObject * qobject = (TTQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQObject"));
 			mark_qobject_children(qobject);
 			return;
 		}
@@ -184,63 +184,63 @@ smokeruby_free(void * p)
 	unmapPointer(o, o->classId, 0);
 	object_count --;
 	
-	if (	qstrcmp(className, "TQObject") == 0
-			|| qstrcmp(className, "TQListBoxItem") == 0
-			|| qstrcmp(className, "TQStyleSheetItem") == 0
+	if (	qstrcmp(className, "TTQObject") == 0
+			|| qstrcmp(className, "TTQListBoxItem") == 0
+			|| qstrcmp(className, "TTQStyleSheetItem") == 0
 			|| qstrcmp(className, "KCommand") == 0
 			|| qstrcmp(className, "KNamedCommand") == 0
 			|| qstrcmp(className, "KMacroCommand") == 0
 			|| qstrcmp(className, "KAboutData") == 0
 			|| qstrcmp(className, "KCmdLineArgs") == 0
-			|| qstrcmp(className, "TQSqlCursor") == 0 )
+			|| qstrcmp(className, "TTQSqlCursor") == 0 )
 	{
 		// Don't delete instances of these classes for now
 		free(o);
 		return;
-	} else if (isDerivedFromByName(o->smoke, className, "TQLayoutItem")) {
-		TQLayoutItem * item = (TQLayoutItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQLayoutItem"));
+	} else if (isDerivedFromByName(o->smoke, className, "TTQLayoutItem")) {
+		TTQLayoutItem * item = (TTQLayoutItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQLayoutItem"));
 		if (item->layout() != 0 || item->widget() != 0 || item->spacerItem() != 0) {
 			free(o);
 			return;
 		}
-	} else if (qstrcmp(className, "TQIconViewItem") == 0) {
-		TQIconViewItem * item = (TQIconViewItem *) o->ptr;
+	} else if (qstrcmp(className, "TTQIconViewItem") == 0) {
+		TTQIconViewItem * item = (TTQIconViewItem *) o->ptr;
 		if (item->iconView() != 0) {
 			free(o);
 			return;
 		}
-	} else if (qstrcmp(className, "TQCheckListItem") == 0) {
-		TQCheckListItem * item = (TQCheckListItem *) o->ptr;
+	} else if (qstrcmp(className, "TTQCheckListItem") == 0) {
+		TTQCheckListItem * item = (TTQCheckListItem *) o->ptr;
 		if (item->parent() != 0 || item->listView() != 0) {
 			free(o);
 			return;
 		}
-	} else if (qstrcmp(className, "TQListViewItem") == 0) {
-		TQListViewItem * item = (TQListViewItem *) o->ptr;
+	} else if (qstrcmp(className, "TTQListViewItem") == 0) {
+		TTQListViewItem * item = (TTQListViewItem *) o->ptr;
 		if (item->parent() != 0 || item->listView() != 0) {
 			free(o);
 			return;
 		}
-	} else if (isDerivedFromByName(o->smoke, className, "TQTableItem")) {
-		TQTableItem * item = (TQTableItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQTableItem"));
+	} else if (isDerivedFromByName(o->smoke, className, "TTQTableItem")) {
+		TTQTableItem * item = (TTQTableItem *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQTableItem"));
 		if (item->table() != 0) {
 			free(o);
 			return;
 		}
-	} else if (qstrcmp(className, "TQPopupMenu") == 0) {
-		TQPopupMenu * item = (TQPopupMenu *) o->ptr;
+	} else if (qstrcmp(className, "TTQPopupMenu") == 0) {
+		TTQPopupMenu * item = (TTQPopupMenu *) o->ptr;
 		if (item->parentWidget(false) != 0) {
 			free(o);
 			return;
 		}
-	} else if (isDerivedFromByName(o->smoke, className, "TQWidget")) {
-		TQWidget * qwidget = (TQWidget *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQWidget"));
+	} else if (isDerivedFromByName(o->smoke, className, "TTQWidget")) {
+		TTQWidget * qwidget = (TTQWidget *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQWidget"));
 		if (qwidget->parentWidget(true) != 0) {
 			free(o);
 			return;
 		}
-	} else if (isDerivedFromByName(o->smoke, className, "TQObject")) {
-		TQObject * qobject = (TQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TQObject"));
+	} else if (isDerivedFromByName(o->smoke, className, "TTQObject")) {
+		TTQObject * qobject = (TTQObject *) o->smoke->cast(o->ptr, o->classId, o->smoke->idClass("TTQObject"));
 		if (qobject->parent() != 0) {
 			free(o);
 			return;
@@ -268,70 +268,70 @@ smokeruby_free(void * p)
 
 /*
  * Given an approximate classname and a qt instance, try to improve the resolution of the name
- * by using the various Qt rtti mechanisms for QObjects, QEvents and QCanvasItems
+ * by using the various Qt rtti mechanisms for TQObjects, TQEvents and TQCanvasItems
  */
 static const char *
 resolve_classname(Smoke* smoke, int classId, void * ptr)
 {
-	if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQEvent")) {
-		TQEvent * qevent = (TQEvent *) smoke->cast(ptr, classId, smoke->idClass("TQEvent"));
+	if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TTQEvent")) {
+		TTQEvent * qevent = (TTQEvent *) smoke->cast(ptr, classId, smoke->idClass("TTQEvent"));
 		switch (qevent->type()) {
-		case TQEvent::ChildInserted:
-		case TQEvent::ChildRemoved:
-			return "Qt::ChildEvent";
-		case TQEvent::Close:
-			return "Qt::CloseEvent";
-		case TQEvent::ContextMenu:
-			return "Qt::ContextMenuEvent";
-//		case TQEvent::User:
-//			return "Qt::CustomEvent";
-		case TQEvent::DragEnter:
-			return "Qt::DragEnterEvent";
-		case TQEvent::DragLeave:
-			return "Qt::DragLeaveEvent";
-		case TQEvent::DragMove:
-			return "Qt::DragMoveEvent";
-		case TQEvent::DragResponse:
-			return "Qt::DragResponseEvent";
-		case TQEvent::Drop:
-			return "Qt::DropEvent";
-		case TQEvent::FocusIn:
-		case TQEvent::FocusOut:
-			return "Qt::FocusEvent";
-		case TQEvent::Hide:
-			return "Qt::HideEvent";
-		case TQEvent::KeyPress:
-		case TQEvent::KeyRelease:
-			return "Qt::KeyEvent";
-		case TQEvent::IMStart:
-		case TQEvent::IMCompose:
-		case TQEvent::IMEnd:
-			return "Qt::IMEvent";
-		case TQEvent::MouseButtonPress:
-		case TQEvent::MouseButtonRelease:
-		case TQEvent::MouseButtonDblClick:
-		case TQEvent::MouseMove:
-			return "Qt::MouseEvent";
-		case TQEvent::Move:
-			return "Qt::MoveEvent";
-		case TQEvent::Paint:
-			return "Qt::PaintEvent";
-		case TQEvent::Resize:
-			return "Qt::ResizeEvent";
-		case TQEvent::Show:
-			return "Qt::ShowEvent";
-	//	case TQEvent::Tablet:
-	//		 return "Qt::TabletEvent";
-		case TQEvent::Timer:
-			return "Qt::TimerEvent";
-		case TQEvent::Wheel:
-			return "Qt::WheelEvent";
+		case TTQEvent::ChildInserted:
+		case TTQEvent::ChildRemoved:
+			return "TQt::ChildEvent";
+		case TTQEvent::Close:
+			return "TQt::CloseEvent";
+		case TTQEvent::ContextMenu:
+			return "TQt::ContextMenuEvent";
+//		case TTQEvent::User:
+//			return "TQt::CustomEvent";
+		case TTQEvent::DragEnter:
+			return "TQt::DragEnterEvent";
+		case TTQEvent::DragLeave:
+			return "TQt::DragLeaveEvent";
+		case TTQEvent::DragMove:
+			return "TQt::DragMoveEvent";
+		case TTQEvent::DragResponse:
+			return "TQt::DragResponseEvent";
+		case TTQEvent::Drop:
+			return "TQt::DropEvent";
+		case TTQEvent::FocusIn:
+		case TTQEvent::FocusOut:
+			return "TQt::FocusEvent";
+		case TTQEvent::Hide:
+			return "TQt::HideEvent";
+		case TTQEvent::KeyPress:
+		case TTQEvent::KeyRelease:
+			return "TQt::KeyEvent";
+		case TTQEvent::IMStart:
+		case TTQEvent::IMCompose:
+		case TTQEvent::IMEnd:
+			return "TQt::IMEvent";
+		case TTQEvent::MouseButtonPress:
+		case TTQEvent::MouseButtonRelease:
+		case TTQEvent::MouseButtonDblClick:
+		case TTQEvent::MouseMove:
+			return "TQt::MouseEvent";
+		case TTQEvent::Move:
+			return "TQt::MoveEvent";
+		case TTQEvent::Paint:
+			return "TQt::PaintEvent";
+		case TTQEvent::Resize:
+			return "TQt::ResizeEvent";
+		case TTQEvent::Show:
+			return "TQt::ShowEvent";
+	//	case TTQEvent::Tablet:
+	//		 return "TQt::TabletEvent";
+		case TTQEvent::Timer:
+			return "TQt::TimerEvent";
+		case TTQEvent::Wheel:
+			return "TQt::WheelEvent";
 		default:
 			break;
 		}
-	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQObject")) {
-		TQObject * qobject = (TQObject *) smoke->cast(ptr, classId, smoke->idClass("TQObject"));
-		TQMetaObject * meta = qobject->metaObject();
+	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TTQObject")) {
+		TTQObject * qobject = (TTQObject *) smoke->cast(ptr, classId, smoke->idClass("TTQObject"));
+		TTQMetaObject * meta = qobject->metaObject();
 
 		while (meta != 0) {
 			Smoke::Index classId = smoke->idClass(meta->className());
@@ -341,50 +341,50 @@ resolve_classname(Smoke* smoke, int classId, void * ptr)
 
 			meta = meta->superClass();
 		}
-	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQCanvasItem")) {
-		TQCanvasItem * qcanvasitem = (TQCanvasItem *) smoke->cast(ptr, classId, smoke->idClass("TQCanvasItem"));
+	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TTQCanvasItem")) {
+		TTQCanvasItem * qcanvasitem = (TTQCanvasItem *) smoke->cast(ptr, classId, smoke->idClass("TTQCanvasItem"));
 		switch (qcanvasitem->rtti()) {
-		case TQCanvasItem::Rtti_Sprite:
-			return "Qt::CanvasSprite";
-		case TQCanvasItem::Rtti_PolygonalItem:
-			return "Qt::CanvasPolygonalItem";
-		case TQCanvasItem::Rtti_Text:
-			return "Qt::CanvasText";
-		case TQCanvasItem::Rtti_Polygon:
-			return "Qt::CanvasPolygon";
-		case TQCanvasItem::Rtti_Rectangle:
-			return "Qt::CanvasRectangle";
-		case TQCanvasItem::Rtti_Ellipse:
-			return "Qt::CanvasEllipse";
-		case TQCanvasItem::Rtti_Line:
-			return "Qt::CanvasLine";
-		case TQCanvasItem::Rtti_Spline:
-			return "Qt::CanvasSpline";
+		case TTQCanvasItem::Rtti_Sprite:
+			return "TQt::CanvasSprite";
+		case TTQCanvasItem::Rtti_PolygonalItem:
+			return "TQt::CanvasPolygonalItem";
+		case TTQCanvasItem::Rtti_Text:
+			return "TQt::CanvasText";
+		case TTQCanvasItem::Rtti_Polygon:
+			return "TQt::CanvasPolygon";
+		case TTQCanvasItem::Rtti_Rectangle:
+			return "TQt::CanvasRectangle";
+		case TTQCanvasItem::Rtti_Ellipse:
+			return "TQt::CanvasEllipse";
+		case TTQCanvasItem::Rtti_Line:
+			return "TQt::CanvasLine";
+		case TTQCanvasItem::Rtti_Spline:
+			return "TQt::CanvasSpline";
 		default:
 			break;
 		}
-	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQListViewItem")) {
-		TQListViewItem * item = (TQListViewItem *) smoke->cast(ptr, classId, smoke->idClass("TQListViewItem"));
+	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TTQListViewItem")) {
+		TTQListViewItem * item = (TTQListViewItem *) smoke->cast(ptr, classId, smoke->idClass("TTQListViewItem"));
 		switch (item->rtti()) {
 		case 0:
-			return "Qt::ListViewItem";
+			return "TQt::ListViewItem";
 		case 1:
-			return "Qt::CheckListItem";
+			return "TQt::CheckListItem";
 		default:
-			return "Qt::ListViewItem";
+			return "TQt::ListViewItem";
 			break;
 		}
-	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TQTableItem")) {
-		TQTableItem * item = (TQTableItem *) smoke->cast(ptr, classId, smoke->idClass("TQTableItem"));
+	} else if (isDerivedFromByName(smoke, smoke->classes[classId].className, "TTQTableItem")) {
+		TTQTableItem * item = (TTQTableItem *) smoke->cast(ptr, classId, smoke->idClass("TTQTableItem"));
 		switch (item->rtti()) {
 		case 0:
-			return "Qt::TableItem";
+			return "TQt::TableItem";
 		case 1:
-			return "Qt::ComboTableItem";
+			return "TQt::ComboTableItem";
 		case 2:
-			return "Qt::CheckTableItem";
+			return "TQt::CheckTableItem";
 		default:
-			return "Qt::TableItem";
+			return "TQt::TableItem";
 			break;
 		}
 	}
@@ -464,7 +464,7 @@ marshall_basetype(Marshall *m)
 	switch(m->action()) {
 	  case Marshall::FromVALUE:
 		if (TYPE(*(m->var())) == T_OBJECT) {
-			// A Qt::Boolean has been passed as a value
+			// A TQt::Boolean has been passed as a value
 			VALUE temp = rb_funcall(qt_internal_module, rb_intern("get_qboolean"), 1, *(m->var()));
 	    	m->item().s_bool = (temp == Qtrue ? true : false);
 		} else {
@@ -630,7 +630,7 @@ marshall_basetype(Marshall *m)
 	  case Marshall::FromVALUE:
 	  	{
 		if (TYPE(*(m->var())) == T_OBJECT) {
-			// A Qt::Enum is a subclass of Qt::Integer, so 'get_qinteger()' can be called ok
+			// A TQt::Enum is a subclass of TQt::Integer, so 'get_qinteger()' can be called ok
 			VALUE temp = rb_funcall(qt_internal_module, rb_intern("get_qinteger"), 1, *(m->var()));
 	    	m->item().s_enum = (long) NUM2LONG(temp);
 		} else {
@@ -803,41 +803,41 @@ void marshall_ucharP(Marshall *m) {
 }
 
 static const char * KCODE = 0;
-static TQTextCodec *codec = 0;
+static TTQTextCodec *codec = 0;
 
 static void 
 init_codec() {
 	VALUE temp = rb_gv_get("$KCODE");
 	KCODE = StringValuePtr(temp);
 	if (qstrcmp(KCODE, "EUC") == 0) {
-		codec = TQTextCodec::codecForName("eucJP");
+		codec = TTQTextCodec::codecForName("eucJP");
 	} else if (qstrcmp(KCODE, "SJIS") == 0) {
-		codec = TQTextCodec::codecForName("Shift-JIS");
+		codec = TTQTextCodec::codecForName("Shift-JIS");
 	}
 }
 
-TQString* 
+TTQString* 
 qstringFromRString(VALUE rstring) {
 	if (KCODE == 0) {
 		init_codec();
 	}
 	
-	TQString *	s;
+	TTQString *	s;
 	if (qstrcmp(KCODE, "UTF8") == 0)
-		s = new TQString(TQString::fromUtf8(StringValuePtr(rstring), RSTRING(rstring)->len));
+		s = new TTQString(TTQString::fromUtf8(StringValuePtr(rstring), RSTRING(rstring)->len));
 	else if (qstrcmp(KCODE, "EUC") == 0)
-		s = new TQString(codec->toUnicode(StringValuePtr(rstring)));
+		s = new TTQString(codec->toUnicode(StringValuePtr(rstring)));
 	else if (qstrcmp(KCODE, "SJIS") == 0)
-		s = new TQString(codec->toUnicode(StringValuePtr(rstring)));
+		s = new TTQString(codec->toUnicode(StringValuePtr(rstring)));
 	else if(qstrcmp(KCODE, "NONE") == 0)
-		s = new TQString(TQString::fromLatin1(StringValuePtr(rstring)));
+		s = new TTQString(TTQString::fromLatin1(StringValuePtr(rstring)));
 	else
-		s = new TQString(TQString::fromLocal8Bit(StringValuePtr(rstring), RSTRING(rstring)->len));
+		s = new TTQString(TTQString::fromLocal8Bit(StringValuePtr(rstring), RSTRING(rstring)->len));
 	return s;
 }
 
 VALUE 
-rstringFromQString(TQString * s) {
+rstringFromTQString(TTQString * s) {
 	if (KCODE == 0) {
 		init_codec();
 	}
@@ -858,11 +858,11 @@ static void marshall_QString(Marshall *m) {
 	switch(m->action()) {
 	case Marshall::FromVALUE:
 	{
-		TQString* s = 0;
+		TTQString* s = 0;
 		if ( *(m->var()) != Qnil) {
 			s = qstringFromRString(*(m->var()));
 		} else {
-			s = new TQString(TQString::null);
+			s = new TTQString(TTQString::null);
 		}
 		
 		m->item().s_voidp = s;
@@ -870,7 +870,7 @@ static void marshall_QString(Marshall *m) {
 		
 		if (!m->type().isConst() && *(m->var()) != Qnil && s != 0 && !s->isNull()) {
 			rb_str_resize(*(m->var()), 0);
-			VALUE temp = rstringFromQString(s);
+			VALUE temp = rstringFromTQString(s);
 			rb_str_cat2(*(m->var()), StringValuePtr(temp));
 		}
 	    
@@ -881,12 +881,12 @@ static void marshall_QString(Marshall *m) {
 	break;
 	case Marshall::ToVALUE:
 	{
-		TQString *s = (TQString*)m->item().s_voidp;
+		TTQString *s = (TTQString*)m->item().s_voidp;
 		if (s != 0) {
 			if (s->isNull()) {
 				*(m->var()) = Qnil;
 			} else {
-				*(m->var()) = rstringFromQString(s);
+				*(m->var()) = rstringFromTQString(s);
 			}
 			if (m->cleanup() || m->type().isStack()) {
 				delete s;
@@ -902,11 +902,11 @@ static void marshall_QString(Marshall *m) {
     }
 }
 
-// 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.
+// The only way to convert a TTQChar to a TTQString is to
+// pass a TTQChar to a TTQString constructor. However,
+// TQStrings aren't in the QtRuby api, so add this
+// convenience method 'TQt::Char.to_s' to get a ruby
+// string from a TQt::Char.
 VALUE
 qchar_to_s(VALUE self)
 {
@@ -915,9 +915,9 @@ qchar_to_s(VALUE self)
 		return Qnil;
 	}
 
-	TQChar * qchar = (TQChar*) o->ptr;
-	TQString s(*qchar);
-	return rstringFromQString(&s);
+	TTQChar * qchar = (TTQChar*) o->ptr;
+	TTQString s(*qchar);
+	return rstringFromTQString(&s);
 }
 
 #if 0
@@ -938,13 +938,13 @@ static void marshall_QCString(Marshall *m) {
     switch(m->action()) {
       case Marshall::FromVALUE:
 	{
-	    TQCString *s = 0;
+	    TTQCString *s = 0;
 	    VALUE rv = *(m->var());
 	    if (rv == Qnil) {
-		s = new TQCString(); 
+		s = new TTQCString(); 
         } else {
-		// 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); 
+		// Add 1 to the ruby string length to allow for a TTQCString '\0' terminator
+		s = new TTQCString(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:
 	{
-	    TQCString *s = (TQCString*)m->item().s_voidp;
+	    TTQCString *s = (TTQCString*)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
-//                  TQTextCodec* c = TQTextCodec::codecForMib(106); // utf8
+//                  TTQTextCodec* c = TTQTextCodec::codecForMib(106); // utf8
 //                  if(c->heuristicContentMatch(p,len) >= 0)
 //                  #else
 //                  if(is_utf8_string((U8 *)p,len))
@@ -1008,7 +1008,7 @@ static void marshall_QCOORD_array(Marshall *m) {
 		break;
 	    }
 	    int count = RARRAY(av)->len;
-	    QCOORD *coord = new QCOORD[count + 2];
+	    TQCOORD *coord = new TQCOORD[count + 2];
 	    for(long i = 0; i < count; i++) {
 		VALUE svp = rb_ary_entry(av, i);
 		coord[i] = NUM2INT(svp);
@@ -1079,7 +1079,7 @@ static void marshall_intR(Marshall *m) {
 	    VALUE rv = *(m->var());
 		int * i = new int;
 		if (TYPE(rv) == T_OBJECT) {
-			// A Qt::Integer has been passed as an integer value
+			// A TQt::Integer has been passed as an integer value
 			VALUE temp = rb_funcall(qt_internal_module, rb_intern("get_qinteger"), 1, rv);
 			*i = NUM2INT(temp);
 			m->item().s_voidp = i;
@@ -1125,7 +1125,7 @@ static void marshall_boolR(Marshall *m) {
 	    VALUE rv = *(m->var());
 		bool * b = new bool;
 		if (TYPE(rv) == T_OBJECT) {
-			// A Qt::Boolean has been passed as a value
+			// A TQt::Boolean has been passed as a value
 			VALUE temp = rb_funcall(qt_internal_module, rb_intern("get_qboolean"), 1, rv);
 			*b = (temp == Qtrue ? true : false);
 			m->item().s_voidp = b;
@@ -1208,12 +1208,12 @@ void marshall_QStringList(Marshall *m) {
 	    }
 
 	    int count = RARRAY(list)->len;
-	    TQStringList *stringlist = new QStringList;
+	    TTQStringList *stringlist = new TQStringList;
 
 	    for(long i = 0; i < count; i++) {
 		VALUE item = rb_ary_entry(list, i);
 		if(TYPE(item) != T_STRING) {
-		    stringlist->append(TQString());
+		    stringlist->append(TTQString());
 		    continue;
 		}
 		stringlist->append(*(qstringFromRString(item)));
@@ -1225,8 +1225,8 @@ void marshall_QStringList(Marshall *m) {
 		
 		if (stringlist != 0 && !m->type().isConst()) {
 			rb_ary_clear(list);
-			for(TQStringList::Iterator it = stringlist->begin(); it != stringlist->end(); ++it)
-		    	rb_ary_push(list, rstringFromQString(&(*it)));
+			for(TTQStringList::Iterator it = stringlist->begin(); it != stringlist->end(); ++it)
+		    	rb_ary_push(list, rstringFromTQString(&(*it)));
 		}
 			
 		if (m->cleanup())
@@ -1235,15 +1235,15 @@ void marshall_QStringList(Marshall *m) {
       }
       case Marshall::ToVALUE: 
 	{
-	    TQStringList *stringlist = static_cast<TQStringList *>(m->item().s_voidp);
+	    TTQStringList *stringlist = static_cast<TTQStringList *>(m->item().s_voidp);
 	    if(!stringlist) {
 		*(m->var()) = Qnil;
 		break;
 	    }
 
 	    VALUE av = rb_ary_new();
-	    for(TQStringList::Iterator it = stringlist->begin(); it != stringlist->end(); ++it) {
-		VALUE rv = rstringFromQString(&(*it));
+	    for(TTQStringList::Iterator it = stringlist->begin(); it != stringlist->end(); ++it) {
+		VALUE rv = rstringFromTQString(&(*it));
 		rb_ary_push(av, rv);
 	    }
 
@@ -1270,15 +1270,15 @@ void marshall_QStrList(Marshall *m) {
 	    }
 
 	    int count = RARRAY(list)->len;
-	    TQStrList *stringlist = new QStrList;
+	    TTQStrList *stringlist = new TQStrList;
 
 	    for(long i = 0; i < count; i++) {
 		VALUE item = rb_ary_entry(list, i);
 		if(TYPE(item) != T_STRING) {
-		    stringlist->append(TQString());
+		    stringlist->append(TTQString());
 		    continue;
 		}
-		stringlist->append(TQString::fromUtf8(StringValuePtr(item), RSTRING(item)->len));
+		stringlist->append(TTQString::fromUtf8(StringValuePtr(item), RSTRING(item)->len));
 	    }
 
 	    m->item().s_voidp = stringlist;
@@ -1297,7 +1297,7 @@ void marshall_QStrList(Marshall *m) {
       }
       case Marshall::ToVALUE: 
 	{
-	    TQStrList *stringlist = static_cast<TQStrList *>(m->item().s_voidp);
+	    TTQStrList *stringlist = static_cast<TTQStrList *>(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;
-	    TQValueList<int> *valuelist = new TQValueList<int>;
+	    TTQValueList<int> *valuelist = new TTQValueList<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(TQValueListIterator<int> it = valuelist->begin();
+			for(TTQValueListIterator<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:
 	{
-	    TQValueList<int> *valuelist = (TQValueList<int>*)m->item().s_voidp;
+	    TTQValueList<int> *valuelist = (TTQValueList<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(TQValueListIterator<int> it = valuelist->begin();
+	    for(TTQValueListIterator<int> it = valuelist->begin();
 		it != valuelist->end();
 		++it)
 		rb_ary_push(av, INT2NUM(*it));
@@ -1498,7 +1498,7 @@ void marshall_voidP(Marshall *m) {
     }
 }
 
-void marshall_QMapQStringQString(Marshall *m) {
+void marshall_QMapTQStringTQString(Marshall *m) {
     switch(m->action()) {
       case Marshall::FromVALUE:
 	{
@@ -1508,7 +1508,7 @@ void marshall_QMapQStringQString(Marshall *m) {
 		break;
 	    }
 		
-		TQMap<TQString,TQString> * map = new TQMap<TQString,TQString>;
+		TTQMap<TTQString,TTQString> * map = new TTQMap<TTQString,TTQString>;
 		
 		// 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)[TQString(StringValuePtr(key))] = TQString(StringValuePtr(value));
+			(*map)[TTQString(StringValuePtr(key))] = TTQString(StringValuePtr(value));
 		}
 	    
 		m->item().s_voidp = map;
@@ -1528,7 +1528,7 @@ void marshall_QMapQStringQString(Marshall *m) {
 	break;
       case Marshall::ToVALUE:
 	{
-	    TQMap<TQString,TQString> *map = (TQMap<TQString,TQString>*)m->item().s_voidp;
+	    TTQMap<TTQString,TTQString> *map = (TTQMap<TTQString,TTQString>*)m->item().s_voidp;
 	    if(!map) {
 		*(m->var()) = Qnil;
 		break;
@@ -1536,9 +1536,9 @@ void marshall_QMapQStringQString(Marshall *m) {
 		
 	    VALUE hv = rb_hash_new();
 			
-		TQMap<TQString,TQString>::Iterator it;
+		TTQMap<TTQString,TTQString>::Iterator it;
 		for (it = map->begin(); it != map->end(); ++it) {
-			rb_hash_aset(hv, rstringFromQString((TQString*)&(it.key())), rstringFromQString((TQString*) &(it.data())));
+			rb_hash_aset(hv, rstringFromTQString((TTQString*)&(it.key())), rstringFromTQString((TTQString*) &(it.data())));
         }
 		
 		*(m->var()) = hv;
@@ -1554,7 +1554,7 @@ void marshall_QMapQStringQString(Marshall *m) {
     }
 }
 
-void marshall_QMapQStringQVariant(Marshall *m) {
+void marshall_QMapTQStringTQVariant(Marshall *m) {
     switch(m->action()) {
       case Marshall::FromVALUE:
 	{
@@ -1564,7 +1564,7 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 		break;
 	    }
 		
-		TQMap<TQString,TQVariant> * map = new TQMap<TQString,TQVariant>;
+		TTQMap<TTQString,TTQVariant> * map = new TTQMap<TTQString,TTQVariant>;
 		
 		// Convert the ruby hash to an array of key/value arrays
 		VALUE temp = rb_funcall(hash, rb_intern("to_a"), 0);
@@ -1574,9 +1574,9 @@ 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("TQVariant")) {
-				// If the value isn't a Qt::Variant, then try and construct
-				// a Qt::Variant from it
+			if (!o || !o->ptr || o->classId != o->smoke->idClass("TTQVariant")) {
+				// If the value isn't a TQt::Variant, then try and construct
+				// a TQt::Variant from it
 				value = rb_funcall(qvariant_class, rb_intern("new"), 1, value);
 				if (value == Qnil) {
 					continue;
@@ -1585,9 +1585,9 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 			}
 
 			void * ptr = o->ptr;
-			ptr = o->smoke->cast(ptr, o->classId, o->smoke->idClass("TQVariant"));
+			ptr = o->smoke->cast(ptr, o->classId, o->smoke->idClass("TTQVariant"));
 			
-			(*map)[TQString(StringValuePtr(key))] = (TQVariant)*(TQVariant*)ptr;
+			(*map)[TTQString(StringValuePtr(key))] = (TTQVariant)*(TTQVariant*)ptr;
 		}
 	    
 		m->item().s_voidp = map;
@@ -1599,7 +1599,7 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 	break;
       case Marshall::ToVALUE:
 	{
-	    TQMap<TQString,TQVariant> *map = (TQMap<TQString,TQVariant>*)m->item().s_voidp;
+	    TTQMap<TTQString,TTQVariant> *map = (TTQMap<TTQString,TTQVariant>*)m->item().s_voidp;
 	    if(!map) {
 		*(m->var()) = Qnil;
 		break;
@@ -1607,21 +1607,21 @@ void marshall_QMapQStringQVariant(Marshall *m) {
 		
 	    VALUE hv = rb_hash_new();
 			
-		TQMap<TQString,TQVariant>::Iterator it;
+		TTQMap<TTQString,TTQVariant>::Iterator it;
 		for (it = map->begin(); it != map->end(); ++it) {
-			void *p = new TQVariant(it.data());
+			void *p = new TTQVariant(it.data());
 			VALUE obj = getPointerObject(p);
 				
 			if (obj == Qnil) {
 				smokeruby_object  * o = ALLOC(smokeruby_object);
-				o->classId = m->smoke()->idClass("TQVariant");
+				o->classId = m->smoke()->idClass("TTQVariant");
 				o->smoke = m->smoke();
 				o->ptr = p;
 				o->allocated = true;
-				obj = set_obj_info("Qt::Variant", o);
+				obj = set_obj_info("TQt::Variant", o);
 			}
 			
-			rb_hash_aset(hv, rstringFromQString((TQString*)&(it.key())), obj);
+			rb_hash_aset(hv, rstringFromTQString((TTQString*)&(it.key())), obj);
         }
 		
 		*(m->var()) = hv;
@@ -1644,7 +1644,7 @@ void marshall_QUObject(Marshall *m) {
 	    VALUE array = *(m->var());
 	    if (array != Qnil && TYPE(array) == T_ARRAY) {
 		VALUE rv = rb_ary_entry(array, 0);
-		Data_Get_Struct(rv, QUObject, m->item().s_voidp);
+		Data_Get_Struct(rv, TQUObject, m->item().s_voidp);
 	    } else {
 		m->item().s_voidp = 0;
 		}
@@ -1674,7 +1674,7 @@ void marshall_QRgb_array(Marshall *m) {
 		break;
 	    }
 	    int count = RARRAY(list)->len;
-	    QRgb *rgb = new QRgb[count + 2];
+	    TQRgb *rgb = new TQRgb[count + 2];
 	    long i;
 	    for(i = 0; i < count; i++) {
 		VALUE item = rb_ary_entry(list, i);
@@ -1722,7 +1722,7 @@ void marshall_QPairintint(Marshall *m) {
 			int1 = NUM2INT(item);
 		}
 		
-		QPair<int,int> * qpair = new QPair<int,int>(int0,int1);
+		TQPair<int,int> * qpair = new TQPair<int,int>(int0,int1);
 	    m->item().s_voidp = qpair;
 	    m->next();
 	    if(m->cleanup())
@@ -1749,16 +1749,16 @@ void marshall_QPairintint(Marshall *m) {
 #include <tqtabbar.h>
 
 #if QT_VERSION >= 0x030200
-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> )
+DEF_LIST_MARSHALLER( TQPtrListTQNetworkOperation, TTQPtrList<TTQNetworkOperation>, TTQNetworkOperation, TTQPtrListStdIterator<TTQNetworkOperation> )
+DEF_LIST_MARSHALLER( TQPtrListTQToolBar, TTQPtrList<TTQToolBar>, TTQToolBar, TTQPtrListStdIterator<TTQToolBar> )
+DEF_LIST_MARSHALLER( TQPtrListTQTab, TTQPtrList<TTQTab>, TTQTab, TTQPtrListStdIterator<TTQTab> )
+DEF_LIST_MARSHALLER( TQPtrListTQDockWindow, TTQPtrList<TTQDockWindow>, TTQDockWindow, TTQPtrListStdIterator<TTQDockWindow> )
+DEF_LIST_MARSHALLER( TQFileInfoList, TQFileInfoList, TTQFileInfo, TQFileInfoList::Iterator )
+DEF_LIST_MARSHALLER( TTQObjectList, TTQObjectList, TTQObject, TTQPtrListStdIterator<TTQObject> )
+DEF_LIST_MARSHALLER( TTQWidgetList, TTQWidgetList, TTQWidget, TTQPtrListStdIterator<TTQWidget> )
 #endif
 
-DEF_LIST_MARSHALLER( TQCanvasItemList, TQCanvasItemList, TQCanvasItem, TQValueListIterator<TQCanvasItem*> )
+DEF_LIST_MARSHALLER( TTQCanvasItemList, TTQCanvasItemList, TTQCanvasItem, TTQValueListIterator<TTQCanvasItem*> )
 
 template <class Item, class ItemList, class ItemListIterator, const char *ItemSTR >
 void marshall_ValueItemList(Marshall *m) {
@@ -1778,12 +1778,12 @@ void marshall_ValueItemList(Marshall *m) {
                 // TODO do type checking!
 		smokeruby_object *o = value_obj_info(item);
 
-		// Special case for the TQValueList<TQVariant> type
-		if (	qstrcmp(ItemSTR, "TQVariant") == 0 
-				&& (!o || !o->ptr || o->classId != o->smoke->idClass("TQVariant")) ) 
+		// Special case for the TTQValueList<TTQVariant> type
+		if (	qstrcmp(ItemSTR, "TTQVariant") == 0 
+				&& (!o || !o->ptr || o->classId != o->smoke->idClass("TTQVariant")) ) 
 		{
-			// If the value isn't a Qt::Variant, then try and construct
-			// a Qt::Variant from it
+			// If the value isn't a TQt::Variant, then try and construct
+			// a TQt::Variant from it
 			item = rb_funcall(qvariant_class, rb_intern("new"), 1, item);
 			if (item == Qnil) {
 				continue;
@@ -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, 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 )
+DEF_VALUELIST_MARSHALLER( TQVariantList, TTQValueList<TTQVariant>, TTQVariant, TTQValueList<TTQVariant>::Iterator )
+DEF_VALUELIST_MARSHALLER( TQPixmapList, TTQValueList<TTQPixmap>, TTQPixmap, TTQValueList<TTQPixmap>::Iterator )
+DEF_VALUELIST_MARSHALLER( TQIconDragItemList, TTQValueList<TTQIconDragItem>, TTQIconDragItem, TTQValueList<TTQIconDragItem>::Iterator )
+DEF_VALUELIST_MARSHALLER( TQImageTextKeyLangList, TTQValueList<TTQImageTextKeyLang>, TTQImageTextKeyLang, TTQValueList<TTQImageTextKeyLang>::Iterator )
+DEF_VALUELIST_MARSHALLER( TQUrlInfoList, TTQValueList<TTQUrlInfo>, TTQUrlInfo, TTQValueList<TTQUrlInfo>::Iterator )
+DEF_VALUELIST_MARSHALLER( TQTranslatorMessageList, TTQValueList<TQTranslatorMessage>, TQTranslatorMessage, TTQValueList<TQTranslatorMessage>::Iterator )
+DEF_VALUELIST_MARSHALLER( TQHostAddressList, TTQValueList<TTQHostAddress>, TTQHostAddress, TTQValueList<TTQHostAddress>::Iterator )
 
 TypeHandler Qt_handlers[] = {
-    { "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 },
+    { "TTQString", marshall_QString },
+    { "TTQString&", marshall_QString },
+    { "TTQString*", marshall_QString },
+    { "TTQCString", marshall_QCString },
+    { "TTQCString&", marshall_QCString },
+    { "TTQCString*", marshall_QCString },
+    { "TTQStringList", marshall_QStringList },
+    { "TTQStringList&", marshall_QStringList },
+    { "TTQStringList*", marshall_QStringList },
+    { "TTQStrList", marshall_QStrList },
+    { "TTQStrList&", marshall_QStrList },
+    { "TTQStrList*", marshall_QStrList },
     { "long long int", marshall_longlong },
     { "long long int&", marshall_longlong },
     { "Q_INT64", marshall_longlong },
@@ -1914,44 +1914,44 @@ TypeHandler Qt_handlers[] = {
     { "char*", marshall_charP },
     { "char**", marshall_charP_array },
     { "uchar*", marshall_ucharP },
-    { "QRgb*", marshall_QRgb_array },
-    { "QPair<int,int>&", marshall_QPairintint },
-    { "QUObject*", marshall_QUObject },
-    { "const QCOORD*", marshall_QCOORD_array },
+    { "TQRgb*", marshall_QRgb_array },
+    { "TQPair<int,int>&", marshall_QPairintint },
+    { "TQUObject*", marshall_QUObject },
+    { "const TQCOORD*", marshall_QCOORD_array },
     { "void", marshall_void },
-    { "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 },
+    { "TTQValueList<int>", marshall_QValueListInt },
+    { "TTQValueList<int>&", marshall_QValueListInt },
+    { "TTQValueList<TTQVariant>", marshall_QVariantList },
+    { "TTQValueList<TTQVariant>&", marshall_QVariantList },
+    { "TTQValueList<TTQPixmap>", marshall_QPixmapList },
+    { "TTQValueList<TTQIconDragItem>&", marshall_QIconDragItemList },
+    { "TTQValueList<TTQImageTextKeyLang>", marshall_QImageTextKeyLangList },
+    { "TTQValueList<TTQUrlInfo>&", marshall_QUrlInfoList },
+    { "TTQValueList<TQTranslatorMessage>", marshall_QTranslatorMessageList },
+    { "TTQValueList<TTQHostAddress>", marshall_QHostAddressList },
+    { "TTQCanvasItemList", marshall_TTQCanvasItemList },
+    { "TTQMap<TTQString,TTQString>", marshall_QMapTQStringTQString },
+    { "TTQMap<TTQString,TTQString>&", marshall_QMapTQStringTQString },
+    { "TTQMap<TTQString,TTQVariant>", marshall_QMapTQStringTQVariant },
+    { "TTQMap<TTQString,TTQVariant>&", marshall_QMapTQStringTQVariant },
 #if QT_VERSION >= 0x030200
-    { "TQWidgetList", marshall_TQWidgetList },
-    { "TQWidgetList*", marshall_TQWidgetList },
-    { "TQWidgetList&", marshall_TQWidgetList },
-    { "TQObjectList*", marshall_TQObjectList },
-    { "TQObjectList&", marshall_TQObjectList },
-    { "QFileInfoList*", marshall_QFileInfoList },
-    { "TQPtrList<TQToolBar>", marshall_QPtrListQToolBar },
-    { "TQPtrList<TQTab>*", marshall_QPtrListQTab },
-    { "TQPtrList<TQDockWindow>", marshall_QPtrListQDockWindow },
-    { "TQPtrList<TQDockWindow>*", marshall_QPtrListQDockWindow },
-    { "TQPtrList<TQNetworkOperation>", marshall_QPtrListQNetworkOperation },
-    { "TQPtrList<TQNetworkOperation>&", marshall_QPtrListQNetworkOperation },
+    { "TTQWidgetList", marshall_TTQWidgetList },
+    { "TTQWidgetList*", marshall_TTQWidgetList },
+    { "TTQWidgetList&", marshall_TTQWidgetList },
+    { "TTQObjectList*", marshall_TTQObjectList },
+    { "TTQObjectList&", marshall_TTQObjectList },
+    { "TQFileInfoList*", marshall_QFileInfoList },
+    { "TTQPtrList<TTQToolBar>", marshall_QPtrListTQToolBar },
+    { "TTQPtrList<TTQTab>*", marshall_QPtrListTQTab },
+    { "TTQPtrList<TTQDockWindow>", marshall_QPtrListTQDockWindow },
+    { "TTQPtrList<TTQDockWindow>*", marshall_QPtrListTQDockWindow },
+    { "TTQPtrList<TTQNetworkOperation>", marshall_QPtrListTQNetworkOperation },
+    { "TTQPtrList<TTQNetworkOperation>&", marshall_QPtrListTQNetworkOperation },
 #endif
     { 0, 0 }
 };
 
-TQAsciiDict<TypeHandler> type_handlers(199);
+TTQAsciiDict<TypeHandler> type_handlers(199);
 
 void install_handlers(TypeHandler *h) {
     while(h->name) {