gtk3-tqt-engine/tdegtk/tdegtk-draw.cpp

/* The TdeGtk Theming Engine for Gtk+.
 * Copyright (C) 2012 Timothy Pearson <kb9vqf@pearsoncomputing.net>
 *
 * This  library is free  software; you can  redistribute it and/or
 * modify it  under  the terms  of the  GNU Lesser  General  Public
 * License  as published  by the Free  Software  Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed  in the hope that it will be useful,
 * but  WITHOUT ANY WARRANTY; without even  the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License  along  with  this library;  if not,  write to  the Free
 * Software Foundation, Inc., 51  Franklin St, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 */

#include <cairo.h>
#include <gtk/gtk.h>
#include <math.h>

#include <tqapplication.h>
#include <tqpainter.h>
#include <tqstyle.h>
#include <tqpopupmenu.h>
#include <tqlistview.h>
#include <tqdrawutil.h>
#include <tqslider.h>

#include <kiconloader.h>
#include <kicontheme.h>

#include "tdegtk-cairo-support.h"
#include "tdegtk-draw.h"
#include "tdegtk-support.h"
#include "tdegtk-types.h"
#include "tdegtk-widgetlookup.h"
#include "tdegtk-utils.h"
#include "tdegtk-animations.h"

#include "tqtcairopainter.h"

#define DEBUG_FILL_BACKGROUND_WITH_COLOR(p,x,y,z)	TQBrush brush2( TQColor(x,y,z), TQBrush::SolidPattern );	\
							p.setBrush( brush2 );						\
							p.setPen( TQt::NoPen );						\
							p.drawRect( 0,0, width*2,height*2 );				\
							p.setBrush(TQt::NoBrush);

#define DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p,x)		p.setBrush(x);				\
								p.setPen(TQt::NoPen);			\
								p.drawRect(0, 0, width, height);	\
								p.setBrush(TQt::NoBrush);

#define DRAW_FILLED_RECTANGLE_OVER_SPECIFIC_AREA(p,b,x,y,w,h)	p.setBrush(b);				\
								p.setPen(TQt::NoPen);			\
								p.drawRect(x, y, w, h);			\
								p.setBrush(TQt::NoBrush);

extern int m_scrollBarSubLineWidth;

WidgetLookup m_widgetLookup;
Animations m_animations;

//#define DRAW_SCROLLBAR_PIECES_INSTEAD_OF_ENTIRE_BAR 1

// Keep this in sync with gtkToTQPaletteColorGroup() below
static TQColorGroup gtkToTQtColorGroup(GtkThemingEngine* engine, GtkStateFlags state) {
// 	GdkRGBA *background_color;
// 	GdkRGBA *foreground_color;
// 	gtk_theming_engine_get(engine, state, GTK_STYLE_PROPERTY_BACKGROUND_COLOR, &background_color, NULL);
// 	gtk_theming_engine_get(engine, state, GTK_STYLE_PROPERTY_COLOR, &foreground_color, NULL);

// 	GTK_STATE_FLAG_ACTIVE
// 	GTK_STATE_FLAG_PRELIGHT
// 	GTK_STATE_FLAG_SELECTED
// 	GTK_STATE_FLAG_INSENSITIVE
// 	GTK_STATE_FLAG_INCONSISTENT
// 	GTK_STATE_FLAG_FOCUSED

	TQColorGroup cg;
// 	if (state & GTK_STATE_FLAG_INCONSISTENT) {
// 		cg = tqApp->palette().inactive();
// 	}
	/*else*/ if (state & GTK_STATE_FLAG_INSENSITIVE) {
		cg = tqApp->palette().disabled();
	}
	else {
		cg = tqApp->palette().active();
	}
// 	cg.setColor(TQColorGroup::Background, TQColor((background_color->red*255.0),(background_color->green*255.0),(background_color->blue*255.0)));
// 	cg.setColor(TQColorGroup::Foreground, TQColor((foreground_color->red*255.0),(foreground_color->green*255.0),(foreground_color->blue*255.0)));

	return cg;
}

// Keep this in sync with gtkToTQtColorGroup() above
static TQPalette::ColorGroup gtkToTQPaletteColorGroup(GtkThemingEngine* engine, GtkStateFlags state) {
	TQPalette::ColorGroup cg = TQPalette::Active;

	if (state & GTK_STATE_FLAG_INSENSITIVE) {
		cg = TQPalette::Disabled;
	}
	else {
		cg = TQPalette::Active;
	}

	return cg;
}

static TQStyle::SFlags gtkToTQtStyleFlags(GtkThemingEngine* engine, GtkStateFlags state, TQt3WidgetType wt, GtkWidget* widget) {
	TQStyle::SFlags sflags = TQStyle::Style_Default;

	gboolean active, inconsistent, mousedown, prelight, focused, disabled, in_menu, has_focus;
	in_menu = gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_MENUITEM);
	prelight = (state & GTK_STATE_FLAG_PRELIGHT) != 0;
	focused = (state & GTK_STATE_FLAG_FOCUSED) != 0;
	disabled = (state & GTK_STATE_FLAG_INSENSITIVE) != 0;
	inconsistent = (state & GTK_STATE_FLAG_INCONSISTENT) != 0;
	mousedown = (state & GTK_STATE_FLAG_SELECTED) != 0;
	active = (state & GTK_STATE_FLAG_ACTIVE) != 0;
	has_focus = gtk_widget_has_visible_focus(widget);

	if ((wt == TQT3WT_TQRadioButton) || (wt == TQT3WT_TQCheckBox) || (wt == TQT3WT_TQPushButton)) {
		GtkCheckButton* checkButton = (widget)?((GTK_IS_CHECK_BUTTON(widget))?GTK_CHECK_BUTTON(widget):0L):0L;
		if ((!inconsistent) && (!mousedown)) {
			if (active) {
				sflags |= TQStyle::Style_On;
			}
			else {
				sflags |= TQStyle::Style_Off;
			}
		}
		if (mousedown) {
			sflags |= TQStyle::Style_Down;
			if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkButton))) {
				sflags |= TQStyle::Style_On;
			}
		}
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
	}
	else if (wt == TQT3WT_TQToolButton) {
		if (!inconsistent) {
			if (active) {
				sflags |= TQStyle::Style_On;
			}
			else {
				sflags |= TQStyle::Style_Off;
			}
		}
		if (mousedown) {
			sflags |= TQStyle::Style_Down;
		}
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
			sflags |= TQStyle::Style_Raised;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
	}
	else if (wt == TQT3WT_GTKTreeViewCell) {
		if (!inconsistent) {
			if (active) {
				sflags |= TQStyle::Style_On;
			}
			else {
				sflags |= TQStyle::Style_Off;
			}
		}
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
	}
	else if (wt == TQT3WT_TQGroupBox) {
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
	}
	else if (wt == TQT3WT_TQMenuItem) {
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
	}
	else if (wt == TQT3WT_TQSlider) {
		if (active) {
			sflags |= TQStyle::Style_Active;
		}
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
	}
	else if (wt == TQT3WT_TQScrollBar) {
		if (active) {
			sflags |= TQStyle::Style_Active;
		}
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
	}
	else if (wt == TQT3WT_TQLineEdit) {
		if (active) {
			sflags |= TQStyle::Style_Down;
		}
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
		sflags |= TQStyle::Style_Sunken;
	}
	else {
		if (active) {
			sflags |= TQStyle::Style_Down;
		}
		if (prelight) {
			sflags |= TQStyle::Style_MouseOver;
		}
		if (focused) {
			sflags |= TQStyle::Style_HasFocus;
		}
		if (!disabled) {
			sflags |= TQStyle::Style_Enabled;
		}
		if (has_focus) {
			sflags |= TQStyle::Style_HasFocus;
		}
	}

	return sflags;
}

static TQColorGroup::ColorRole backgroundModeToColorRole(TQt::BackgroundMode mode) {
	TQColorGroup::ColorRole ret = TQColorGroup::Background;

	if (mode == TQt::PaletteForeground) {
		ret = TQColorGroup::Foreground;
	}
	else if (mode == TQt::PaletteBackground) {
		ret = TQColorGroup::Background;
	}
	else if (mode == TQt::PaletteButton) {
		ret = TQColorGroup::Button;
	}
	else if (mode == TQt::PaletteLight) {
		ret = TQColorGroup::Light;
	}
	else if (mode == TQt::PaletteMidlight) {
		ret = TQColorGroup::Midlight;
	}
	else if (mode == TQt::PaletteDark) {
		ret = TQColorGroup::Dark;
	}
	else if (mode == TQt::PaletteMid) {
		ret = TQColorGroup::Mid;
	}
	else if (mode == TQt::PaletteText) {
		ret = TQColorGroup::Text;
	}
	else if (mode == TQt::PaletteBrightText) {
		ret = TQColorGroup::BrightText;
	}
	else if (mode == TQt::PaletteButtonText) {
		ret = TQColorGroup::ButtonText;
	}
	else if (mode == TQt::PaletteBase) {
		ret = TQColorGroup::Base;
	}
	else if (mode == TQt::PaletteShadow) {
		ret = TQColorGroup::Shadow;
	}
	else if (mode == TQt::PaletteHighlight) {
		ret = TQColorGroup::Highlight;
	}
	else if (mode == TQt::PaletteHighlightedText) {
		ret = TQColorGroup::HighlightedText;
	}
	else if (mode == TQt::PaletteLink) {
		ret = TQColorGroup::Link;
	}
	else if (mode == TQt::PaletteLinkVisited) {
		ret = TQColorGroup::LinkVisited;
	}

	return ret;
}

