Revert "Rename a number of old tq methods that are no longer tq specific"

This reverts commit 5c194e6e7059ddcc96b0e0166ce6157c35fc183e.

4 files changed, 164 insertions, 164 deletions

diff --git a/styles/dotnet/dotnet.cpp b/styles/dotnet/dotnet.cpp
index 9c42ccb4..df40c1a5 100644
--- a/styles/dotnet/dotnet.cpp
+++ b/styles/dotnet/dotnet.cpp
@@ -211,7 +211,7 @@ void dotNETstyle::renderButton(TQPainter *p,
 			p->setBrush(TQBrush::NoBrush);
 			p->drawConvexPolygon(outline);
 			p->setPen(g.button().light());
-			p->drawPolyline(outline, 0, 3);
+			p->tqdrawPolyline(outline, 0, 3);
 		} else {
 			p->setPen(g.button().dark());
 			p->setBrush(g.button());
@@ -335,13 +335,13 @@ void dotNETstyle::renderPanel(TQPainter *p,
 			p->setPen(g.background().dark());
 			p->drawConvexPolygon(TQPointArray(4, corners));
 			p->setPen(g.background().light());
-			p->drawPolyline(TQPointArray(4, corners), 0, 3);
+			p->tqdrawPolyline(TQPointArray(4, corners), 0, 3);
 		} else {
 			const TQCOORD corners[] = { x, y2, x, y, x2, y, x2, y2 };
 			p->setPen(g.background().dark());
 			p->drawPolygon(TQPointArray(4, corners));
 			p->setPen(g.background().light());
-			p->drawPolyline(TQPointArray(4, corners), 0, 3);
+			p->tqdrawPolyline(TQPointArray(4, corners), 0, 3);
 		}
 	}
 
@@ -353,13 +353,13 @@ void dotNETstyle::renderPanel(TQPainter *p,
 				p->setPen(g.background().dark());
 				p->drawConvexPolygon(TQPointArray(4, corners));
 				p->setPen(g.background().light());
-				p->drawPolyline(TQPointArray(4, corners), 0, 3);
+				p->tqdrawPolyline(TQPointArray(4, corners), 0, 3);
 			} else {
 				const TQCOORD corners[] = { x, y2, x, y, x2, y, x2, y2 };
 				p->setPen(g.background().dark());
 				p->drawPolygon(TQPointArray(4, corners));
 				p->setPen(g.background().light());
-				p->drawPolyline(TQPointArray(4, corners), 0, 3);
+				p->tqdrawPolyline(TQPointArray(4, corners), 0, 3);
 			}
 		}
 	}