void gtkRangeToCeData(GtkRange* rangeWidget, TQStyleControlElementData &ceData) {
	gint slider_start_pos;
	gint slider_end_pos;
	GtkAdjustment* adjustment = gtk_range_get_adjustment(rangeWidget);
	gtk_range_get_slider_range(rangeWidget, &slider_start_pos, &slider_end_pos);

	ceData.minSteps = gtk_adjustment_get_lower(adjustment);
	ceData.maxSteps = gtk_adjustment_get_upper(adjustment);
// 	ceData.tickMarkSetting =
// 	ceData.tickInterval =
	ceData.currentStep = gtk_adjustment_get_value(adjustment);
	ceData.startStep = slider_start_pos;
	ceData.lineStep = gtk_adjustment_get_step_increment(adjustment);
	ceData.pageStep = gtk_adjustment_get_page_increment(adjustment);
}

void gtkScaleToSliderCeData(GtkScale* scaleWidget, TQStyleControlElementData &ceData) {
	gtkRangeToCeData(GTK_RANGE(scaleWidget), ceData);

// 	GtkPositionType valuePosition = gtk_scale_get_value_pos(scaleWidget);
// 	if (valuePosition == GTK_POS_LEFT) {
// 		ceData.tickMarkSetting = TQSlider::Left;
// 	}
// 	else if (valuePosition == GTK_POS_RIGHT) {
// 		ceData.tickMarkSetting = TQSlider::Right;
// 	}
// 	else if (valuePosition == GTK_POS_TOP) {
// 		ceData.tickMarkSetting = TQSlider::Above;
// 	}
// 	else if (valuePosition == GTK_POS_BOTTOM) {
// 		ceData.tickMarkSetting = TQSlider::Below;
// 	}
// 	else {
		ceData.tickMarkSetting = TQSlider::NoMarks;
// 	}
}

void gtkScrollbarToScrollbarCeData(GtkScrollbar* scrollbarWidget, TQStyleControlElementData &ceData) {
	GtkRange* rangeWidget = GTK_RANGE(scrollbarWidget);
	gtkRangeToCeData(rangeWidget, ceData);

	gint slider_start_pos;
	gint slider_end_pos;
	GtkAdjustment* adjustment = gtk_range_get_adjustment(rangeWidget);
	gtk_range_get_slider_range(rangeWidget, &slider_start_pos, &slider_end_pos);

	ceData.minSteps = gtk_adjustment_get_lower(adjustment);
	ceData.maxSteps = (gtk_adjustment_get_upper(adjustment)-(gtk_adjustment_get_page_increment(adjustment)+gtk_adjustment_get_step_increment(adjustment)));
	ceData.currentStep = gtk_adjustment_get_value(adjustment);
	ceData.startStep = slider_start_pos;
	ceData.lineStep = gtk_adjustment_get_step_increment(adjustment);
	ceData.pageStep = gtk_adjustment_get_page_increment(adjustment);

	// Convert the GTK slider length into a correct pagestep that TQt3 can use to obtain the same slider length value
	TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
	int gtkSliderLength = slider_end_pos - slider_start_pos;
	uint range = ceData.maxSteps - ceData.minSteps;
	int sbextent = tqApp->style().pixelMetric(TQStyle::PM_ScrollBarExtent, ceData, elementFlags, NULL);
	int maxlen = ((ceData.orientation == TQt::Horizontal) ? ceData.rect.width() : ceData.rect.height()) - (sbextent * 2);
	int gtkPageStep=ceil((-1.0)*(range*gtkSliderLength)/(gtkSliderLength-maxlen));
	ceData.pageStep = gtkPageStep;
}

static void
draw_combobox_frame(DRAW_ARGS, const GtkWidgetPath* path, GtkStateFlags state, GtkWidget* widget) {
	cairo_save(cr);

	cairo_matrix_t gtk_matrix;
	cairo_get_matrix(cr, &gtk_matrix);
	gtk_matrix.x0 = 0;
	gtk_matrix.y0 = 0;
	cairo_set_matrix(cr, &gtk_matrix);

	GtkWidget* parent(widget?gtk_widget_get_parent(widget):0L);
	if (GTK_IS_COMBO_BOX(parent)) {
		const GtkAllocation allocation = Gtk::gtk_widget_get_allocation(parent);
		TQRect boundingRect(0, 0, allocation.width, allocation.height);
		TQt3CairoPaintDevice pd2(NULL, allocation.x, allocation.y, allocation.width, allocation.height, cr);
		TQPainter p2(&pd2);

		TQStringList objectTypes;
		objectTypes.append(TQCOMBOBOX_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;

		if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY)) {
			elementFlags = elementFlags | TQStyle::CEF_IsEditable;
		}

		ceData.rect = boundingRect;

		if (gtk_widget_has_visible_focus(widget)) {
			elementFlags = elementFlags | TQStyle::CEF_HasFocus;
		}

		// Draw item
		//tqApp->style().drawComplexControl(TQStyle::CC_ComboBox, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget), TQStyle::SC_ComboBoxFrame, TQStyle::SC_None);
		tqApp->style().drawComplexControl(TQStyle::CC_ComboBox, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget), TQStyle::SC_All, TQStyle::SC_None);
	}

	cairo_restore(cr);
}

static void
draw_progressbar_frame(DRAW_ARGS, const GtkWidgetPath* path, GtkStateFlags state, GtkWidget* widget) {
	cairo_save(cr);

	cairo_matrix_t gtk_matrix;
	cairo_get_matrix(cr, &gtk_matrix);
	gtk_matrix.x0 = 0;
	gtk_matrix.y0 = 0;
	cairo_set_matrix(cr, &gtk_matrix);

	if (GTK_IS_PROGRESS_BAR(widget)) {
		const GtkAllocation allocation = Gtk::gtk_widget_get_allocation(widget);
		TQRect boundingRect(0, 0, allocation.width, allocation.height);
		TQt3CairoPaintDevice pd2(NULL, allocation.x, allocation.y, allocation.width, allocation.height, cr);
		TQPainter p2(&pd2);

		TQStringList objectTypes;
		objectTypes.append(TQPROGRESSBAR_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);
	
		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;
	
		GtkProgressBar* progressBar = GTK_PROGRESS_BAR(widget);
		gdouble gtkProgressBarFraction = gtk_progress_bar_get_fraction(progressBar);
		ceData.totalSteps = 8192;
		ceData.currentStep = gtkProgressBarFraction*8192;
		ceData.percentageVisible = false;

		TQStyle::SFlags sflags = gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget);
		sflags = sflags | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default);

		TQRect progressBarGrooveRect;
		TQRect progressBarContentsRect;

		if (gtk_widget_has_visible_focus(widget)) {
			elementFlags = elementFlags | TQStyle::CEF_HasFocus;
		}

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Base);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p2, brush)

		// Draw frame
		progressBarGrooveRect = TQStyle::visualRect(tqApp->style().subRect(TQStyle::SR_ProgressBarGroove, ceData, elementFlags, NULL), ceData, elementFlags);
		progressBarContentsRect = TQStyle::visualRect(tqApp->style().subRect(TQStyle::SR_ProgressBarContents, ceData, elementFlags, NULL), ceData, elementFlags);

		tqApp->style().drawControl(TQStyle::CE_ProgressBarGroove, &p2, ceData, elementFlags, progressBarGrooveRect, ((state & GTK_STATE_FLAG_INSENSITIVE)?objectPalette.disabled():objectPalette.active()), sflags);

		// Draw contents
		if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL)) {
			// If vertical, apply a 90 degree rotation matrix to the painter
			// This is required to make TQt draw a vertical progress bar
			TQWMatrix m;

// 			// Upside down
// 			m.rotate(90.0);
// 			m.translate(0, (allocation.width)*(-1.0));

			// Right side up
			m.rotate(-90.0);
			m.translate((allocation.height)*(-1.0), 0);

			p2.setWorldMatrix(m, TRUE);

			boundingRect = TQRect(0, 0, allocation.height, allocation.width);
			ceData.rect = boundingRect;
		}

		progressBarGrooveRect = TQStyle::visualRect(tqApp->style().subRect(TQStyle::SR_ProgressBarGroove, ceData, elementFlags, NULL), ceData, elementFlags);
		progressBarContentsRect = TQStyle::visualRect(tqApp->style().subRect(TQStyle::SR_ProgressBarContents, ceData, elementFlags, NULL), ceData, elementFlags);

		tqApp->style().drawControl(TQStyle::CE_ProgressBarContents, &p2, ceData, elementFlags, progressBarContentsRect, ((state & GTK_STATE_FLAG_INSENSITIVE)?objectPalette.disabled():objectPalette.active()), sflags);
	}

	cairo_restore(cr);
}

static void
draw_slider_frame(DRAW_ARGS, const GtkWidgetPath* path, GtkStateFlags state, GtkWidget* widget) {
	cairo_save(cr);

	cairo_matrix_t gtk_matrix;
	cairo_get_matrix(cr, &gtk_matrix);
	gtk_matrix.x0 = 0;
	gtk_matrix.y0 = 0;
	cairo_set_matrix(cr, &gtk_matrix);

	if (GTK_IS_SCALE(widget)) {
		const GtkAllocation allocation = Gtk::gtk_widget_get_allocation(widget);

		GdkRectangle rangeRect;
		gtk_range_get_range_rect(GTK_RANGE(widget), &rangeRect);

		TQRect boundingRect(0, 0, rangeRect.width, rangeRect.height);
		TQt3CairoPaintDevice pd2(NULL, allocation.x + rangeRect.x, allocation.y + rangeRect.y, rangeRect.width, rangeRect.height, cr);
		TQPainter p2(&pd2);

		bool mousedown = (state & GTK_STATE_FLAG_ACTIVE) != 0;
		bool prelight = (state & GTK_STATE_FLAG_PRELIGHT) != 0;

		GtkScale* scaleWidget = GTK_SCALE(widget);

		TQStringList objectTypes;
		objectTypes.append(TQSLIDER_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;

		gtkScaleToSliderCeData(scaleWidget, ceData);

		if (gtk_widget_has_visible_focus(widget)) {
			elementFlags = elementFlags | TQStyle::CEF_HasFocus;
		}

		if (mousedown) {
			elementFlags = elementFlags | TQStyle::CEF_IsActive;
		}

		if (prelight) {
			elementFlags = elementFlags | TQStyle::CEF_HasMouse;
		}

		// Draw item
		tqApp->style().drawComplexControl(TQStyle::CC_Slider, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQSlider, widget) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default), TQStyle::SC_All, ((mousedown)?TQStyle::SC_All:TQStyle::SC_None));
	}

	cairo_restore(cr);
}

static void
draw_scrollbar_frame(DRAW_ARGS, const GtkWidgetPath* path, GtkStateFlags state, GtkWidget* widget) {
	cairo_save(cr);

	cairo_matrix_t gtk_matrix;
	cairo_get_matrix(cr, &gtk_matrix);
	gtk_matrix.x0 = 0;
	gtk_matrix.y0 = 0;
	cairo_set_matrix(cr, &gtk_matrix);

	if (GTK_IS_SCROLLBAR(widget)) {
		const GtkAllocation allocation = Gtk::gtk_widget_get_allocation(widget);

		GdkRectangle rangeRect;
		gtk_range_get_range_rect(GTK_RANGE(widget), &rangeRect);

		TQRect boundingRect(0, 0, rangeRect.width, rangeRect.height);
		TQt3CairoPaintDevice pd2(NULL, allocation.x + rangeRect.x, allocation.y + rangeRect.y, rangeRect.width, rangeRect.height, cr);
		TQPainter p2(&pd2);

		GtkStateFlags widgetStateFlags = gtk_widget_get_state_flags(widget);

		bool prelight = (state & GTK_STATE_FLAG_PRELIGHT) != 0;

		GtkScrollbar* scrollbarWidget = GTK_SCROLLBAR(widget);

		TQStringList objectTypes;
		objectTypes.append(TQSLIDER_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;

		gtkScrollbarToScrollbarCeData(scrollbarWidget, ceData);

		if (gtk_widget_has_visible_focus(widget)) {
			elementFlags = elementFlags | TQStyle::CEF_HasFocus;
		}

		if (prelight) {
			elementFlags = elementFlags | TQStyle::CEF_HasMouse;
		}

		TQStyle::SFlags sflags = gtkToTQtStyleFlags(engine, state, TQT3WT_TQScrollBar, widget);
		sflags = sflags | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default);

		if (gtk_widget_get_sensitive(widget)) {
			sflags |= TQStyle::Style_Enabled;
			state = (GtkStateFlags)(state & (~GTK_STATE_FLAG_INSENSITIVE));
		}
		else {
			sflags &= ~TQStyle::Style_Enabled;
			state = (GtkStateFlags)(state | GTK_STATE_FLAG_INSENSITIVE);
		}

		// Determine active subcontrols
		gint cursor_x = -1;
		gint cursor_y = -1;
		TQStyle::SubControl activeSubControl = TQStyle::SC_None;
		if (gtk_widget_get_realized(widget)) {
			GdkDevice *device;
			device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(widget)));
			gdk_window_get_device_position(gtk_widget_get_window(widget), device, &cursor_x, &cursor_y, NULL);
			cursor_x = cursor_x - allocation.x;
			cursor_y = cursor_y - allocation.y;

			TQPoint cursor_pos(cursor_x, cursor_y);
			TQRect addline, subline, addpage, subpage, slider, first, last;		
			subline = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarSubLine);
			addline = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarAddLine);
			subpage = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarSubPage);
			addpage = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarAddPage);
			slider  = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarSlider);
			first   = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarFirst);
			last    = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarLast);

			// HACK
			// This may not be 100% reliable, and it has the side effect of triggering the page step activity effect when the slider is dragged quickly and the mouse cursor momentarily pops out of the slider rectangle.
			GdkModifierType mouseStateFlags;
			gdk_device_get_state (device, gtk_widget_get_window(widget), NULL, &mouseStateFlags);
			bool mousedown = (mouseStateFlags & GDK_BUTTON1_MASK);

			if (mousedown) {
				if (subline.contains(cursor_pos)) {
					activeSubControl = (TQStyle::SubControl)(activeSubControl | TQStyle::SC_ScrollBarSubLine);
				}
				if (addline.contains(cursor_pos)) {
					activeSubControl = (TQStyle::SubControl)(activeSubControl | TQStyle::SC_ScrollBarAddLine);
				}
				if (subpage.contains(cursor_pos)) {
					activeSubControl = (TQStyle::SubControl)(activeSubControl | TQStyle::SC_ScrollBarSubPage);
				}
				if (addpage.contains(cursor_pos)) {
					activeSubControl = (TQStyle::SubControl)(activeSubControl | TQStyle::SC_ScrollBarAddPage);
				}
				if (slider.contains(cursor_pos)) {
					activeSubControl = (TQStyle::SubControl)(activeSubControl | TQStyle::SC_ScrollBarSlider);
				}
				if (first.contains(cursor_pos)) {
					activeSubControl = (TQStyle::SubControl)(activeSubControl | TQStyle::SC_ScrollBarFirst);
				}
				if (last.contains(cursor_pos)) {
					activeSubControl = (TQStyle::SubControl)(activeSubControl | TQStyle::SC_ScrollBarLast);
				}
			}
		}

		// Draw item
		tqApp->style().drawComplexControl(TQStyle::CC_ScrollBar, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), sflags, TQStyle::SC_All, activeSubControl);
	}

	cairo_restore(cr);
}

static void
draw_checkbox(DRAW_ARGS, const GtkWidgetPath* path, GtkStateFlags state, GtkWidget* widget, TQt3WidgetType tqt3WidgetType) {
	TQStringList objectTypes;
	objectTypes.append(TQCHECKBOX_OBJECT_NAME_STRING);
	TQPalette objectPalette = tqApp->palette(objectTypes);

	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd2(NULL, x, y, width, height, cr);
	TQPainter p2(&pd2);

	TQStyleControlElementData ceData;
	TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
	ceData.widgetObjectTypes = objectTypes;
	ceData.rect = boundingRect;

	if (gtk_widget_has_visible_focus(widget)) {
		elementFlags = elementFlags | TQStyle::CEF_HasFocus;
	}

	// Draw item
	tqApp->style().drawControl(TQStyle::CE_CheckBox, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, tqt3WidgetType, widget));
}

static void
draw_radiobutton(DRAW_ARGS, const GtkWidgetPath* path, GtkStateFlags state, GtkWidget* widget, TQt3WidgetType tqt3WidgetType) {
	TQStringList objectTypes;
	objectTypes.append(TQCHECKBOX_OBJECT_NAME_STRING);
	TQPalette objectPalette = tqApp->palette(objectTypes);

	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd2(NULL, x, y, width, height, cr);
	TQPainter p2(&pd2);

	TQStyleControlElementData ceData;
	TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
	ceData.widgetObjectTypes = objectTypes;
	ceData.rect = boundingRect;

	if (gtk_widget_has_visible_focus(widget)) {
		elementFlags = elementFlags | TQStyle::CEF_HasFocus;
	}

	// Draw item
	tqApp->style().drawControl(TQStyle::CE_RadioButton, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, tqt3WidgetType, widget));
}

static void
draw_pushbutton(DRAW_ARGS, const GtkWidgetPath* path, GtkStateFlags state, GtkWidget* widget, TQt3WidgetType tqt3WidgetType) {
	TQStringList objectTypes;
	objectTypes.append(TQCHECKBOX_OBJECT_NAME_STRING);
	TQPalette objectPalette = tqApp->palette(objectTypes);

	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd2(NULL, x, y, width, height, cr);
	TQPainter p2(&pd2);

	TQStyleControlElementData ceData;
	TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
	ceData.widgetObjectTypes = objectTypes;
	ceData.rect = boundingRect;

	if (gtk_widget_has_default(widget)) {
		elementFlags = elementFlags | TQStyle::CEF_IsDefault;
	}
	if (gtk_widget_has_visible_focus(widget)) {
		elementFlags = elementFlags | TQStyle::CEF_HasFocus;
	}

	// Draw item
	tqApp->style().drawControl(TQStyle::CE_PushButton, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, tqt3WidgetType, widget));
}