@@ -719,8 +719,8 @@ void dotNETstyle::tqdrawPrimitive(TQ_PrimitiveElement pe,
 			p->save();
 
 			if (flags & Style_Down) {
-				p->translate(pixelMetric(PM_ButtonShiftHorizontal),
-				             pixelMetric(PM_ButtonShiftVertical));
+				p->translate(tqpixelMetric(PM_ButtonShiftHorizontal),
+				             tqpixelMetric(PM_ButtonShiftVertical));
 			}
 
 			if (flags & Style_Enabled) {
@@ -757,7 +757,7 @@ void dotNETstyle::tqdrawPrimitive(TQ_PrimitiveElement pe,
 }
 
 
-void dotNETstyle::drawControl(TQ_ControlElement element,
+void dotNETstyle::tqdrawControl(TQ_ControlElement element,
                               TQPainter *p,
                               const TQWidget *widget,
                               const TQRect &r,
@@ -827,7 +827,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 					p->setPen(cg.highlight().dark(120));
 					p->drawConvexPolygon(corners);
 					p->setPen(cg.highlight().light(120));
-					p->drawPolyline(corners, 0, 3);
+					p->tqdrawPolyline(corners, 0, 3);
 					if (roundedCorners) {
 						p->setPen(cg.background().dark());
 						p->drawPoints(corners);
@@ -857,7 +857,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 		case CE_TabBarTab: {
 			const TQTabBar *tb = (const TQTabBar *) widget;
 			bool cornerWidget = false;
-			TQTabBar::Shape tbs = tb->shape();
+			TQTabBar::Shape tbs = tb->tqshape();
 			bool selected = flags & Style_Selected;
 			int x, x2, y, y2, w, h;
 			r.rect(&x, &y, &w, &h);
@@ -878,7 +878,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 						p->setPen(cg.background().dark());
 						if (selected) {
 							const TQCOORD oCorners[] = { x, y2, x, y, x2, y, x2, y2 };
-							p->drawPolyline(TQPointArray(4, oCorners));
+							p->tqdrawPolyline(TQPointArray(4, oCorners));
 
 							if (roundedCorners) {
 								p->setPen(cg.background());
@@ -898,7 +898,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 							p->fillRect(r2, TQColor(cg.mid().light(105)));
 
 							const TQCOORD oCorners[] = { x, y2, x, y + 2, x2, y + 2, x2, y2 };
-							p->drawPolyline(TQPointArray(4, oCorners));
+							p->tqdrawPolyline(TQPointArray(4, oCorners));
 
 							p->setPen(cg.background());
 
@@ -952,7 +952,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 						p->setPen(cg.background().dark());
 						if (selected) {
 							const TQCOORD oCorners[] = { x, y + 1, x, y2, x2, y2, x2, y + 1 };
-							p->drawPolyline(TQPointArray(4, oCorners));
+							p->tqdrawPolyline(TQPointArray(4, oCorners));
 
 							p->setPen(cg.background().dark(115));
 							p->drawLine(x + 1, y + h - 2, x + w - 2, y + h - 2);
@@ -967,7 +967,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 							TQRect r2(x + 1, y + 2, w - 2, h - 5);
 							p->fillRect(r2, cg.mid().light(105));
 
-							p->drawPolyline(TQPointArray(4, oCorners));
+							p->tqdrawPolyline(TQPointArray(4, oCorners));
 
 							p->setPen(cg.mid().dark(115));
 						/*	Inner right border */
@@ -1019,7 +1019,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 				}
 
 				default:
-					winstyle->drawControl(element, p, widget, r, cg, flags, opt);
+					winstyle->tqdrawControl(element, p, widget, r, cg, flags, opt);
 			}
 
 			break;
@@ -1039,8 +1039,8 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 			p->setPen(flags & Style_Enabled ? TQColor(cg.foreground()) : TQColor(cg.mid().dark()));
 
 			if (!flags & Style_Selected) {
-				p->translate(pixelMetric(PM_ButtonShiftHorizontal),
-				             pixelMetric(PM_ButtonShiftVertical));
+				p->translate(tqpixelMetric(PM_ButtonShiftHorizontal),
+				             tqpixelMetric(PM_ButtonShiftVertical));
 			}
 
 			p->drawText(r, text_flags, opt.tab()->text());
@@ -1057,7 +1057,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 			TQRect br = r;
 			bool btnDefault = button->isDefault();
 
-			static int di = pixelMetric(PM_ButtonDefaultIndicator);
+			static int di = tqpixelMetric(PM_ButtonDefaultIndicator);
 			br.addCoords(di, di, -di, -di);
 
 			if (btnDefault) {
@@ -1076,8 +1076,8 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 			TQRect ur(r);
 
 			if (flags & Style_Down) {
-				p->translate(pixelMetric(PM_ButtonShiftHorizontal),
-				             pixelMetric(PM_ButtonShiftVertical));
+				p->translate(tqpixelMetric(PM_ButtonShiftHorizontal),
+				             tqpixelMetric(PM_ButtonShiftVertical));
 			}
 
 			if (!pb->text().isEmpty() && (flags & Style_ButtonDefault)) {
@@ -1120,13 +1120,13 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 			}
 
 			if (!pb->text().isEmpty()) {
-				p->setPen(enabled ? cg.foreground() : pb->palette().disabled().buttonText());
+				p->setPen(enabled ? cg.foreground() : pb->tqpalette().disabled().buttonText());
 				p->drawText(ur, text_flags, pb->text());
 			}
 
 			if ( flags & Style_HasFocus )
 				tqdrawPrimitive( PE_FocusRect, p,
-				               visualRect( subRect( SR_PushButtonFocusRect, widget ), widget ),
+				               tqvisualRect( subRect( SR_PushButtonFocusRect, widget ), widget ),
 				               cg, flags );
 
 			break;
@@ -1257,7 +1257,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 				pmr.moveCenter(cr.center());
 
 				if (TQApplication::reverseLayout())
-					pmr = visualRect( pmr, r );
+					pmr = tqvisualRect( pmr, r );
 
 				p->setPen(cg.highlightedText());
 				p->drawPixmap(pmr.topLeft(), pixmap);
@@ -1295,7 +1295,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 
 						TQRect rr = TQRect(xp, y+m, tab, h-(2*m));
 						if (TQApplication::reverseLayout())
-							rr = visualRect(rr, r);
+							rr = tqvisualRect(rr, r);
 
 						if (useTextShadows) {
 							TQPen op = p->pen();
@@ -1310,7 +1310,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 
 					TQRect rr = TQRect(xpos, y+m, w-xm-tab+1, h-(2*m));
 					if (TQApplication::reverseLayout()) {
-						rr = visualRect(rr, r);
+						rr = tqvisualRect(rr, r);
 						text_flags |= AlignRight;
 					}
 
@@ -1335,7 +1335,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 			}
 
 			if (mi->popup()) {
-				int dim = pixelMetric(PM_MenuButtonIndicator);
+				int dim = tqpixelMetric(PM_MenuButtonIndicator);
 
 				xpos = x+w - arrowHMargin - 2*itemFrame - dim;
 
@@ -1347,7 +1347,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 
 				TQRect rr = TQRect(xpos, y + h/2 - dim/2, dim, dim);
 				if (TQApplication::reverseLayout())
-					rr = visualRect( rr, r );
+					rr = tqvisualRect( rr, r );
 				tqdrawPrimitive((TQApplication::reverseLayout() ? PE_ArrowLeft : PE_ArrowRight), p, rr, cg, Style_Enabled);
 			}
 
@@ -1364,7 +1364,7 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 
 					TQRect rr = TQRect( xp + 6, y + 6, 16, h - 6 );
 					if (TQApplication::reverseLayout())
-						rr = visualRect( rr, r );
+						rr = tqvisualRect( rr, r );
 
 					tqdrawPrimitive(PE_CheckMark, p, rr, cg, cflags);
 				}
@@ -1380,11 +1380,11 @@ void dotNETstyle::drawControl(TQ_ControlElement element,
 			p->fillRect(r, cg.button());
 			break;
 		default:
-			winstyle->drawControl(element, p, widget, r, cg, flags, opt);
+			winstyle->tqdrawControl(element, p, widget, r, cg, flags, opt);
 	}
 }
 
-void dotNETstyle::drawControlMask(TQ_ControlElement element,
+void dotNETstyle::tqdrawControlMask(TQ_ControlElement element,
                                   TQPainter *p,
                                   const TQWidget *w,
                                   const TQRect &r,
@@ -1407,12 +1407,12 @@ void dotNETstyle::drawControlMask(TQ_ControlElement element,
 		}
 
 		default: {
-			KStyle::drawControlMask (element, p, w, r, opt);
+			KStyle::tqdrawControlMask (element, p, w, r, opt);
 		}
 	}
 }
 
-void dotNETstyle::drawComplexControlMask(ComplexControl c,
+void dotNETstyle::tqdrawComplexControlMask(ComplexControl c,
                                          TQPainter *p,
                                          const TQWidget *w,
                                          const TQRect &r,
@@ -1434,12 +1434,12 @@ void dotNETstyle::drawComplexControlMask(ComplexControl c,
 			break;
 		}
 		default: {
-			KStyle::drawComplexControlMask (c, p, w, r, o);
+			KStyle::tqdrawComplexControlMask (c, p, w, r, o);
 		}
 	}
 }
 
-void dotNETstyle::drawComplexControl(ComplexControl control,
+void dotNETstyle::tqdrawComplexControl(ComplexControl control,
                                      TQPainter *p,
                                      const TQWidget *widget,
                                      const TQRect &r,
@@ -1489,13 +1489,13 @@ void dotNETstyle::drawComplexControl(ComplexControl control,
 			}
 
 			TQRect hr = (pseudo3D ? TQRect(w - handle_offset - 1, y, handle_width + 2, h) : TQRect(w - handle_offset - 1, y + 1, handle_width + 2, h - 1));
-			if (TQApplication::reverseLayout()) { hr = visualRect(hr, r); }
+			if (TQApplication::reverseLayout()) { hr = tqvisualRect(hr, r); }
 
 			p->drawRect(hr);
 			p->setBrush(NoBrush);
 			TQRect rr = (pseudo3D ? TQRect(x + 1, y + 1, w - 2, h - 2) : TQRect(x + 1, y + 1, w - 1, h - 1));
 
-			if (TQApplication::reverseLayout()) { rr = visualRect( rr, r ); }
+			if (TQApplication::reverseLayout()) { rr = tqvisualRect( rr, r ); }
 
 			if (flags & Style_HasFocus || cg.highlight() == cg.midlight() ||
 			    (cb->listBox() && cb->listBox()->isVisible())) {
@@ -1516,10 +1516,10 @@ void dotNETstyle::drawComplexControl(ComplexControl control,
 				ca.setPoint(1, hr.bottomRight());
 				ca.setPoint(2, hr.bottomLeft());
 				p->setPen(test.dark(120));
-				p->drawPolyline(ca);
+				p->tqdrawPolyline(ca);
 				p->setPen(test.light(120));
 				ca.setPoint(1, hr.topLeft());
-				p->drawPolyline(ca);
+				p->tqdrawPolyline(ca);
 				p->restore();
 			}
 
@@ -1544,7 +1544,7 @@ void dotNETstyle::drawComplexControl(ComplexControl control,
 			TQRect pmr(0, 0, 7, 4);
 			pmr.moveCenter(cr.center());
 			if (TQApplication::reverseLayout()) {
-				pmr = visualRect( pmr, r );
+				pmr = tqvisualRect( pmr, r );
 			}
 
 			p->drawPixmap(pmr.topLeft(), downArrow);
@@ -1608,7 +1608,7 @@ void dotNETstyle::drawComplexControl(ComplexControl control,
 			TQ_PrimitiveElement pe;
 
 			TQRect swf = querySubControlMetrics(control, sw, SC_SpinWidgetFrame);
-			swf = visualRect( swf, sw );
+			swf = tqvisualRect( swf, sw );
 
 			if (controls & SC_SpinWidgetFrame) {
 			// Don't draw the WindowsStyle thick frame.
@@ -1629,7 +1629,7 @@ void dotNETstyle::drawComplexControl(ComplexControl control,
 					pe = PE_SpinWidgetUp;
 
 				TQRect re = sw->upRect();
-				TQColorGroup ucg = sw->isUpEnabled() ? cg : sw->palette().disabled();
+				TQColorGroup ucg = sw->isUpEnabled() ? cg : sw->tqpalette().disabled();
 				p->fillRect(re.x() + 1, re.y() + 1, re.width() - 2, re.height() - 1, flags & Style_Raised ? ucg.background() : ucg.highlight());
 				if (pseudo3D) {
 					const TQCOORD corners[] = { re.x(), re.bottom(), re.x(), re.y() + 1, re.x() + 1, re.y(), re.right() - 1, re.y(), re.right(), re.y() + 1, re.right(), re.bottom() };
@@ -1661,7 +1661,7 @@ void dotNETstyle::drawComplexControl(ComplexControl control,
 					pe = PE_SpinWidgetDown;
 
 				TQRect re = sw->downRect();
-				TQColorGroup dcg = sw->isDownEnabled() ? cg : sw->palette().disabled();
+				TQColorGroup dcg = sw->isDownEnabled() ? cg : sw->tqpalette().disabled();
 				p->fillRect(re.x() + 1, re.y(), re.width() - 2, re.height() - 1, flags & Style_Raised ? dcg.background() : dcg.highlight());
 				if (pseudo3D) {
 					const TQCOORD corners[] = {
@@ -1690,7 +1690,7 @@ void dotNETstyle::drawComplexControl(ComplexControl control,
 		}
 
 		default:
-			KStyle::drawComplexControl(control, p, widget,
+			KStyle::tqdrawComplexControl(control, p, widget,
 			                           r, cg, flags, controls,
 			                           active, opt);
 			break;
@@ -1708,7 +1708,7 @@ TQRect dotNETstyle::subRect(SubRect r, const TQWidget *widget) const
 
 		case SR_PushButtonFocusRect: {
 			TQRect rect = widget->rect();
-			int margin = pixelMetric(PM_ButtonDefaultIndicator, widget) + pixelMetric(PM_DefaultFrameWidth, widget) + 2;
+			int margin = tqpixelMetric(PM_ButtonDefaultIndicator, widget) + tqpixelMetric(PM_DefaultFrameWidth, widget) + 2;
 
 			rect.addCoords(margin, margin, -margin, -margin);
 			return rect;
@@ -1749,7 +1749,7 @@ TQRect dotNETstyle::querySubControlMetrics(ComplexControl control,
 		}
 
 		case CC_SpinWidget: {
-			int fw = pixelMetric(PM_SpinBoxFrameWidth, widget);
+			int fw = tqpixelMetric(PM_SpinBoxFrameWidth, widget);
 			TQSize bs;
 			bs.setHeight(TQMAX(8, widget->height()/2));
 			bs.setWidth(TQMIN(bs.height() * 8 / 5, widget->width() / 4));
@@ -1787,15 +1787,15 @@ TQRect dotNETstyle::querySubControlMetrics(ComplexControl control,
 	return KStyle::querySubControlMetrics(control, widget, subcontrol, opt);
 }
 
-int dotNETstyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
+int dotNETstyle::tqpixelMetric(PixelMetric m, const TQWidget *widget) const
 {
 	switch(m) {
 	//	TABS
 	//	----
 		case PM_TabBarTabVSpace: {
 			const TQTabBar * tb = (const TQTabBar *) widget;
-			if (tb->shape() == TQTabBar::RoundedAbove ||
-			    tb->shape() == TQTabBar::RoundedBelow)
+			if (tb->tqshape() == TQTabBar::RoundedAbove ||
+			    tb->tqshape() == TQTabBar::RoundedBelow)
 				return 12;
 			else
 				return 0;
@@ -1803,8 +1803,8 @@ int dotNETstyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 
 		case PM_TabBarTabOverlap: {
 			const TQTabBar* tb = (const TQTabBar*)widget;
-			if (tb->shape() != TQTabBar::RoundedAbove &&
-			    tb->shape() != TQTabBar::RoundedBelow)
+			if (tb->tqshape() != TQTabBar::RoundedAbove &&
+			    tb->tqshape() != TQTabBar::RoundedBelow)
 				return 3;                   // Leave standard size alone
 			else
 				return 1;                   // Change size for our tabs only
@@ -1878,7 +1878,7 @@ int dotNETstyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 		}
 
 		default:
-			return KStyle::pixelMetric(m, widget);
+			return KStyle::tqpixelMetric(m, widget);
 	}
 }
 
@@ -1901,8 +1901,8 @@ TQSize dotNETstyle::tqsizeFromContents(ContentsType t,
 			bool checkable = popup->isCheckable();
 
 			if (mi->custom()) {
-				w = mi->custom()->sizeHint().width();
-				h = mi->custom()->sizeHint().height();
+				w = mi->custom()->tqsizeHint().width();
+				h = mi->custom()->tqsizeHint().height();
 			} else if (mi->widget()) {
 			// don't change the size in this case.
 			} else if (mi->isSeparator()) {
@@ -1945,8 +1945,8 @@ TQSize dotNETstyle::tqsizeFromContents(ContentsType t,
 			const TQPushButton* button = (const TQPushButton*) widget;
 			int w  = s.width();
 			int h  = s.height();
-			int bm = pixelMetric( PM_ButtonMargin, widget );
-			int fw = pixelMetric( PM_DefaultFrameWidth, widget ) * 2;
+			int bm = tqpixelMetric( PM_ButtonMargin, widget );
+			int fw = tqpixelMetric( PM_DefaultFrameWidth, widget ) * 2;
 
 			//We use bold font sometimes, so that make take more space than TQt allocated.
 			TQFontMetrics origFM = button->fontMetrics();
@@ -1968,7 +1968,7 @@ TQSize dotNETstyle::tqsizeFromContents(ContentsType t,
 
 			// Compensate for default indicator. Doing it for all widgets lets us
 			// workaround changes in auto-default behavior in KDialogBase in 3.3
-			int di = pixelMetric( PM_ButtonDefaultIndicator );
+			int di = tqpixelMetric( PM_ButtonDefaultIndicator );
 			w += di * 2;
 			h += di * 2;
 
@@ -2011,7 +2011,7 @@ void dotNETstyle::paletteChanged()
 
 void dotNETstyle::updatePalette( TQComboBox *combo )
 {
-	TQPalette pal = TQApplication::palette();
+	TQPalette pal = TQApplication::tqpalette();
 	pal.setColor(TQColorGroup::Dark,
 	             pal.active().color(TQColorGroup::Base));
 	pal.setColor(TQColorGroup::Midlight,
@@ -2021,7 +2021,7 @@ void dotNETstyle::updatePalette( TQComboBox *combo )
 
 void dotNETstyle::updatePalette( TQToolBar *bar )
 {
-	TQPalette pal = TQApplication::palette();
+	TQPalette pal = TQApplication::tqpalette();
 	pal.setColor(TQColorGroup::Button,
 	             pal.active().color(TQColorGroup::Background));
 	bar->setPalette(pal);
@@ -2029,7 +2029,7 @@ void dotNETstyle::updatePalette( TQToolBar *bar )
 
 void dotNETstyle::updatePalette( TQMenuBar *bar )
 {
-	TQPalette pal = TQApplication::palette();
+	TQPalette pal = TQApplication::tqpalette();
 	pal.setColor(TQColorGroup::Button,
 	             pal.active().color(TQColorGroup::Background));
 	bar->setPalette(pal);
@@ -2046,7 +2046,7 @@ bool dotNETstyle::eventFilter(TQObject *obj, TQEvent *ev)
 		if (ev->type() == TQEvent::Enter) {
 			TQWidget *btn = (TQWidget *)obj;
 			if (btn->isEnabled()) {
-				TQPalette pal = btn->palette();
+				TQPalette pal = btn->tqpalette();
 				pal.setColor(TQColorGroup::Dark,
 				             pal.active().color(TQColorGroup::Highlight).dark());
 				pal.setColor(TQColorGroup::Midlight,
@@ -2055,7 +2055,7 @@ bool dotNETstyle::eventFilter(TQObject *obj, TQEvent *ev)
 			}
 		} else if (ev->type() == TQEvent::Leave) {
 			TQWidget *btn = (TQWidget *)obj;
-			TQPalette pal = btn->palette();
+			TQPalette pal = btn->tqpalette();
 			pal.setColor(TQColorGroup::Dark,
 			             pal.active().color(TQColorGroup::Base));
 			pal.setColor(TQColorGroup::Midlight,
@@ -2064,7 +2064,7 @@ bool dotNETstyle::eventFilter(TQObject *obj, TQEvent *ev)
 		}
 	} else if (obj->inherits(TQBUTTON_OBJECT_NAME_STRING)) {
 		TQWidget *btn = (TQWidget *)obj;
-		TQPalette pal = btn->palette();
+		TQPalette pal = btn->tqpalette();
 		pal.setColor(TQColorGroup::Button,
 		             pal.active().color(TQColorGroup::Background));
 		btn->setPalette(pal);
diff --git a/styles/dotnet/dotnet.h b/styles/dotnet/dotnet.h
index 5e4f104a..f2dbcf8a 100644
--- a/styles/dotnet/dotnet.h
+++ b/styles/dotnet/dotnet.h
@@ -62,7 +62,7 @@ public:
 		SFlags flags = Style_Default,
 		const TQStyleOption &opt = TQStyleOption::Default ) const;
 
-	void drawControl( TQ_ControlElement element,
+	void tqdrawControl( TQ_ControlElement element,
 		TQPainter *p,
 		const TQWidget *widget,
 		const TQRect &r,
@@ -70,9 +70,9 @@ public:
 		SFlags flags = Style_Default,
 		const TQStyleOption& = TQStyleOption::Default ) const;
 
-	void drawControlMask( TQ_ControlElement, TQPainter *, const TQWidget *, const TQRect &, const TQStyleOption &) const;
+	void tqdrawControlMask( TQ_ControlElement, TQPainter *, const TQWidget *, const TQRect &, const TQStyleOption &) const;
 
-	void drawComplexControl( ComplexControl control,
+	void tqdrawComplexControl( ComplexControl control,
 		TQPainter *p,
 		const TQWidget *widget,
 		const TQRect &r,
@@ -82,7 +82,7 @@ public:
 		SCFlags active = SC_None,
 		const TQStyleOption& = TQStyleOption::Default ) const;
 
-	int pixelMetric( PixelMetric m,
+	int tqpixelMetric( PixelMetric m,
 		const TQWidget *widget = 0 ) const;
 
 	TQRect subRect( SubRect r,
@@ -93,7 +93,7 @@ public:
 		SubControl subcontrol,
 		const TQStyleOption &opt = TQStyleOption::Default ) const;
 
-	void drawComplexControlMask(TQStyle::ComplexControl c,
+	void tqdrawComplexControlMask(TQStyle::ComplexControl c,
 	                            TQPainter *p,
 	                            const TQWidget *w,
 	                            const TQRect &r,
diff --git a/styles/phase/phasestyle.cpp b/styles/phase/phasestyle.cpp
index e2d66ecd..dc9a75fb 100644
--- a/styles/phase/phasestyle.cpp
+++ b/styles/phase/phasestyle.cpp
@@ -421,7 +421,7 @@ void PhaseStyle::drawPhaseTab(TQPainter *painter,
 	edge = false;
     }
 
-    switch (TQTabBar::Shape(bar->shape())) {
+    switch (TQTabBar::Shape(bar->tqshape())) {
       case TQTabBar::RoundedAbove:
       case TQTabBar::TriangularAbove: {
 	  // is there a corner widget?
@@ -727,8 +727,8 @@ void PhaseStyle::tqdrawPrimitive(TQ_PrimitiveElement element,
 
       case PE_Indicator:
           drawPhasePanel(painter, x+1, y+1, w-2, h-2, group, true, enabled ?
-                         &group.brush(TQColorGroup::Base) :
-                         &group.brush(TQColorGroup::Background));
+                         &group.tqbrush(TQColorGroup::Base) :
+                         &group.tqbrush(TQColorGroup::Background));
 
           if (on) {
               painter->setPen(mouseover
@@ -736,7 +736,7 @@ void PhaseStyle::tqdrawPrimitive(TQ_PrimitiveElement element,
                               : group.dark());
               painter->drawRect(x+4, y+4, w-8, h-8);
               painter->fillRect(x+5, y+5, w-10, h-10,
-                                group.brush(TQColorGroup::Highlight));
+                                group.tqbrush(TQColorGroup::Highlight));
           } else if (mouseover) {
               painter->setPen(TQColor(group.highlight().dark(contrast)));
               painter->drawRect(x+4, y+4, w-8, h-8);
@@ -749,7 +749,7 @@ void PhaseStyle::tqdrawPrimitive(TQ_PrimitiveElement element,
           break;
 
       case PE_ExclusiveIndicator: {
-          // note that this requires an even size from pixelMetric
+          // note that this requires an even size from tqpixelMetric
           cx = (x + x2) / 2;
           cy = (y + y2) / 2;
 
@@ -761,14 +761,14 @@ void PhaseStyle::tqdrawPrimitive(TQ_PrimitiveElement element,
           parray.putPoints(0, 8,
                            x+1,cy+1, x+1,cy,    cx,y+1,    cx+1,y+1,
                            x2-1,cy,  x2-1,cy+1, cx+1,y2-1, cx,y2-1);
-          painter->drawConvexPolygon(parray, 0, 8);
+          painter->tqdrawConvexPolygon(parray, 0, 8);
 
           painter->setPen(group.mid());
           parray.putPoints(0, 4, x,cy, cx,y, cx+1,y, x2,cy);
-          painter->drawPolyline(parray, 0, 4);
+          painter->tqdrawPolyline(parray, 0, 4);
           painter->setPen(group.midlight());
           parray.putPoints(0, 4, x2,cy+1, cx+1,y2, cx,y2, x,cy+1);
-          painter->drawPolyline(parray, 0, 4);
+          painter->tqdrawPolyline(parray, 0, 4);
 
           if (on) {
               painter->setBrush(group.brush(TQColorGroup::Highlight));
@@ -778,14 +778,14 @@ void PhaseStyle::tqdrawPrimitive(TQ_PrimitiveElement element,
               parray.putPoints(0, 8,
                                x+4,cy+1, x+4,cy,    cx,y+4,    cx+1,y+4,
                                x2-4,cy,  x2-4,cy+1, cx+1,y2-4, cx,y2-4);
-              painter->drawConvexPolygon(parray, 0, 8);
+              painter->tqdrawConvexPolygon(parray, 0, 8);
           } else if (mouseover) {
               painter->setPen(TQColor(group.highlight().dark(contrast)));
               parray.putPoints(0, 9,
                                x+4,cy+1, x+4,cy,    cx,y+4,    cx+1,y+4,
                                x2-4,cy,  x2-4,cy+1, cx+1,y2-4, cx,y2-4,
                                x+4,cy+1);
-              painter->drawPolyline(parray, 0, 9);
+              painter->tqdrawPolyline(parray, 0, 9);
           }
           break;
       }
@@ -798,13 +798,13 @@ void PhaseStyle::tqdrawPrimitive(TQ_PrimitiveElement element,
           parray.putPoints(0, 8,
                            x,cy+1, x,cy,    cx,y,    cx+1,y,
                            x2,cy,  x2,cy+1, cx+1,y2, cx,y2);
-          painter->drawConvexPolygon(parray, 0, 8);
+          painter->tqdrawConvexPolygon(parray, 0, 8);
           painter->setPen(TQt::color0);
           break;
 
       case PE_DockWindowResizeHandle:
           drawPhasePanel(painter, x, y, w, h, group, false,
-                         &group.brush(TQColorGroup::Background));
+                         &group.tqbrush(TQColorGroup::Background));
           break;
 
       case PE_Splitter:
@@ -1095,7 +1095,7 @@ void PhaseStyle::drawKStylePrimitive(KStylePrimitive element,
               }
           }
           drawPhasePanel(painter, x, y, w, h, group, true,
-                         &group.brush(TQColorGroup::Mid));
+                         &group.tqbrush(TQColorGroup::Mid));
           break;
       }
 
@@ -1127,11 +1127,11 @@ void PhaseStyle::drawKStylePrimitive(KStylePrimitive element,
 }
 
 //////////////////////////////////////////////////////////////////////////////
-// drawControl()
+// tqdrawControl()
 // -------------
 // Draw the control
 
-void PhaseStyle::drawControl(TQ_ControlElement element,
+void PhaseStyle::tqdrawControl(TQ_ControlElement element,
                              TQPainter *painter,
                              const TQWidget *widget,
                              const TQRect &rect,
@@ -1153,11 +1153,11 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
     switch (element) {
       case CE_PushButton: {
           depress = flags & (Style_Down | Style_On);
-          int bd = pixelMetric(PM_ButtonDefaultIndicator, widget) + 1;
+          int bd = tqpixelMetric(PM_ButtonDefaultIndicator, widget) + 1;
 
           if ((flags & Style_ButtonDefault) && !depress) {
               drawPhasePanel(painter, x, y, w, h, group, true,
-                             &group.brush(TQColorGroup::Mid));
+                             &group.tqbrush(TQColorGroup::Mid));
               drawPhaseBevel(painter, x+bd, y+bd, w-bd*2, h-bd*2, group,
                              (widget==hover_)
                              ? TQColor(group.button().light(contrast))
@@ -1181,7 +1181,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
       case CE_PushButtonLabel: {
           const TQPushButton* button = ::tqqt_cast<const TQPushButton*>(widget);
           if (!button) {
-              KStyle::drawControl(element, painter, widget, rect, group,
+              KStyle::tqdrawControl(element, painter, widget, rect, group,
                                   flags, option);
               return;
           }
@@ -1193,7 +1193,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
           }
 
           if (button->isMenuButton()) { // menu indicator
-              int dx = pixelMetric(PM_MenuButtonIndicator, widget);
+              int dx = tqpixelMetric(PM_MenuButtonIndicator, widget);
               tqdrawPrimitive(PE_ArrowDown, painter,
                             TQRect(x+w-dx-2, y+2, dx, h-4),
                             group, flags, option);
@@ -1232,24 +1232,24 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
               for(int n=0; n<2; n++) {
                   drawItem(painter, TQRect(x+n, y, w, h),
                            AlignCenter | ShowPrefix,
-                           button->colorGroup(),
+                           button->tqcolorGroup(),
                            button->isEnabled(),
                            button->pixmap(),
                            button->text(), -1,
                            (button->isEnabled()) ?
-                           &button->colorGroup().buttonText() :
-                           &button->colorGroup().mid());
+                           &button->tqcolorGroup().buttonText() :
+                           &button->tqcolorGroup().mid());
               }
           } else { // normal button
               drawItem(painter, TQRect(x, y, w, h),
                        AlignCenter | ShowPrefix,
-                       button->colorGroup(),
+                       button->tqcolorGroup(),
                        button->isEnabled(),
                        button->pixmap(),
                        button->text(), -1,
                        (button->isEnabled()) ?
-                       &button->colorGroup().buttonText() :
-                       &button->colorGroup().mid());
+                       &button->tqcolorGroup().buttonText() :
+                       &button->tqcolorGroup().mid());
           }
           break;
       }
@@ -1259,14 +1259,14 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
           const TQButton *b = ::tqqt_cast<const TQButton*>(widget);
           if (!b) return;
 
-          int alignment = reverse_ ? AlignRight : AlignLeft;
-          drawItem(painter, rect, alignment | AlignVCenter | ShowPrefix,
+          int tqalignment = reverse_ ? AlignRight : AlignLeft;
+          drawItem(painter, rect, tqalignment | AlignVCenter | ShowPrefix,
                    group, flags & Style_Enabled, b->pixmap(), b->text());
 
           // only draw focus if content (forms on html won't)
           if ((flags & Style_HasFocus) && ((!b->text().isNull()) || b->pixmap())) {
               tqdrawPrimitive(PE_FocusRect, painter,
-                            visualRect(subRect(SR_RadioButtonFocusRect,
+                            tqvisualRect(subRect(SR_RadioButtonFocusRect,
                                                widget), widget),
                             group, flags);
           }
@@ -1296,7 +1296,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
       case CE_MenuBarItem: {
           const TQMenuBar *mbar = ::tqqt_cast<const TQMenuBar*>(widget);
           if (!mbar) {
-              KStyle::drawControl(element, painter, widget, rect, group,
+              KStyle::tqdrawControl(element, painter, widget, rect, group,
                                   flags, option);
               return;
           }
@@ -1306,7 +1306,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
           if ((flags & Style_Active) && (flags & Style_HasFocus)) {
               if (flags & Style_Down) {
                   drawPhasePanel(painter, x, y, w, h, group, true,
-                                 &group.brush(TQColorGroup::Background));
+                                 &group.tqbrush(TQColorGroup::Background));
               } else {
                   drawPhaseBevel(painter, x, y, w, h,
                                  group, group.background(),
@@ -1327,7 +1327,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
       case CE_PopupMenuItem: {
           const TQPopupMenu *popup = ::tqqt_cast<const TQPopupMenu*>(widget);
           if (!popup) {
-              KStyle::drawControl(element, painter, widget, rect, group,
+              KStyle::tqdrawControl(element, painter, widget, rect, group,
                                   flags, option);
               return;
           }
@@ -1341,7 +1341,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
           int tabwidth   = option.tabWidth();
           int checkwidth = option.maxIconWidth();
           bool checkable = popup->isCheckable();
-          bool etchtext  = styleHint(SH_EtchDisabledText);
+          bool etchtext  = tqstyleHint(SH_EtchDisabledText);
           active         = flags & Style_Active;
           enabled        = mi->isEnabled();
           TQRect vrect;
@@ -1380,7 +1380,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
 
               pixmap = mi->iconSet()->pixmap(TQIconSet::Small, mode);
               TQRect pmrect(0, 0, pixmap.width(), pixmap.height());
-              vrect = visualRect(TQRect(x, y, checkwidth, h), rect);
+              vrect = tqvisualRect(TQRect(x, y, checkwidth, h), rect);
               pmrect.moveCenter(vrect.center());
               painter->drawPixmap(pmrect.topLeft(), pixmap);
           }
@@ -1477,7 +1477,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
           if (mi->popup()) { // draw submenu arrow
               TQ_PrimitiveElement arrow = reverse_ ? PE_ArrowLeft : PE_ArrowRight;
               int dim = (h-2*ITEMFRAME) / 2;
-              vrect = visualRect(TQRect(x + w - ARROWMARGIN - ITEMFRAME - dim,
+              vrect = tqvisualRect(TQRect(x + w - ARROWMARGIN - ITEMFRAME - dim,
                                        y + h / 2 - dim / 2, dim, dim), rect);
               tqdrawPrimitive(arrow, painter, vrect, group,
                             enabled ? Style_Enabled : Style_Default);
@@ -1495,7 +1495,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
               drawPhaseTab(painter, x, y, w, h, group, tab, option,
                            flags);
           } else { // not a tabbar
-              KStyle::drawControl(element, painter, widget, rect, group,
+              KStyle::tqdrawControl(element, painter, widget, rect, group,
                                   flags, option);
               return;
           }
@@ -1504,14 +1504,14 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
 
       case CE_ProgressBarGroove: {
           drawPhasePanel(painter, x, y, w, h, group, true,
-                         &group.brush(TQColorGroup::Base));
+                         &group.tqbrush(TQColorGroup::Base));
           break;
       }
 
       case CE_ProgressBarContents: {
           const TQProgressBar* pbar = ::tqqt_cast<const TQProgressBar*>(widget);
           if (!pbar) {
-              KStyle::drawControl(element, painter, widget, rect, group,
+              KStyle::tqdrawControl(element, painter, widget, rect, group,
                                   flags, option);
               return;
           }
@@ -1522,7 +1522,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
 
           if (!pbar->totalSteps()) {
               // busy indicator
-              int bar = pixelMetric(PM_ProgressBarChunkWidth, widget) + 2;
+              int bar = tqpixelMetric(PM_ProgressBarChunkWidth, widget) + 2;
               int progress = pbar->progress() % ((w-bar) * 2);
               if (progress > (w-bar)) progress = 2 * (w-bar) - progress;
               painter->drawRect(x+progress+1, y+1, bar-2, h-2);
@@ -1540,7 +1540,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
       case CE_ToolBoxTab: {
           const TQToolBox *box = ::tqqt_cast<const TQToolBox*>(widget);
           if (!box) {
-              KStyle::drawControl(element, painter, widget, rect, group,
+              KStyle::tqdrawControl(element, painter, widget, rect, group,
                                   flags, option);
               return;
           }
@@ -1556,7 +1556,7 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
           if (box->currentItem() && (flags & Style_Selected)) {
               painter->setPen(group.dark());
               painter->setBrush(box->currentItem()->paletteBackgroundColor());
-              painter->drawConvexPolygon(parray, 0, 6);
+              painter->tqdrawConvexPolygon(parray, 0, 6);
               painter->setBrush(NoBrush);
           } else {
               painter->setClipRegion(parray, TQPainter::CoordPainter);
@@ -1564,28 +1564,28 @@ void PhaseStyle::drawControl(TQ_ControlElement element,
                                 group.background(),
                                 false, 0, 0, 0, h*2, false);
               painter->setClipping(false);
-              painter->drawPolyline(parray, 0, 4);
+              painter->tqdrawPolyline(parray, 0, 4);
           }
 
           parray.putPoints(0, 4, x,y+1, cx,y+1, rx-2,y2-1, x2,y2-1);
           painter->setPen(group.midlight());
-          painter->drawPolyline(parray, 0, 4);
+          painter->tqdrawPolyline(parray, 0, 4);
 
           break;
       }
 
       default:
-          KStyle::drawControl(element, painter, widget, rect, group,
+          KStyle::tqdrawControl(element, painter, widget, rect, group,
                               flags, option);
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
-// drawControlMask()
+// tqdrawControlMask()
 // -----------------
 // Draw a bitmask for the element
 
-void PhaseStyle::drawControlMask(TQ_ControlElement element,
+void PhaseStyle::tqdrawControlMask(TQ_ControlElement element,
                                  TQPainter *painter,
                                  const TQWidget *widget,
                                  const TQRect &rect,
@@ -1598,16 +1598,16 @@ void PhaseStyle::drawControlMask(TQ_ControlElement element,
           break;
 
       default:
-          KStyle::drawControlMask(element, painter, widget, rect, option);
+          KStyle::tqdrawControlMask(element, painter, widget, rect, option);
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
-// drawComplexControl()
+// tqdrawComplexControl()
 // --------------------
 // Draw a complex control
 
-void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
+void PhaseStyle::tqdrawComplexControl(TQ_ComplexControl control,
                                     TQPainter *painter,
                                     const TQWidget *widget,
                                     const TQRect &rect,
@@ -1629,7 +1629,7 @@ void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
       case CC_ComboBox: {
           const TQComboBox * combo = ::tqqt_cast<const TQComboBox*>(widget);
           if (!combo) {
-              KStyle::drawComplexControl(control, painter, widget, rect, group,
+              KStyle::tqdrawComplexControl(control, painter, widget, rect, group,
                                          flags, controls, active, option);
               return;
           }
@@ -1641,20 +1641,20 @@ void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
                           : group.button(), sunken);
 
           if (controls & SC_ComboBoxArrow) { // draw arrow box
-              subrect = visualRect(querySubControlMetrics(CC_ComboBox, widget,
+              subrect = tqvisualRect(querySubControlMetrics(CC_ComboBox, widget,
                             SC_ComboBoxArrow), widget);
 
               subrect.rect(&x, &y, &w, &h);
               int slot = TQMAX(h/4, 6) + (h % 2);
               drawPhasePanel(painter, x+3, y+(h/2)-(slot/2), w-6,
                              slot, group, true,
-                             sunken ? &group.brush(TQColorGroup::Midlight)
-                             : &group.brush(TQColorGroup::Mid));
+                             sunken ? &group.tqbrush(TQColorGroup::Midlight)
+                             : &group.tqbrush(TQColorGroup::Mid));
           }
 
           if (controls & SC_ComboBoxEditField) { // draw edit box
               if (combo->editable()) { // editable box
-                  subrect = visualRect(querySubControlMetrics(CC_ComboBox,
+                  subrect = tqvisualRect(querySubControlMetrics(CC_ComboBox,
                                 widget, SC_ComboBoxEditField), widget);
                   x2 = subrect.right(); y2 = subrect.bottom();
                   painter->setPen(group.dark());
@@ -1664,7 +1664,7 @@ void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
                   painter->setPen(group.button());
                   painter->drawPoint(x2+2, y2);
               } else if (combo->hasFocus()) { // non editable box
-                  subrect = visualRect(subRect(SR_ComboBoxFocusRect,
+                  subrect = tqvisualRect(subRect(SR_ComboBoxFocusRect,
                                                combo), widget);
                   tqdrawPrimitive(PE_FocusRect, painter, subrect, group,
                                 Style_FocusAtBorder,
@@ -1680,7 +1680,7 @@ void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
           // always a three button scrollbar
           const TQScrollBar *sb = ::tqqt_cast<const TQScrollBar*>(widget);
           if (!sb) {
-              KStyle::drawComplexControl(control, painter, widget, rect, group,
+              KStyle::tqdrawComplexControl(control, painter, widget, rect, group,
                                          flags, controls, active, option);
               return;
           }
@@ -1777,7 +1777,7 @@ void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
       case CC_SpinWidget: {
           const TQSpinWidget *spin = ::tqqt_cast<const TQSpinWidget*>(widget);
           if (!spin) {
-              KStyle::drawComplexControl(control, painter, widget, rect, group,
+              KStyle::tqdrawComplexControl(control, painter, widget, rect, group,
                                          flags, controls, active, option);
               return;
           }
@@ -1837,7 +1837,7 @@ void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
       case CC_ToolButton: {
           const TQToolButton *btn = ::tqqt_cast<const TQToolButton*>(widget);
           if (!btn) {
-              KStyle::drawComplexControl(control, painter, widget, rect, group,
+              KStyle::tqdrawComplexControl(control, painter, widget, rect, group,
                                          flags, controls, active, option);
               return;
           }
@@ -1905,7 +1905,7 @@ void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
           // now draw active buttons
           if (down || on) {
               drawPhasePanel(painter, x, y, w, h, group, true,
-                             &group.brush(TQColorGroup::Button));
+                             &group.tqbrush(TQColorGroup::Button));
           } else if (raised) {
               drawPhaseBevel(painter, x, y, w, h, group, group.button(),
                              false, !horiz, true);
@@ -1915,18 +1915,18 @@ void PhaseStyle::drawComplexControl(TQ_ComplexControl control,
       }
 
       default:
-          KStyle::drawComplexControl(control, painter, widget, rect, group,
+          KStyle::tqdrawComplexControl(control, painter, widget, rect, group,
                                      flags, controls, active, option);
           break;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
-// drawComplexControlMask()
+// tqdrawComplexControlMask()
 // ------------------------
 // Draw a bitmask for the control
 
-void PhaseStyle::drawComplexControlMask(TQ_ComplexControl control,
+void PhaseStyle::tqdrawComplexControlMask(TQ_ComplexControl control,
                                         TQPainter *painter,
                                         const TQWidget *widget,
                                         const TQRect &rect,
@@ -1941,16 +1941,16 @@ void PhaseStyle::drawComplexControlMask(TQ_ComplexControl control,
       }
 
       default:
-          KStyle::drawComplexControlMask(control,painter,widget,rect,option);
+          KStyle::tqdrawComplexControlMask(control,painter,widget,rect,option);
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
-// pixelMetric()
+// tqpixelMetric()
 // -------------
 // Get the pixel metric for metric
 
-int PhaseStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) const
+int PhaseStyle::tqpixelMetric(PixelMetric metric, const TQWidget *widget) const
 {
     // not using widget's font, so that all metrics are uniform
     int em = TQMAX(TQApplication::fontMetrics().strikeOutPos() * 3, 17);
@@ -1973,7 +1973,7 @@ int PhaseStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) const
 
       case PM_TabBarTabVSpace:
           if (const TQTabBar *tb = ::tqqt_cast<const TQTabBar*>(widget)) {
-              if (tb->shape() == TQTabBar::RoundedAbove) {
+              if (tb->tqshape() == TQTabBar::RoundedAbove) {
                   return 10;
               } else {
                   return 6;
@@ -2000,7 +2000,7 @@ int PhaseStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) const
           return em;
 
       default:
-          return KStyle::pixelMetric(metric, widget);
+          return KStyle::tqpixelMetric(metric, widget);
     }
 }
 
@@ -2036,7 +2036,7 @@ TQRect PhaseStyle::querySubControlMetrics(TQ_ComplexControl control,
 {
     TQRect rect;
 
-    const int fw = pixelMetric(PM_DefaultFrameWidth, widget);
+    const int fw = tqpixelMetric(PM_DefaultFrameWidth, widget);
     int w = widget->width(), h = widget->height();
     int xc;
 
@@ -2143,8 +2143,8 @@ TQSize PhaseStyle::tqsizeFromContents(ContentsType contents,
               return KStyle::tqsizeFromContents(contents, widget, contentsize,
                                               option);
           }
-          int margin = pixelMetric(PM_ButtonMargin, widget)
-              + pixelMetric(PM_DefaultFrameWidth, widget) + 4;
+          int margin = tqpixelMetric(PM_ButtonMargin, widget)
+              + tqpixelMetric(PM_DefaultFrameWidth, widget) + 4;
 
           w += margin + 6; // add room for bold font
           h += margin;
@@ -2167,8 +2167,8 @@ TQSize PhaseStyle::tqsizeFromContents(ContentsType contents,
           TQMenuItem *item = option.menuItem();
 
           if (item->custom()) {
-              w = item->custom()->sizeHint().width();
-              h = item->custom()->sizeHint().height();
+              w = item->custom()->tqsizeHint().width();
+              h = item->custom()->tqsizeHint().height();
               if (!item->custom()->fullSpan())
                   h += ITEMVMARGIN*2 + ITEMFRAME*2;
           } else if (item->widget()) { // a menu item that is a widget
@@ -2273,17 +2273,17 @@ bool PhaseStyle::eventFilter(TQObject *object, TQEvent *event)
             TQPainter painter(widget);
             if (flatToolbar(toolbar)) {
                 painter.fillRect(widget->rect(),
-                                  parent->colorGroup().background());
+                                  parent->tqcolorGroup().background());
             } else {
                 drawPhaseGradient(&painter, widget->rect(),
-                                  parent->colorGroup().background(),
+                                  parent->tqcolorGroup().background(),
                                   !horiz, px, py,
                                   prect.width(), prect.height(), true);
                 if (horiz && (h==prect.height()-2)) {
-                    painter.setPen(parent->colorGroup().mid());
+                    painter.setPen(parent->tqcolorGroup().mid());
                     painter.drawLine(x, h-1, w-1, h-1);
                 } else if (!horiz && (w==prect.width()-2)) {
-                    painter.setPen(parent->colorGroup().mid());
+                    painter.setPen(parent->tqcolorGroup().mid());
                     painter.drawLine(w-1, y, w-1, h-1);
                 }
             }
@@ -2298,42 +2298,42 @@ bool PhaseStyle::eventFilter(TQObject *object, TQEvent *event)
             TQT_TQRECT_OBJECT(widget->rect()).rect(&x, &y, &w, &h);
             // draw the extension
             drawPhaseGradient(&painter, widget->rect(),
-                              toolbar->colorGroup().background(),
+                              toolbar->tqcolorGroup().background(),
                               !horiz, x, y, w-1, h-1, true);
             if (horiz) {
-                painter.setPen(toolbar->colorGroup().dark());
+                painter.setPen(toolbar->tqcolorGroup().dark());
                 painter.drawLine(w-1, 0, w-1, h-1);
-                painter.setPen(toolbar->colorGroup().mid());
+                painter.setPen(toolbar->tqcolorGroup().mid());
                 painter.drawLine(w-2, 0, w-2, h-2);
                 painter.drawLine(x, h-1, w-2, h-1);
                 painter.drawLine(x, y, x, h-2);
-                painter.setPen(toolbar->colorGroup().midlight());
+                painter.setPen(toolbar->tqcolorGroup().midlight());
                 painter.drawLine(x+1, y, x+1, h-2);
             } else {
-                painter.setPen(toolbar->colorGroup().dark());
+                painter.setPen(toolbar->tqcolorGroup().dark());
                 painter.drawLine(0, h-1, w-1, h-1);
-                painter.setPen(toolbar->colorGroup().mid());
+                painter.setPen(toolbar->tqcolorGroup().mid());
                 painter.drawLine(0, h-2, w-2, h-2);
                 painter.drawLine(w-1, y, w-1, h-2);
                 painter.drawLine(x, y, w-2, y);
-                painter.setPen(toolbar->colorGroup().midlight());
+                painter.setPen(toolbar->tqcolorGroup().midlight());
                 painter.drawLine(x, y+1, w-2, y+1);
             }
         }
 
         // TQFrame lines (do this guy last)
         else if (0 != (frame = ::tqqt_cast<TQFrame*>(object))) {
-            TQFrame::Shape shape = frame->frameShape();
-            switch (shape) {
+            TQFrame::Shape tqshape = frame->frameShape();
+            switch (tqshape) {
               case TQFrame::HLine:
               case TQFrame::VLine: {
                   // NOTE: assuming lines have no content
                   TQPainter painter(frame);
                   TQT_TQRECT_OBJECT(frame->rect()).rect(&x, &y, &w, &h);
-                  painter.setPen(frame->colorGroup().dark());
-                  if (shape == TQFrame::HLine) {
+                  painter.setPen(frame->tqcolorGroup().dark());
+                  if (tqshape == TQFrame::HLine) {
                       painter.drawLine(0, h/2, w, h/2);
-                  } else if (shape == TQFrame::VLine) {
+                  } else if (tqshape == TQFrame::VLine) {
                       painter.drawLine(w/2, 0, w/2, h);
                   }
                   return true;
@@ -2355,12 +2355,12 @@ bool PhaseStyle::eventFilter(TQObject *object, TQEvent *event)
                 if (0 != (widget = ::tqqt_cast<TQWidget*>(object)) &&
                     widget->isEnabled()) {
                     hover_ = widget;
-                    widget->repaint(false);
+                    widget->tqrepaint(false);
                 }
             } else if (event->type() == TQEvent::Leave) {
                 if (0 != (widget = ::tqqt_cast<TQWidget*>(object))) {
                     hover_ = 0;
-                    widget->repaint(false);
+                    widget->tqrepaint(false);
                 }
             }
         } else if (::tqqt_cast<TQTabBar*>(object)) { // special case for qtabbar
@@ -2369,13 +2369,13 @@ bool PhaseStyle::eventFilter(TQObject *object, TQEvent *event)
                     widget->isEnabled()) {
                     hover_ = widget;
                     hovertab_ = 0;;
-                    widget->repaint(false);
+                    widget->tqrepaint(false);
                 }
             } else if (event->type() == TQEvent::Leave) {
                 if (0 != (widget = ::tqqt_cast<TQWidget*>(object))) {
                     hover_ = 0;
                     hovertab_ = 0;;
-                    widget->repaint(false);
+                    widget->tqrepaint(false);
                 }
             } else if (event->type() == TQEvent::MouseMove) {
                 TQTabBar *tabbar;
@@ -2385,7 +2385,7 @@ bool PhaseStyle::eventFilter(TQObject *object, TQEvent *event)
                         TQTab *tab = tabbar->selectTab(me->pos());
                         if (hovertab_ != tab) {
                             hovertab_ = tab;
-                            tabbar->repaint(false);
+                            tabbar->tqrepaint(false);
                         }
                     }
                 }
diff --git a/styles/phase/phasestyle.h b/styles/phase/phasestyle.h
index ec0f2352..9d81264e 100644
--- a/styles/phase/phasestyle.h
+++ b/styles/phase/phasestyle.h
@@ -82,7 +82,7 @@ public:
             SFlags flags = Style_Default,
             const TQStyleOption &option = TQStyleOption::Default) const;
 
-    void drawControl(TQ_ControlElement element,
+    void tqdrawControl(TQ_ControlElement element,
             TQPainter *painter,
             const TQWidget *widget,
             const TQRect &rect,
@@ -90,13 +90,13 @@ public:
             SFlags flags = Style_Default,
             const TQStyleOption &option = TQStyleOption::Default) const;
 
-    void drawControlMask(TQ_ControlElement element,
+    void tqdrawControlMask(TQ_ControlElement element,
             TQPainter *painter,
             const TQWidget *widget,
             const TQRect &rect,
             const TQStyleOption &option = TQStyleOption::Default) const;
 
-    void drawComplexControl(TQ_ComplexControl control,
+    void tqdrawComplexControl(TQ_ComplexControl control,
             TQPainter *painter,
             const TQWidget *widget,
             const TQRect &rect,
@@ -106,13 +106,13 @@ public:
             SCFlags active = SC_None,
             const TQStyleOption &option = TQStyleOption::Default) const;
 
-    void drawComplexControlMask(TQ_ComplexControl control,
+    void tqdrawComplexControlMask(TQ_ComplexControl control,
             TQPainter *painter,
             const TQWidget *widget,
             const TQRect &rect,
             const TQStyleOption &option = TQStyleOption::Default) const;
 
-    int pixelMetric(PixelMetric metric,
+    int tqpixelMetric(PixelMetric metric,
             const TQWidget *widget = 0) const;
 
     TQRect subRect(SubRect rect, const TQWidget *widget) const;