static void
draw_toolbar_button(DRAW_ARGS, const GtkWidgetPath* path, GtkStateFlags state, GtkWidget* widget, TQt3WidgetType tqt3WidgetType) {
	bool mousedown = (state & GTK_STATE_FLAG_ACTIVE) != 0;

	TQStringList objectTypes;
	objectTypes.append(TQTOOLBUTTON_OBJECT_NAME_STRING);
	TQPalette objectPalette = tqApp->palette(objectTypes);

	TQStyleControlElementData ceData;
	TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
	ceData.widgetObjectTypes = objectTypes;
	ceData.colorGroup = ((state & GTK_STATE_FLAG_INSENSITIVE)?objectPalette.disabled():objectPalette.active());
	ceData.orientation = TQt::Horizontal;

	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd2(NULL, x, y, width, height, cr);
	TQPainter p2(&pd2);

	ceData.rect = boundingRect;

	GtkWidget* parent = (widget)?Gtk::gtk_widget_find_parent(widget, GTK_TYPE_TOOLBAR):0L;
	if (parent) {
		TQStringList parentObjectTypes;
		parentObjectTypes.append(TQTOOLBAR_OBJECT_NAME_STRING);
		TQPalette parentObjectPalette = tqApp->palette(parentObjectTypes);
		const GtkAllocation allocation = Gtk::gtk_widget_get_allocation(parent);

		ceData.parentWidgetData.widgetObjectTypes = parentObjectTypes;
		ceData.parentWidgetData.rect = TQRect(0, 0, allocation.width, allocation.height);
		ceData.parentWidgetData.colorGroup = ((state & GTK_STATE_FLAG_INSENSITIVE)?parentObjectPalette.disabled():parentObjectPalette.active());
	}

	// Draw item
	tqApp->style().drawComplexControl(TQStyle::CC_ToolButton, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, tqt3WidgetType, widget), TQStyle::SC_ToolButton, ((mousedown)?TQStyle::SC_ToolButton:TQStyle::SC_None));
}

/* draw a texture placed on the centroid */
static gboolean
draw_centroid_texture (GtkThemingEngine *engine,
                       cairo_t          *cr,
                       gdouble           x,
                       gdouble           y,
                       gdouble           width,
                       gdouble           height)
{
  GtkStateFlags state;
  GValue value = { 0, };
  cairo_pattern_t *texture = NULL;
  cairo_surface_t *surface = NULL;
  gboolean retval = FALSE;

  state = gtk_theming_engine_get_state (engine);

  gtk_theming_engine_get_property (engine, "-tdegtk-centroid-texture", state, &value);

  if (!G_VALUE_HOLDS_BOXED (&value))
    return FALSE;

  texture = (cairo_pattern_t*)g_value_dup_boxed (&value);
  g_value_unset (&value);

  if (texture != NULL)
    cairo_pattern_get_surface (texture, &surface);

  if (surface != NULL)
    {
      cairo_save (cr);

      cairo_set_source_surface (cr, surface, (gint) (x + width / 2 - cairo_image_surface_get_width (surface) / 2),
                                             (gint) (y + height / 2 - cairo_image_surface_get_height (surface) / 2));
      cairo_paint (cr);

      cairo_restore (cr);

      retval = TRUE;
    }

  if (texture != NULL)
    cairo_pattern_destroy (texture);

  return retval;
}

static void
tdegtk_draw_activity (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_widget_path_is_type(path, GTK_TYPE_PROGRESS_BAR)) {
#if 0
		TQStringList objectTypes;
		objectTypes.append(TQPROGRESSBAR_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;

		TQStyle::SFlags sflags = gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget);
		sflags = sflags | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default);

		TQRect progressBarRect = TQStyle::visualRect(tqApp->style().subRect(TQStyle::SR_ProgressBarContents, ceData, elementFlags, NULL), ceData, elementFlags);

		// Draw item
		tqApp->style().drawControl(TQStyle::CE_ProgressBarContents, &p, ceData, elementFlags, progressBarRect, ((state & GTK_STATE_FLAG_INSENSITIVE)?objectPalette.disabled():objectPalette.active()), sflags);
#else
		// Do nothing
#endif
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,0,128);
		printf("[WARNING] tdegtk_draw_activity() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}

	p.end();
}

static void
tdegtk_draw_arrow (GtkThemingEngine *engine,
                  cairo_t          *cr,
                  gdouble           angle,
                  gdouble           x,
                  gdouble           y,
                  gdouble           size)
{
	cairo_save(cr);
	cairo_reset_clip(cr);

	TQRect boundingRect(0, 0, size, size);
	TQt3CairoPaintDevice *pd = NULL;
	TQPainter *p = NULL;

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	GtkWidget* parent(widget?gtk_widget_get_parent(widget):0L);

	GtkArrowType arrow_direction;

	if ((angle <= ((G_PI/2)-(G_PI/4))) || (angle > ((3*(G_PI/2))+(G_PI/4)))) {
		arrow_direction = GTK_ARROW_UP;
	}
	else if ((angle <= ((G_PI)-(G_PI/4))) && (angle > ((0)+(G_PI/4)))) {
		arrow_direction = GTK_ARROW_RIGHT;
	}
	else if ((angle <= ((3*(G_PI/2))-(G_PI/4))) && (angle > ((G_PI/2)+(G_PI/4)))) {
		arrow_direction = GTK_ARROW_DOWN;
	}
	else {
		arrow_direction = GTK_ARROW_LEFT;
	}

#if 0
	if (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_COMBO_BOX)) {
		// Do nothing
	}

	else
#endif
	if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCROLLBAR)) {
#ifdef DRAW_SCROLLBAR_PIECES_INSTEAD_OF_ENTIRE_BAR
		TQStringList objectTypes;
		objectTypes.append(TQSCROLLBAR_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		GtkRange* rangeWidget = GTK_RANGE(widget);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.orientation = ((arrow_direction == GTK_ARROW_UP) || (arrow_direction == GTK_ARROW_DOWN))?TQt::Vertical:TQt::Horizontal;
		bool subline = ((arrow_direction == GTK_ARROW_DOWN) || (arrow_direction == GTK_ARROW_RIGHT))?false:true;

		bool combine_addlineregion_drawing_areas = tqApp->style().styleHint(TQStyle::SH_ScrollBar_CombineAddLineRegionDrawingAreas);
		const GtkAllocation allocation = Gtk::gtk_widget_get_allocation(widget);

		TQStyle::SFlags sflags = gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget);
		sflags = sflags | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default);

		if (combine_addlineregion_drawing_areas) {
			int newx = x;
			int newy = y;
			int neww = size;
			int newh = size;
			if (!subline) {
				if (ceData.orientation == TQt::Horizontal) {
					if ((x+m_scrollBarSubLineWidth) == allocation.width) {
						newx = x-m_scrollBarSubLineWidth;
					}
					boundingRect.setWidth(m_scrollBarSubLineWidth*2);
					neww = m_scrollBarSubLineWidth*2;
				}
				else {
					if ((y+m_scrollBarSubLineWidth) == allocation.height) {
						newy = y-m_scrollBarSubLineWidth;
					}
					boundingRect.setHeight(m_scrollBarSubLineWidth*2);
					newh = m_scrollBarSubLineWidth*2;
				}
			}
			pd = new TQt3CairoPaintDevice(NULL, newx, newy, neww, newh, cr);
			p = new TQPainter(pd);

			if (!subline) {
				if (ceData.orientation == TQt::Horizontal) {
					p->setClipRect(TQRect(0+m_scrollBarSubLineWidth, 0, m_scrollBarSubLineWidth, newh));
				}
				else {
					p->setClipRect(TQRect(0, 0+m_scrollBarSubLineWidth, neww, m_scrollBarSubLineWidth));
				}
			}
		}
		else {
			pd = new TQt3CairoPaintDevice(NULL, x, y, size, size, cr);
			p = new TQPainter(pd);
		}

		ceData.rect = boundingRect;

		gtkRangeToCeData(rangeWidget, ceData);

		// Draw slider arrow buttons
		TQRect scrollpagerect = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, (subline)?TQStyle::SC_ScrollBarSubLine:TQStyle::SC_ScrollBarAddLine, sflags);
		if (ceData.orientation == TQt::Vertical) {
			scrollpagerect.setY(ceData.rect.y());
			scrollpagerect.setHeight(ceData.rect.height());
		}
		else {
			scrollpagerect.setX(ceData.rect.x());
			scrollpagerect.setWidth(ceData.rect.width());
		}
		tqApp->style().drawPrimitive((subline)?TQStyle::PE_ScrollBarSubLine:TQStyle::PE_ScrollBarAddLine, p, scrollpagerect, gtkToTQtColorGroup(engine, state), sflags);
#else
		// Draw nothing
#endif
	}

	else if (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_COMBO_BOX) && (!(GTK_IS_MENU_ITEM(widget) || GTK_IS_MENU_ITEM(parent) || (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM))))) {
		// Do nothing
	}

	else {
		pd = new TQt3CairoPaintDevice(NULL, x, y, size, size, cr);
		p = new TQPainter(pd);

		// Draw arrow
		TQStyle::PrimitiveElement pe;
		if (arrow_direction == GTK_ARROW_UP) {
			pe = TQStyle::PE_ArrowUp;
		}
		else if (arrow_direction == GTK_ARROW_DOWN) {
			pe = TQStyle::PE_ArrowDown;
		}
		else if (arrow_direction == GTK_ARROW_LEFT) {
			pe = TQStyle::PE_ArrowLeft;
		}
		else {
			pe = TQStyle::PE_ArrowRight;
		}
		tqApp->style().drawPrimitive(pe, p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
	}
	
	if (p) {
		p->end();
		delete p;
	}
	if (pd) {
		delete pd;
	}

	cairo_restore(cr);
}

static void
tdegtk_draw_cell_background (DRAW_ARGS,
                            GtkRegionFlags flags)
{
	cairo_save(cr);
	cairo_reset_clip(cr);

	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
		TQStringList objectTypes;
		objectTypes.append(TQLISTVIEW_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		if ((state & GTK_STATE_FLAG_SELECTED) != 0) {
			ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Highlight);
		}
		else {
			ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Base);
		}

		TQListViewItem tqt3ListViewItem;
		TQStyleOption listViewItemOpt(&tqt3ListViewItem);

		// Draw item
		tqApp->style().drawComplexControl(TQStyle::CC_ListView, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget), TQStyle::SC_ListView, TQStyle::SC_All, listViewItemOpt);
	}

	// FIXME
	// GtkCellRenderer backgrounds should be drawn here, however GTK3 does not provide any means for a GtkCellRenderer to call style engine methods!
	// See upstream GTK bug #687677

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,128,64);
		printf("[WARNING] tdegtk_draw_cell_background() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}

	p.end();

	cairo_restore(cr);
}

static void
tdegtk_draw_cell_frame (DRAW_ARGS,
                       GtkRegionFlags flags)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

#if 0
	if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
		TQStringList objectTypes;
		objectTypes.append(TQLISTVIEW_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		if ((state & GTK_STATE_FLAG_SELECTED) != 0) {
			ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Highlight);
		}
		else {
			ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Base);
		}

		TQListViewItem tqt3ListViewItem;
		TQStyleOption listViewItemOpt(&tqt3ListViewItem);

		TQRect paintDeviceRect;
		TQRect backgroundRect;

		// Draw item
		tqApp->style().drawComplexControl(TQStyle::CC_ListView, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget), TQStyle::SC_ListView, TQStyle::SC_All, listViewItemOpt);
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,64,64);
		printf("[WARNING] tdegtk_draw_cell_background() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}
#endif

	p.end();
}

static void
tdegtk_draw_check (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
		draw_checkbox(engine, cr, x, y, width, height, path, state, widget, TQT3WT_GTKTreeViewCell);
	}
	else {
		draw_checkbox(engine, cr, x, y, width, height, path, state, widget, TQT3WT_TQCheckBox);
	}
	p.end();
}

static void
tdegtk_draw_common (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	DEBUG_FILL_BACKGROUND_WITH_COLOR(p,0,255,255);

	GtkStateFlags state;
	state = gtk_theming_engine_get_state(engine);
	//tqApp->style().drawPrimitive(TQStyle::PE_Indicator, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
	
	p.end();
}

static void
tdegtk_draw_common_background (DRAW_ARGS)
{
	cairo_save(cr);
	cairo_reset_clip(cr);

	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCROLLBAR)) {
#ifdef DRAW_SCROLLBAR_PIECES_INSTEAD_OF_ENTIRE_BAR
		TQStringList objectTypes;
		objectTypes.append(TQSCROLLBAR_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		GtkRange* rangeWidget = GTK_RANGE(widget);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;

		gtkRangeToCeData(rangeWidget, ceData);

		// Draw frame
		tqApp->style().drawPrimitive(TQStyle::PE_PanelLineEdit, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
#else
		draw_scrollbar_frame(engine, cr, x, y, width, height, path, state, widget);
#endif
	}

	else if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_FRAME) || gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY) || gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BUTTON)) && (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_COMBO_BOX))) {
		draw_combobox_frame(engine, cr, x, y, width, height, path, state, widget);
	}

	else if ((gtk_widget_path_is_type(path, GTK_TYPE_ENTRY))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_VIEW))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_BUFFER))
		|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY))
		|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_COMBOBOX_ENTRY))
		) {
		TQStringList objectTypes;
		objectTypes.append(TQLINEEDIT_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Base);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
	}

#if 0
	else if (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_COMBO_BOX)) {
		bool mousedown = (state & GTK_STATE_FLAG_ACTIVE) != 0;

		TQStringList objectTypes;
		objectTypes.append(TQCOMBOBOX_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;

		if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY)) {
			elementFlags = elementFlags | TQStyle::CEF_IsEditable;
		}

		ceData.rect = boundingRect;

		// Draw item
		tqApp->style().drawComplexControl(TQStyle::CC_ComboBox, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget), TQStyle::SC_ComboBoxEditField, TQStyle::SC_None);
	}
#endif

	else if (gtk_widget_path_is_type(path, GTK_TYPE_BUTTON)) {
#if 0
		TQStringList objectTypes;
		objectTypes.append(TQBUTTON_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		if (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_TOOLBAR)) {
			// Draw background
			TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
			DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
		}
		else if (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_TREE_VIEW)) {
			// Draw background
			TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
			DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
		}
		else {
			draw_pushbutton(engine, cr, x, y, width, height, path, state, widget, TQT3WT_TQPushButton);
		}
#else
		// Draw nothing!
#endif
	}

	else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_TOOLBAR)) {
		TQStringList objectTypes;
		objectTypes.append(TQTOOLBAR_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
	}

	else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUBAR)) {
		TQStringList objectTypes;
		objectTypes.append(TQMENUBAR_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
	}

	else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_TOOLTIP)) {
		TQStringList objectTypes;
		objectTypes.append(TQTIPLABEL_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
	}

	else if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENU)) || (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM))) {
		GtkWidget* parent(widget?gtk_widget_get_parent(widget):0L);
		if (!GTK_IS_MENU_BAR(parent)) {
			// FIXME
			// Mouse movements in the popup menu should be tracked similarly to mouse movements in the tab bar
			// Many TQt3 styles highlight inactive menu items on hover; not providing this visual feedback may cause users to briefly think their GTK application has frozen up
	
// 			// Register menu item with animation engine
// 			m_animations.menuItemEngine().registerWidget(widget);
// 	
// 			// Check tab properties
// 			int tabIndex = Gtk::gtk_notebook_find_tab(widget, x+width/2, y+height/2);
// 			m_animations.tabWidgetEngine().updateTabRect(widget, tabIndex, x, y, width, height);
// 			bool prelight = (tabIndex == m_animations.tabWidgetEngine().hoveredTab(widget));
// 			GtkMenuItem* menuitem = GTK_MENU_ITEM(widget);
// 			const int currentPage = gtk_notebook_get_current_page(notebook);
// 			const int numPages = gtk_notebook_get_n_pages(notebook);
// 			bool selectedTab = (tabIndex==currentPage);

			TQStringList objectTypes;
			objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
			TQPalette objectPalette = tqApp->palette(objectTypes);

			bool pressed = false;
			bool prelight = false;

			TQStyleControlElementData ceData;
			TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
			ceData.widgetObjectTypes = objectTypes;
			ceData.rect = boundingRect;

			TQMenuItem tqt3MenuItem;
			int maxAcceleratorTextWidth = 0;
			int maxIconWidth = IconSize(KIcon::Small) + 4;
			TQStyleOption menuOpt(&tqt3MenuItem, maxIconWidth, maxAcceleratorTextWidth);

// 			if (???) elementFlags = elementFlags | TQStyle::TQStyle::CEF_IsCheckable;

			TQRect paintDeviceRect;
			TQRect backgroundRect;

			// Draw item
			tqApp->style().drawControl(TQStyle::CE_PopupMenuItem, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQMenuItem, widget) | ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM))?TQStyle::Style_Active:TQStyle::Style_Default) | ((pressed)?TQStyle::Style_Down:TQStyle::Style_Default) | ((prelight)?TQStyle::Style_MouseOver:TQStyle::Style_Default), menuOpt);
		}
	}

	else if (gtk_widget_path_is_type(path, GTK_TYPE_NOTEBOOK)) {
		TQStringList objectTypes;
		objectTypes.append(TQTABWIDGET_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
	}

	else if (gtk_widget_path_is_type(path, GTK_TYPE_PROGRESS_BAR)) {
		// Do nothing; backround is drawn in frame drawing routine
	}

	else if (gtk_widget_path_is_type(path, GTK_TYPE_HANDLE_BOX)) {
		TQStringList objectTypes;
		objectTypes.append(TQDOCKWINDOWHANDLE_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
	}

	else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_CELL)) {
		TQStringList objectTypes;
		objectTypes.append(TQLISTVIEW_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		if ((state & GTK_STATE_FLAG_SELECTED) != 0) {
			ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Highlight);
		}
		else {
			ceData.viewportData.bgBrush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Base);
		}

		TQListViewItem tqt3ListViewItem;
		TQStyleOption listViewItemOpt(&tqt3ListViewItem);

		// Draw item
		tqApp->style().drawComplexControl(TQStyle::CC_ListView, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget), TQStyle::SC_ListView, TQStyle::SC_All, listViewItemOpt);
	}

	else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCALE) /*&& gtk_theming_engine_has_class (engine, GTK_STYLE_CLASS_TROUGH)*/) {
		draw_slider_frame(engine, cr, x, y, width, height, path, state, widget);
	}

	else if (gtk_widget_path_is_type(path, GTK_TYPE_IMAGE)) {
		// Do nothing
	}

	else if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BACKGROUND))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_EXPANDER))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_BOX))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_VIEWPORT))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_SCROLLED_WINDOW))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_PANED))
		) {
		TQStringList objectTypes;
		objectTypes.append(TQWIDGET_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,0,0,255);
		printf("[WARNING] tdegtk_draw_common_background() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}

	p.end();

	cairo_restore(cr);
}

static void
tdegtk_draw_common_frame (DRAW_ARGS)
{
	cairo_save(cr);
	cairo_reset_clip(cr);

	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	TQString widgetPath(Gtk::gtk_widget_path(widget));

	if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCROLLBAR)) {
#ifdef DRAW_SCROLLBAR_PIECES_INSTEAD_OF_ENTIRE_BAR
		if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BUTTON)) {
			// Scrollbar buttons are drawn in the arrow handler
		}
		else {
			TQStringList objectTypes;
			objectTypes.append(TQSCROLLBAR_OBJECT_NAME_STRING);
			TQPalette objectPalette = tqApp->palette(objectTypes);

			GtkRange* rangeWidget = GTK_RANGE(widget);
	
			TQStyleControlElementData ceData;
			TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
			ceData.widgetObjectTypes = objectTypes;
			ceData.rect = boundingRect;
			ceData.orientation = ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal);

			gtkRangeToCeData(rangeWidget, ceData);
	
			// Draw background
			// HACK
			// PE_ScrollBarAddPage and PE_ScrollBarSubPage are separate in TQt3
			// Apparently there is no such distinction in GTK3!
			TQRect scrollpagerect = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarAddPage, gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
			if (ceData.orientation == TQt::Vertical) {
				scrollpagerect.setY(ceData.rect.y());
				scrollpagerect.setHeight(ceData.rect.height());
			}
			else {
				scrollpagerect.setX(ceData.rect.x());
				scrollpagerect.setWidth(ceData.rect.width());
			}
			tqApp->style().drawPrimitive(TQStyle::PE_ScrollBarAddPage, &p, scrollpagerect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
		}
#else
		// Do nothing...
#endif
	}

	else if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_FRAME) || gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY) || gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BUTTON)) && (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_COMBO_BOX))) {
		draw_combobox_frame(engine, cr, x, y, width, height, path, state, widget);
	}

	else {
		if (gtk_widget_path_is_type(path, GTK_TYPE_BUTTON)) {
			if (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_TOOLBAR)) {
				draw_toolbar_button(engine, cr, x, y, width, height, path, state, widget, TQT3WT_TQToolButton);
			}
			else if (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_TREE_VIEW)) {
				// Draw frame
				tqApp->style().drawPrimitive(TQStyle::PE_HeaderSection, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
			}
			else {
				draw_pushbutton(engine, cr, x, y, width, height, path, state, widget, TQT3WT_TQPushButton);
			}
		}

		else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM)) {
			GtkWidget* parent(widget?gtk_widget_get_parent(widget):0L);
			if (GTK_IS_MENU_BAR(parent)) {
				TQStringList objectTypes;
				objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
				TQPalette objectPalette = tqApp->palette(objectTypes);

				// See FIXME in tdegtk_draw_common_background

				bool pressed = true;
				bool prelight = false;
	
				TQStyleControlElementData ceData;
				TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
				ceData.widgetObjectTypes = objectTypes;
				ceData.rect = boundingRect;
				ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;
	
				// Draw frame
				tqApp->style().drawPrimitive(TQStyle::PE_ButtonDropDown, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQMenuItem, widget) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default) | ((pressed)?TQStyle::Style_Down:TQStyle::Style_Default) | ((prelight)?TQStyle::Style_MouseOver:TQStyle::Style_Default));
			}
		}

#if 0
		// FIXME
		// Certain styles (highcolor) paint over the color swatches if this is enabled, rendering the picker useless
		else if (widgetPath.endsWith(".GtkColorSwatch")) {
			TQStringList objectTypes;
			objectTypes.append(TQLINEEDIT_OBJECT_NAME_STRING);
			TQPalette objectPalette = tqApp->palette(objectTypes);
	
			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_PanelLineEdit, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQLineEdit, widget));
		}
#endif

		else if (widgetPath.endsWith(".add-color-button")) {
			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_ButtonBevel, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
		}

		else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY)) {
			TQStringList objectTypes;
			objectTypes.append(TQLINEEDIT_OBJECT_NAME_STRING);
			TQPalette objectPalette = tqApp->palette(objectTypes);
	
			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_PanelLineEdit, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQLineEdit, widget));
		}

		else if (gtk_widget_path_is_type(path, GTK_TYPE_SPIN_BUTTON)) {
			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_ButtonBevel, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQPushButton, widget));
		}

		else if ((gtk_widget_path_is_type(path, GTK_TYPE_HANDLE_BOX))
			|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_TOOLBAR))
			) {
			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_PanelDockWindow, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
		}

		else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUBAR)) {
			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_PanelMenuBar, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
		}

		else if (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_STATUSBAR)) {
			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_StatusBarSection, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
		}

		else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENU)) {
			TQStringList objectTypes;
			objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
			TQPalette objectPalette = tqApp->palette(objectTypes);

			TQStyleControlElementData ceData;
			TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
			ceData.widgetObjectTypes = objectTypes;
			ceData.rect = boundingRect;
			ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;

			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_PanelPopup, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
		}

		else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_TOOLTIP)) {
			TQStringList objectTypes;
			objectTypes.append(TQTOOLTIP_OBJECT_NAME_STRING);
			TQPalette objectPalette = tqApp->palette(objectTypes);
	
			int groupBoxLineWidth = 1;
	
			int lineWidth = 0;

			lineWidth = groupBoxLineWidth;

			// Draw tooltip frame
			qDrawPlainRect(&p, boundingRect, ((state & GTK_STATE_FLAG_INSENSITIVE)?objectPalette.disabled():objectPalette.active()).foreground(), lineWidth);
		}

		else if (gtk_widget_path_is_type(path, GTK_TYPE_PROGRESS_BAR)) {
			draw_progressbar_frame(engine, cr, x, y, width, height, path, state, widget);
		}

		else if (gtk_widget_path_is_type(path, GTK_TYPE_IMAGE)) {
			// Do nothing
		}

		else if (gtk_widget_path_is_type(path, GTK_TYPE_NOTEBOOK)) {
			// Draw frame
			tqApp->style().drawPrimitive(TQStyle::PE_PanelTabWidget, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
		}

		else if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BACKGROUND))
			|| (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_BOX))
			|| (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_EXPANDER))
			|| (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_BOX))
			|| (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_VIEWPORT))
			|| (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_SCROLLED_WINDOW))
			|| (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_PANED))
			) {
			// Do nothing
		}

		else {
			DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,64,255);
			printf("[WARNING] tdegtk_draw_common_frame() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
		}
	}

	p.end();

	cairo_restore(cr);
}

static void
tdegtk_draw_expander (DRAW_ARGS)
{
  GtkStateFlags state;
  GdkRGBA color;
  gint size;
  gdouble angle = G_PI_2;

  state = gtk_theming_engine_get_state (engine);

  gtk_theming_engine_get_color (engine, state, &color);

  cairo_save (cr);

  /* use floor function to adjust doubles */
  size = floor (MIN (width, height));

  x += (gint) (width / 2) - size / 2;
  y += (gint) (height / 2) - size / 2;

  if ((state & GTK_STATE_FLAG_ACTIVE) == 0)
    angle = 0;

  cairo_translate (cr, x + size / 2.0 + 0.5, y + size / 2.0 + 0.5);
  cairo_rotate (cr, angle);
  cairo_translate (cr, size / 4.0, 0);

  /* FIXME this + 1/- 1 is done to fix blurred diagonal lines.
   * I know it's not nice at all, but it fix a visual bug */
  cairo_move_to (cr, - size / 2.0, - size / 2.0);
  cairo_rel_line_to (cr, size / 2.0 + 1, size / 2.0);
  cairo_rel_line_to (cr, - size / 2.0 - 1, size / 2.0);
  cairo_close_path (cr);

  cairo_set_source_rgba (cr, color.red, color.green, color.blue, color.alpha * 0.75);
  cairo_fill_preserve (cr);

  gdk_cairo_set_source_rgba (cr, &color);
  cairo_stroke (cr);

  cairo_restore (cr);
}

static void
tdegtk_draw_extension (DRAW_ARGS,
                      GtkPositionType gap_side)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_NOTEBOOK)) {
		// Register tabbar with animation engine
		m_animations.tabWidgetEngine().registerWidget(widget);

		// Check tab properties
		int tabIndex = Gtk::gtk_notebook_find_tab(widget, x+width/2, y+height/2);
		m_animations.tabWidgetEngine().updateTabRect(widget, tabIndex, x, y, width, height);
		bool prelight = (tabIndex == m_animations.tabWidgetEngine().hoveredTab(widget));
		GtkNotebook* notebook = GTK_NOTEBOOK(widget);
// 		bool firstTab = (tabIndex == 0);
// 		bool lastTab = (tabIndex == gtk_notebook_get_n_pages(notebook)-1);
		const int currentPage = gtk_notebook_get_current_page(notebook);
		const int numPages = gtk_notebook_get_n_pages(notebook);
		bool selectedTab = (tabIndex==currentPage);

		TQStringList objectTypes;
		objectTypes.append(TQTABBAR_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;

		TQTab tqt3Tab;
		tqt3Tab.setIdentifier(tabIndex);
		TQStyleOption tabOpt(&tqt3Tab, (prelight)?&tqt3Tab:(TQTab*)NULL);

		elementFlags = elementFlags | TQStyle::CEF_HasParentWidget;
		ceData.parentWidgetData.widgetObjectTypes.append(TQTABBAR_OBJECT_NAME_STRING);

		int tab_overlap = tqApp->style().pixelMetric(TQStyle::PM_TabBarTabOverlap);
		int tab_to_frame_gap_height = 2;

		ceData.tabBarData.tabCount = numPages;
		ceData.tabBarData.identIndexMap[tqt3Tab.identifier()] = tabIndex;

		TQRect paintDeviceRect;
		TQRect backgroundRect;

		switch (gap_side) {
			default:
			case GTK_POS_TOP:
				ceData.tabBarData.shape = TQTabBar::RoundedBelow;

				paintDeviceRect = TQRect(x-tab_overlap, y-tab_to_frame_gap_height, width+(tab_overlap*2), height+tab_to_frame_gap_height);
				boundingRect = TQRect(0, 0, width+tab_overlap, height+tab_to_frame_gap_height);
				backgroundRect = TQRect(tab_overlap, 0, width, height+2);
				break;
			case GTK_POS_LEFT:
				ceData.tabBarData.shape = TQTabBar::RoundedAbove;
				// FIXME
				// TQt3 does not know how to draw these
				// For now, draw a single unconnected tab in this location
				tabIndex = 0;
				ceData.tabBarData.tabCount = 1;
				tqt3Tab.setIdentifier(tabIndex);
				ceData.tabBarData.identIndexMap[tqt3Tab.identifier()] = tabIndex;

				paintDeviceRect = TQRect(x-tab_to_frame_gap_height, y, width+tab_to_frame_gap_height, height);
				boundingRect = TQRect(0, 0, width, height);
				backgroundRect = TQRect(0, 0, width, height);
				break;
			case GTK_POS_BOTTOM:
				ceData.tabBarData.shape = TQTabBar::RoundedAbove;

				paintDeviceRect = TQRect(x-tab_overlap, y, width+(tab_overlap*2), height+tab_to_frame_gap_height);
				boundingRect = TQRect(0, 0, width+tab_overlap, height+tab_to_frame_gap_height);
				backgroundRect = TQRect(tab_overlap, 0, width, height+2);
				break;
			case GTK_POS_RIGHT:
				ceData.tabBarData.shape = TQTabBar::RoundedAbove;
				// FIXME
				// TQt3 does not know how to draw these
				// For now, draw a single unconnected tab in this location
				tabIndex = 0;
				ceData.tabBarData.tabCount = 1;
				tqt3Tab.setIdentifier(tabIndex);
				ceData.tabBarData.identIndexMap[tqt3Tab.identifier()] = tabIndex;

				paintDeviceRect = TQRect(x, y, width+tab_to_frame_gap_height, height);
				boundingRect = TQRect(0, 0, width, height);
				backgroundRect = TQRect(0, 0, width, height);
				break;
		}

		cairo_save(cr);
		cairo_reset_clip(cr);

		TQt3CairoPaintDevice pd2(NULL, paintDeviceRect.x(), paintDeviceRect.y(), paintDeviceRect.width(), paintDeviceRect.height(), cr);
		TQPainter p2(&pd2);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
		DRAW_FILLED_RECTANGLE_OVER_SPECIFIC_AREA(p2, brush, backgroundRect.x(), backgroundRect.y(), backgroundRect.width(), backgroundRect.height())

		// Draw tab
		tqApp->style().drawControl(TQStyle::CE_TabBarTab, &p2, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((selectedTab)?TQStyle::Style_Selected:TQStyle::Style_Default) | ((prelight)?TQStyle::Style_MouseOver:TQStyle::Style_Default), tabOpt);

		cairo_restore(cr);
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,255,0);
		printf("[WARNING] tdegtk_draw_extension() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}

	p.end();
}

static void
tdegtk_draw_focus (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_FRAME) || gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY) || gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_BUTTON)) && (Gtk::gtk_widget_path_has_type(path, GTK_TYPE_COMBO_BOX))) {
		// Draw nothing!
	}

	else if ((gtk_widget_path_is_type(path, GTK_TYPE_ENTRY))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_VIEW))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_BUFFER))
		|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY))
		|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_COMBOBOX_ENTRY))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_BUTTON))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_EXPANDER))
		) {
		TQStyle::SFlags sflags = TQStyle::Style_Default;

		TQStringList objectTypes;
		if ((gtk_widget_path_is_type(path, GTK_TYPE_ENTRY))
			|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_VIEW))
			|| (gtk_widget_path_is_type(path, GTK_TYPE_TEXT_BUFFER))
			|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_ENTRY))
			|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_COMBOBOX_ENTRY))
			) {
			objectTypes.append(TQLINEEDIT_OBJECT_NAME_STRING);
		}
		else if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
			objectTypes.append(TQLISTVIEW_OBJECT_NAME_STRING);
		}
		else if (gtk_widget_path_is_type(path, GTK_TYPE_BUTTON)) {
			objectTypes.append(TQPUSHBUTTON_OBJECT_NAME_STRING);
		}
		else {
			objectTypes.append(TQWIDGET_OBJECT_NAME_STRING);
		}

		TQPalette objectPalette = tqApp->palette(objectTypes);
		TQColor bgColor;
	
		if (state & GTK_STATE_FLAG_INSENSITIVE) {
			bgColor = objectPalette.color(TQPalette::Disabled, TQColorGroup::Background);
		}
		else {
			bgColor = objectPalette.color(TQPalette::Active, TQColorGroup::Background);
		}

		TQRect focusBoundingRect = boundingRect;
		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;

		if (gtk_widget_path_is_type(path, GTK_TYPE_BUTTON)) {
			TQStringList objectTypes;
			objectTypes.append(TQBUTTON_OBJECT_NAME_STRING);
			ceData.widgetObjectTypes = objectTypes;
			ceData.rect = boundingRect;

			focusBoundingRect = TQStyle::visualRect(tqApp->style().subRect(TQStyle::SR_PushButtonFocusRect, ceData, elementFlags, NULL), ceData, elementFlags);
		}

		TQStyleOption opt(bgColor);
		// FIXME
		// There are only a few TQt3 widgets that draw a PE_FocusRect directly
		// Those specific widgets need to be isolated and the draw routine added here
		// All other widget should not trigger any drawing here!
		//tqApp->style().drawPrimitive(TQStyle::PE_FocusRect, &p, focusBoundingRect, gtkToTQtColorGroup(engine, state), sflags, opt);
	}

	else if ((gtk_widget_path_is_type(path, GTK_TYPE_ENTRY))
		|| (gtk_widget_path_is_type(path, GTK_TYPE_NOTEBOOK))
		|| (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCALE))
		) {
		// Draw nothing
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,255,64);
		printf("[WARNING] tdegtk_draw_focus() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}

	p.end();
}

static void
tdegtk_draw_frame_gap (DRAW_ARGS,
                      GtkPositionType gap_side,
                      gdouble         xy0_gap,
                      gdouble         xy1_gap)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_FRAME)) {
		GtkFrame* frame = GTK_FRAME(widget);
		GtkShadowType gtkShadowType = gtk_frame_get_shadow_type(frame);

		TQStringList objectTypes;
		objectTypes.append(TQGROUPBOX_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		int groupBoxLineWidth = 1;

		int lineWidth = 0;
		int midLineWidth = 0;
		TQStyle::SFlags sflags = gtkToTQtStyleFlags(engine, state, TQT3WT_TQGroupBox, widget);

		if (gtkShadowType == GTK_SHADOW_NONE) {
			lineWidth = 0;
			midLineWidth = 0;
		}
		else if (gtkShadowType == GTK_SHADOW_IN) {
			lineWidth = groupBoxLineWidth;
			midLineWidth = 0;
			sflags = sflags | TQStyle::Style_Sunken;
		}
		else if (gtkShadowType == GTK_SHADOW_OUT) {
			lineWidth = groupBoxLineWidth;
			midLineWidth = 0;
			sflags = sflags | TQStyle::Style_Raised;
		}
		else if (gtkShadowType == GTK_SHADOW_ETCHED_IN) {
			lineWidth = groupBoxLineWidth;
			midLineWidth = groupBoxLineWidth;
			sflags = sflags | TQStyle::Style_Sunken;
		}
		else if (gtkShadowType == GTK_SHADOW_ETCHED_OUT) {
			lineWidth = groupBoxLineWidth;
			midLineWidth = groupBoxLineWidth;
			sflags = sflags | TQStyle::Style_Raised;
		}

		TQStyleOption opt(lineWidth, midLineWidth);

		// Draw background
		TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
		DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)

		// Draw group box
		tqApp->style().drawPrimitive(TQStyle::PE_PanelGroupBox, &p, boundingRect, gtkToTQtColorGroup(engine, state), sflags, opt);

		// Draw background behind groupbox label
		DRAW_FILLED_RECTANGLE_OVER_SPECIFIC_AREA(p, brush, xy0_gap, x, (xy1_gap-xy0_gap), (height/2))
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,128,0);
		printf("[WARNING] tdegtk_draw_frame_gap() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}
	
	p.end();
}

static void
tdegtk_draw_grip (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	TQStringList objectTypes;
	objectTypes.append(TQSTATUSBAR_OBJECT_NAME_STRING);
	TQPalette objectPalette = tqApp->palette(objectTypes);

	// Draw background
	TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
	DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)

	cairo_save(cr);
	cairo_reset_clip(cr);

	// Draw grip
	tqApp->style().drawPrimitive(TQStyle::PE_SizeGrip, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));

	cairo_restore(cr);

	p.end();
}

static void
tdegtk_draw_handle (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_widget_path_is_type(path, GTK_TYPE_HANDLE_BOX)) {
		TQStringList objectTypes;
		objectTypes.append(TQDOCKWINDOWHANDLE_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);
	
		// Draw handle
		tqApp->style().drawPrimitive(TQStyle::PE_DockWindowHandle, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQStyle::Style_Default:TQStyle::Style_Horizontal));
	}

	else if (gtk_widget_path_is_type(path, GTK_TYPE_PANED)) {
		TQStringList objectTypes;
		objectTypes.append(TQSPLITTER_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);
	
		// Draw handle
		tqApp->style().drawPrimitive(TQStyle::PE_Splitter, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQStyle::Style_Default:TQStyle::Style_Horizontal));
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,0,128,255);
		printf("[WARNING] tdegtk_draw_handle() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}

	p.end();
}

static void
tdegtk_draw_line (GtkThemingEngine *engine,
                 cairo_t          *cr,
                 gdouble           x0,
                 gdouble           y0,
                 gdouble           x1,
                 gdouble           y1)
{
	// line endings
	if (y0 == y1) {
		y0 += 0.5;
		y1 += 0.5;
		x0 += 0.5;
		x1 -= 0.5;
	}
	else if (x0 == x1) {
		x0 += 0.5;
		x1 += 0.5;
		y0 += 0.5;
		y1 -= 0.5;
	}
	
	cairo_move_to (cr, x0, y0);
	cairo_line_to (cr, x1, y1);
	tdegtk_cairo_set_source_border (engine, cr, MAX (x1 - x0, 1), MAX (y1 - y0, 1));
	cairo_stroke (cr);
}

static void
tdegtk_draw_notebook (DRAW_ARGS,
                     GtkPositionType gap_side,
                     gdouble         xy0_gap,
                     gdouble         xy1_gap)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	DEBUG_FILL_BACKGROUND_WITH_COLOR(p,0,255,0);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	TQStringList objectTypes;
	objectTypes.append(TQTABWIDGET_OBJECT_NAME_STRING);
	TQPalette objectPalette = tqApp->palette(objectTypes);

	// Draw background
	TQBrush brush = objectPalette.brush(gtkToTQPaletteColorGroup(engine, state), TQColorGroup::Background);
	DRAW_FILLED_RECTANGLE_OVER_ENTIRE_AREA(p, brush)

	// Draw tab frame
	tqApp->style().drawPrimitive(TQStyle::PE_PanelTabWidget, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
	
	p.end();
}

static void
tdegtk_draw_radio (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_widget_path_is_type(path, GTK_TYPE_TREE_VIEW)) {
		draw_radiobutton(engine, cr, x, y, width, height, path, state, widget, TQT3WT_GTKTreeViewCell);
	}
	else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_MENUITEM)) {
		const GtkAllocation allocation = Gtk::gtk_widget_get_allocation(widget);

		boundingRect = TQRect(0, 0, allocation.width, allocation.height);
		TQt3CairoPaintDevice pd2(NULL, 0, 0, allocation.width, allocation.height, cr);
		TQPainter p2(&pd2);

		bool checked = ((state & GTK_STATE_FLAG_ACTIVE) != 0);
		int maxAcceleratorTextWidth = 0;
		int maxIconWidth = IconSize(KIcon::Small) + 4;

		TQStringList objectTypes;
		objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;

		TQMenuItem tqt3MenuItem;
		tqt3MenuItem.setChecked(checked);
		TQStyleOption menuOpt(&tqt3MenuItem, maxIconWidth, maxAcceleratorTextWidth);
		elementFlags = elementFlags | TQStyle::TQStyle::CEF_IsCheckable;

		if (checked) {
			tqApp->style().drawPrimitive(TQStyle::PE_MenuItemIndicatorFrame, &p2, ceData, elementFlags, ceData.rect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQRadioButton, widget), menuOpt);
			tqApp->style().drawPrimitive(TQStyle::PE_MenuItemIndicatorCheck, &p2, ceData, elementFlags, ceData.rect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQRadioButton, widget), menuOpt);
		}
	}
	else {
		draw_radiobutton(engine, cr, x, y, width, height, path, state, widget, TQT3WT_TQRadioButton);
	}
	
	p.end();
}

static void
tdegtk_draw_separator (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_widget_path_is_type(path, GTK_TYPE_SEPARATOR_MENU_ITEM)) {
		TQStringList objectTypes;
		objectTypes.append(TQPOPUPMENU_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		bool pressed = false;
		bool prelight = false;

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;

		TQMenuItem tqt3MenuItem;
		tqt3MenuItem.setSeparator(true);
		int maxAcceleratorTextWidth = 0;
		int maxIconWidth = IconSize(KIcon::Small) + 4;
		TQStyleOption menuOpt(&tqt3MenuItem, maxIconWidth, maxAcceleratorTextWidth);

// 		if (???) elementFlags = elementFlags | TQStyle::TQStyle::CEF_IsCheckable;

		TQRect paintDeviceRect;
		TQRect backgroundRect;

		// Draw item
		tqApp->style().drawControl(TQStyle::CE_PopupMenuItem, &p, ceData, elementFlags, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_TQMenuItem, widget), menuOpt);
	}

	else if (gtk_widget_path_is_type(path, GTK_TYPE_SEPARATOR)) {
		TQt::Orientation orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;
		tqApp->style().drawPrimitive(TQStyle::PE_Separator, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
	}

	else if (gtk_widget_path_is_type(path, GTK_TYPE_SEPARATOR_TOOL_ITEM)) {
		TQt::Orientation orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;
		tqApp->style().drawPrimitive(TQStyle::PE_Separator, &p, boundingRect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,128,255);
		printf("[WARNING] tdegtk_draw_separator() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}

	p.end();
}

static void
tdegtk_draw_slider (DRAW_ARGS,
                   GtkOrientation orientation)
{
	cairo_save(cr);
	cairo_reset_clip(cr);

	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	const GtkWidgetPath* path;
	GtkStateFlags state;
	GtkWidget* widget;

	path = gtk_theming_engine_get_path(engine);
	state = gtk_theming_engine_get_state(engine);
	widget = m_widgetLookup.find(cr, path);

	if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCROLLBAR)) {
#ifdef DRAW_SCROLLBAR_PIECES_INSTEAD_OF_ENTIRE_BAR
		TQStringList objectTypes;
		objectTypes.append(TQSCROLLBAR_OBJECT_NAME_STRING);
		TQPalette objectPalette = tqApp->palette(objectTypes);

		GtkRange* rangeWidget = GTK_RANGE(widget);

		TQStyleControlElementData ceData;
		TQStyle::ControlElementFlags elementFlags = TQStyle::CEF_None;
		ceData.widgetObjectTypes = objectTypes;
		ceData.rect = boundingRect;
		ceData.orientation = (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_VERTICAL))?TQt::Vertical:TQt::Horizontal;

		gtkRangeToCeData(rangeWidget, ceData);

		// Draw slider
		TQRect scrollpagerect = tqApp->style().querySubControlMetrics(TQStyle::CC_ScrollBar, ceData, elementFlags, TQStyle::SC_ScrollBarSlider, gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget));
		if (ceData.orientation == TQt::Vertical) {
			scrollpagerect.setY(ceData.rect.y());
			scrollpagerect.setHeight(ceData.rect.height());
		}
		else {
			scrollpagerect.setX(ceData.rect.x());
			scrollpagerect.setWidth(ceData.rect.width());
		}
		tqApp->style().drawPrimitive(TQStyle::PE_ScrollBarSlider, &p, scrollpagerect, gtkToTQtColorGroup(engine, state), gtkToTQtStyleFlags(engine, state, TQT3WT_NONE, widget) | ((ceData.orientation == TQt::Horizontal)?TQStyle::Style_Horizontal:TQStyle::Style_Default));
#else
// 		draw_scrollbar_frame(engine, cr, x, y, width, height, path, state, widget);
#endif
	}

	else if (gtk_theming_engine_has_class(engine, GTK_STYLE_CLASS_SCALE)) {
		draw_slider_frame(engine, cr, x, y, width, height, path, state, widget);
	}

	else {
		DEBUG_FILL_BACKGROUND_WITH_COLOR(p,255,0,255);
		printf("[WARNING] tdegtk_draw_slider() nonfunctional for widget with path '%s'\n\r", gtk_widget_path_to_string (gtk_theming_engine_get_path(engine))); fflush(stdout);
	}

	p.end();

	cairo_restore(cr);
}

static void
tdegtk_draw_spinbutton_background (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,255,0);

	p.end();
}

static void
tdegtk_draw_spinbutton_frame (DRAW_ARGS)
{
	TQRect boundingRect(0, 0, width, height);
	TQt3CairoPaintDevice pd(NULL, x, y, width, height, cr);
	TQPainter p(&pd);

	DEBUG_FILL_BACKGROUND_WITH_COLOR(p,128,255,128);

	p.end();
}

void
tdegtk_register_style_default (TdeGtkStyleFunctions *functions)
{
  g_assert (functions);

  functions->draw_activity                      = tdegtk_draw_activity;
  functions->draw_arrow                         = tdegtk_draw_arrow;
  functions->draw_cell_background               = tdegtk_draw_cell_background;
  functions->draw_cell_frame                    = tdegtk_draw_cell_frame;
  functions->draw_check                         = tdegtk_draw_check;
  functions->draw_common                        = tdegtk_draw_common;
  functions->draw_common_background             = tdegtk_draw_common_background;
  functions->draw_common_frame                  = tdegtk_draw_common_frame;
  functions->draw_expander                      = tdegtk_draw_expander;
  functions->draw_extension                     = tdegtk_draw_extension;
  functions->draw_focus                         = tdegtk_draw_focus;
  functions->draw_frame_gap                     = tdegtk_draw_frame_gap;
  functions->draw_grip                          = tdegtk_draw_grip;
  functions->draw_handle                        = tdegtk_draw_handle;
  functions->draw_line                          = tdegtk_draw_line;
  functions->draw_notebook                      = tdegtk_draw_notebook;
  functions->draw_radio                         = tdegtk_draw_radio;
  functions->draw_separator                     = tdegtk_draw_separator;
  functions->draw_slider                        = tdegtk_draw_slider;
  functions->draw_spinbutton_background         = tdegtk_draw_spinbutton_background;
  functions->draw_spinbutton_frame              = tdegtk_draw_spinbutton_frame;
}