Merge branch 'master' of http://scm.trinitydesktop.org/scm/git/tqt3

31 files changed, 3062 insertions, 1648 deletions

diff --git a/changes-3.5 b/changes-3.5
new file mode 100644
index 00000000..f40ce0bb
--- /dev/null
+++ b/changes-3.5
@@ -0,0 +1,48 @@
+Qt 3.5 is a new feature release. It is not backwards compatible with any
+prior TQt3 version due to changes in the QStyle API.
+
+****************************************************************************
+*                           General                                        *
+****************************************************************************
+
+General Improvements
+--------------------
+
+- Technical
+
+    * Modify TQStyle API to work without requiring direct access to TQt-specific objects
+      See "TQStyle API Change" section below
+
+TQStyle API Change
+---------------------
+
+The following style function definitions have changed:
+
+drawPrimitive
+drawControl
+drawControlMask
+subRect
+drawComplexControl
+drawComplexControlMask
+querySubControlMetrics
+querySubControl
+pixelMetric
+sizeFromContents
+styleHint
+stylePixmap
+visualRect
+drawKStylePrimitive
+polish
+unPolish
+
+The following new functions have been added:
+applicationPolish
+applicationUnPolish
+installObjectEventHandler
+removeObjectEventHandler
+objectEventHandler
+widgetActionRequest
+
+Additionally, SH_UnderlineAccelerator has been extended with a new style hint, SH_HideUnderlineAcceleratorWhenAltUp
+
+Porting an existing style to the new API is relatively straightforward; simply update the function definitions in the existing style with the new definition prototypes and cast the passed pointer to TQWidget or TQObject where appropriate.
diff --git a/configure b/configure
index eb3ba1cf..cce8ec09 100755
--- a/configure
+++ b/configure
@@ -2985,7 +2985,7 @@ if [ "$CFG_LARGEFILE" = "yes" ]; then
 fi
 
 $unixtests/ptrsize.test $XQMAKESPEC $OPT_VERBOSE $relpath $outpath
-echo "#define QT_POINTER_SIZE $?" >>$outpath/include/ntqconfig.h.new
+echo "#define TQT_POINTER_SIZE $?" >>$outpath/include/ntqconfig.h.new
 
 if [ ! -z "$QT_MAC_VERSION" ]; then
     echo "#define QT_MACOSX_VERSION  ${QT_MAC_VERSION}  /*from config.tests*/" >>$outpath/include/ntqconfig.h.new
diff --git a/src/3rdparty/sqlite/config.h b/src/3rdparty/sqlite/config.h
index b17d48a8..83363661 100644
--- a/src/3rdparty/sqlite/config.h
+++ b/src/3rdparty/sqlite/config.h
@@ -1,17 +1,17 @@
 #include <ntqglobal.h>
 #include <ntqconfig.h>
 
-#ifndef QT_POINTER_SIZE
+#ifndef TQT_POINTER_SIZE
 # ifdef Q_OS_WIN32
-#  define QT_POINTER_SIZE 4
+#  define TQT_POINTER_SIZE 4
 # elif Q_OS_WIN64
-#  define QT_POINTER_SIZE 8
+#  define TQT_POINTER_SIZE 8
 # else
 #  error This platform is unsupported
 # endif
-#endif /* QT_POINTER_SIZE */
+#endif /* TQT_POINTER_SIZE */
 
-#define SQLITE_PTR_SZ QT_POINTER_SIZE
+#define SQLITE_PTR_SZ TQT_POINTER_SIZE
 
 #ifdef UNICODE
 # undef UNICODE
diff --git a/src/3rdparty/sqlite/trolltech.patch b/src/3rdparty/sqlite/trolltech.patch
index 81d408d1..db15f9b6 100644
--- a/src/3rdparty/sqlite/trolltech.patch
+++ b/src/3rdparty/sqlite/trolltech.patch
@@ -6,17 +6,17 @@ diff -du ./config.h /home/harald/troll/qt-3.3/src/3rdparty/sqlite/config.h
 +#include <ntqglobal.h>
 +#include <ntqconfig.h>
 +
-+#ifndef QT_POINTER_SIZE
++#ifndef TQT_POINTER_SIZE
 +# ifdef Q_OS_WIN32
-+#  define QT_POINTER_SIZE 4
++#  define TQT_POINTER_SIZE 4
 +# elif Q_OS_WIN64
-+#  define QT_POINTER_SIZE 8
++#  define TQT_POINTER_SIZE 8
 +# else
 +#  error This platform is unsupported
 +# endif
-+#endif /* QT_POINTER_SIZE */
++#endif /* TQT_POINTER_SIZE */
 +
-+#define SQLITE_PTR_SZ QT_POINTER_SIZE
++#define SQLITE_PTR_SZ TQT_POINTER_SIZE
 +
 +#ifdef UNICODE
 +# undef UNICODE
diff --git a/src/kernel/ntqstyle.h b/src/kernel/ntqstyle.h
index 0cacb8b2..c77ab6e4 100644
--- a/src/kernel/ntqstyle.h
+++ b/src/kernel/ntqstyle.h
@@ -42,6 +42,11 @@
 
 #ifndef QT_H
 #include "ntqobject.h"
+#include "ntqpixmap.h"
+#include "ntqcolor.h"
+#include "ntqiconset.h"
+#include "ntqtabbar.h"
+#include "ntqtoolbutton.h"
 #endif // QT_H
 
 
@@ -58,26 +63,26 @@ class TQStyleOption {
 public:
     enum StyleOptionDefault { Default };
 
-    TQStyleOption(StyleOptionDefault=Default) : def(TRUE) {}
+    TQStyleOption(StyleOptionDefault=Default) : def(TRUE), tb(NULL) {}
 
     // Note: we don't use default arguments since that is unnecessary
     // initialization.
     TQStyleOption(int in1) :
-	def(FALSE), i1(in1) {}
+	def(FALSE), tb(NULL), i1(in1) {}
     TQStyleOption(int in1, int in2) :
-	def(FALSE), i1(in1), i2(in2) {}
+	def(FALSE), tb(NULL), i1(in1), i2(in2) {}
     TQStyleOption(int in1, int in2, int in3, int in4) :
-	def(FALSE), i1(in1), i2(in2), i3(in3), i4(in4) {}
-    TQStyleOption(TQMenuItem* m) : def(FALSE), mi(m) {}
-    TQStyleOption(TQMenuItem* m, int in1) : def(FALSE), mi(m), i1(in1) {}
-    TQStyleOption(TQMenuItem* m, int in1, int in2) : def(FALSE), mi(m), i1(in1), i2(in2) {}
-    TQStyleOption(const TQColor& c) : def(FALSE), cl(&c) {}
+	def(FALSE), tb(NULL), i1(in1), i2(in2), i3(in3), i4(in4) {}
+    TQStyleOption(TQMenuItem* m) : def(FALSE), mi(m), tb(NULL) {}
+    TQStyleOption(TQMenuItem* m, int in1) : def(FALSE), mi(m), tb(NULL), i1(in1) {}
+    TQStyleOption(TQMenuItem* m, int in1, int in2) : def(FALSE), mi(m), tb(NULL), i1(in1), i2(in2) {}
+    TQStyleOption(const TQColor& c) : def(FALSE), tb(NULL), cl(&c) {}
     TQStyleOption(TQTab* t) : def(FALSE), tb(t) {}
-    TQStyleOption(TQListViewItem* i) : def(FALSE), li(i) {}
-    TQStyleOption(TQCheckListItem* i) : def(FALSE), cli(i) {}
-    TQStyleOption(TQt::ArrowType a) : def(FALSE), i1((int)a) {}
-    TQStyleOption(const TQRect& r) : def(FALSE), i1(r.x()), i2(r.y()), i3(r.width()),i4(r.height()){}
-    TQStyleOption(TQWidget *w) : def(FALSE), p1((void*)w) {}
+    TQStyleOption(TQListViewItem* i) : def(FALSE), tb(NULL), li(i) {}
+    TQStyleOption(TQCheckListItem* i) : def(FALSE), tb(NULL), cli(i) {}
+    TQStyleOption(TQt::ArrowType a) : def(FALSE), tb(NULL), i1((int)a) {}
+    TQStyleOption(const TQRect& r) : def(FALSE), tb(NULL), i1(r.x()), i2(r.y()), i3(r.width()),i4(r.height()){}
+    TQStyleOption(TQWidget *w) : def(FALSE), tb(NULL), p1((void*)w) {}
 
     bool isDefault() const { return def; }
 
@@ -121,6 +126,138 @@ private:
 
 class TQStyleHintReturn; // not defined yet
 
+typedef TQMap<TQ_UINT32, TQSize> DialogButtonSizeMap;
+typedef TQMap<TQ_INT32, TQ_INT32> TabIdentifierIndexMap;
+
+class TQStyleControlElementPopupMenuData {
+	public:
+		//
+};
+
+class TQStyleControlElementTabBarData {
+	public:
+		int tabCount;
+		TQTabBar::Shape shape;
+		TabIdentifierIndexMap identIndexMap;
+};
+
+class TQStyleControlElementListViewData {
+	public:
+		bool rootDecorated;
+		int itemMargin;
+};
+
+class TQStyleControlElementSpinWidgetData {
+	public:
+		TQ_UINT32 buttonSymbols;
+		TQRect upRect;
+		TQRect downRect;
+		bool upEnabled;
+		bool downEnabled;
+};
+
+class TQStyleControlElementTitleBarData {
+	public:
+		bool hasWindow;
+		bool usesActiveColor;
+		int windowState;
+		TQString visibleText;
+};
+
+class TQStyleControlElementDockWidgetData {
+	public:
+		bool hasDockArea;
+		bool closeEnabled;
+		TQt::Orientation areaOrientation;
+};
+
+class TQStyleControlElementGenericWidgetData {
+	public:
+		TQStringList widgetObjectTypes;
+		bool allDataPopulated;
+		TQt::WFlags wflags;
+		TQPixmap bgPixmap;
+		TQBrush bgBrush;
+		TQColor bgColor;
+		TQPoint bgOffset;
+		TQt::BackgroundMode backgroundMode;
+		TQColor fgColor;
+		TQColorGroup colorGroup;
+		TQRect geometry;
+		TQRect rect;
+		TQPoint pos;
+		TQPixmap icon;
+		TQPalette palette;
+		TQFont font;
+};
+
+class TQStyleControlElementData {
+	public:
+		TQStringList widgetObjectTypes;
+		bool allDataPopulated;
+		TQt::WFlags wflags;
+		TQPixmap bgPixmap;
+		TQBrush bgBrush;
+		TQColor bgColor;
+		TQPoint bgOffset;
+		TQt::BackgroundMode backgroundMode;
+		TQPixmap fgPixmap;
+		TQColor fgColor;
+		TQColorGroup colorGroup;
+		TQRect geometry;
+		TQRect rect;
+		TQPoint pos;
+		TQPixmap icon;
+		TQIconSet iconSet;
+		TQString text;
+		TQt::Orientation orientation;
+		TQColor activeItemPaletteBgColor;
+		TQPalette palette;
+		int totalSteps;
+		int currentStep;
+		TQ_UINT32 tickMarkSetting;
+		int tickInterval;
+		int minSteps;
+		int maxSteps;
+		int startStep;
+		int pageStep;
+		int lineStep;
+		int dlgVisibleButtons;
+		DialogButtonSizeMap dlgVisibleSizeHints;
+		TQString progressText;
+		TQString textLabel;
+		TQFont font;
+		int percentageVisible;
+		TQStyleControlElementDockWidgetData dwData;
+		TQToolButton::TextPosition toolButtonTextPosition;
+		int popupDelay;
+		TQStyleControlElementTitleBarData titleBarData;
+		TQStyleControlElementSpinWidgetData spinWidgetData;
+		TQStyleControlElementGenericWidgetData parentWidgetData;
+		TQStyleControlElementGenericWidgetData viewportData;
+		TQStyleControlElementListViewData listViewData;
+		TQStyleControlElementTabBarData tabBarData;
+		TQ_UINT32 comboBoxLineEditFlags;
+		TQ_UINT32 frameStyle;
+		TQRect sliderRect;
+};
+
+class TQStyleWidgetActionRequestData {
+	public:
+		TQStyleWidgetActionRequestData();
+		TQStyleWidgetActionRequestData(int metric1, int metric2=0);
+		TQStyleWidgetActionRequestData(TQPalette palette);
+		TQStyleWidgetActionRequestData(TQFont font);
+		TQStyleWidgetActionRequestData(TQRect rect);
+		~TQStyleWidgetActionRequestData();
+	public:
+		int metric1;
+		int metric2;
+		TQPalette palette;
+		TQFont font;
+		TQRect rect;
+};
+
 class Q_EXPORT TQStyle: public TQObject
 {
     TQ_OBJECT
@@ -129,14 +266,64 @@ public:
     TQStyle();
     virtual ~TQStyle();
 
+    enum ControlElementFlags {
+	CEF_None			= 0x00000000,
+	CEF_IsDefault			= 0x00000001,
+	CEF_AutoDefault			= 0x00000002,
+	CEF_IsActive			= 0x00000004,
+	CEF_IsDown			= 0x00000008,
+	CEF_IsOn			= 0x00000010,
+	CEF_IsEnabled			= 0x00000020,
+	CEF_BiState			= 0x00000040,
+	CEF_HasFocus			= 0x00000080,
+	CEF_IsMenuWidget		= 0x00000100,
+	CEF_IsContainerEmpty		= 0x00000200,
+	CEF_CenterIndicator		= 0x00000400,
+	CEF_IndicatorFollowsStyle	= 0x00000800,
+	CEF_UsesTextLabel		= 0x00001000,
+	CEF_UsesBigPixmap		= 0x00002000,
+	CEF_UseGenericParameters	= 0x00004000,
+	CEF_HasParentWidget		= 0x00008000,
+	CEF_HasPopupMenu		= 0x00010000,
+	CEF_IsCheckable			= 0x00020000,
+	CEF_HasFocusProxy		= 0x00040000,
+	CEF_IsEditable			= 0x00080000,
+	CEF_IsFlat			= 0x00100000,
+	CEF_IsActiveWindow		= 0x00200000,
+	CEF_IsTopLevel			= 0x00400000,
+	CEF_IsVisible			= 0x00800000,
+    };
+
     // New TQStyle API - most of these should probably be pure virtual
 
+    // Old API
+    // DEPRECATED
     virtual void polish( TQWidget * );
+
+    // New API
+    virtual void polish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
+
+    // Old API
+    // DEPRECATED
     virtual void unPolish( TQWidget * );
 
+    // New API
+    virtual void unPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
+
+    // Old API
+    // DEPRECATED
     virtual void polish( TQApplication * );
+
+    // New API
+    virtual void applicationPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
+
+    // Old API
+    // DEPRECATED
     virtual void unPolish( TQApplication * );
 
+    // New API
+    virtual void applicationUnPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
+
     virtual void polish( TQPalette & );
 
     virtual void polishPopupMenu( TQPopupMenu* ) = 0;
@@ -151,7 +338,6 @@ public:
 			   const TQPixmap *pixmap, const TQString &text,
 			   int len = -1, const TQColor *penColor = 0 ) const;
 
-
     enum PrimitiveElement {
 	PE_ButtonCommand,
 	PE_ButtonDefault,
@@ -252,8 +438,20 @@ public:
     };
     typedef uint SFlags;
 
+    // Old API
+    // DEPRECATED
+    virtual void drawPrimitive( PrimitiveElement pe,
+				TQPainter *p,
+				const TQRect &r,
+				const TQColorGroup &cg,
+				SFlags flags = Style_Default,
+				const TQStyleOption& = TQStyleOption::Default ) const = 0;
+
+    // New API
     virtual void drawPrimitive( PrimitiveElement pe,
 				TQPainter *p,
+				TQStyleControlElementData ceData,
+				ControlElementFlags elementFlags,
 				const TQRect &r,
 				const TQColorGroup &cg,
 				SFlags flags = Style_Default,
@@ -294,6 +492,8 @@ public:
 	CE_CustomBase =		0xf0000000
     };
 
+    // Old API
+    // DEPRECATED
     virtual void drawControl( ControlElement element,
 			      TQPainter *p,
 			      const TQWidget *widget,
@@ -301,12 +501,35 @@ public:
 			      const TQColorGroup &cg,
 			      SFlags how = Style_Default,
 			      const TQStyleOption& = TQStyleOption::Default ) const = 0;
+
+    // New API
+    virtual void drawControl( ControlElement element,
+			      TQPainter *p,
+			      TQStyleControlElementData ceData,
+			      ControlElementFlags elementFlags,
+			      const TQRect &r,
+			      const TQColorGroup &cg,
+			      SFlags how = Style_Default,
+			      const TQStyleOption& = TQStyleOption::Default,
+			      const TQWidget *widget = 0 /* compat, will likely go away */ ) const = 0;
+
+    // Old API
+    // DEPRECATED
     virtual void drawControlMask( ControlElement element,
 				  TQPainter *p,
 				  const TQWidget *widget,
 				  const TQRect &r,
 				  const TQStyleOption& = TQStyleOption::Default ) const = 0;
 
+    // New API
+    virtual void drawControlMask( ControlElement element,
+				  TQPainter *p,
+				  TQStyleControlElementData ceData,
+				  ControlElementFlags elementFlags,
+				  const TQRect &r,
+				  const TQStyleOption& = TQStyleOption::Default,
+				  const TQWidget *widget = 0 /* compat, will likely go away */ ) const = 0;
+
     enum SubRect {
 	SR_PushButtonContents,
 	SR_PushButtonFocusRect,
@@ -347,8 +570,13 @@ public:
 	SR_CustomBase =		0xf0000000
     };
 
+    // Old API
+    // DEPRECATED
     virtual TQRect subRect( SubRect r, const TQWidget *widget ) const = 0;
 
+    // New API
+    virtual TQRect subRect( SubRect r, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags, const TQWidget *widget ) const = 0;
+
 
     enum ComplexControl{
 	CC_SpinWidget,
@@ -411,6 +639,8 @@ public:
     typedef uint SCFlags;
 
 
+    // Old API
+    // DEPRECATED
     virtual void drawComplexControl( ComplexControl control,
 				     TQPainter *p,
 				     const TQWidget *widget,
@@ -424,21 +654,70 @@ public:
 #endif
 				     SCFlags subActive = SC_None,
 				     const TQStyleOption& = TQStyleOption::Default ) const = 0;
+
+    virtual void drawComplexControl( ComplexControl control,
+				     TQPainter *p,
+				     TQStyleControlElementData ceData,
+				     ControlElementFlags elementFlags,
+				     const TQRect &r,
+				     const TQColorGroup &cg,
+				     SFlags how = Style_Default,
+#ifdef Q_QDOC
+				     SCFlags sub = SC_All,
+#else
+				     SCFlags sub = (uint)SC_All,
+#endif
+				     SCFlags subActive = SC_None,
+				     const TQStyleOption& = TQStyleOption::Default,
+				     const TQWidget *widget = 0 ) const = 0;
+
+    // Old API
+    // DEPRECATED
     virtual void drawComplexControlMask( ComplexControl control,
 					 TQPainter *p,
 					 const TQWidget *widget,
 					 const TQRect &r,
 					 const TQStyleOption& = TQStyleOption::Default ) const = 0;
 
+    // New API
+    virtual void drawComplexControlMask( ComplexControl control,
+					 TQPainter *p,
+					 const TQStyleControlElementData ceData,
+					 const ControlElementFlags elementFlags,
+					 const TQRect &r,
+					 const TQStyleOption& = TQStyleOption::Default,
+					 const TQWidget *widget = 0 ) const = 0;
+
+    // Old API
+    // DEPRECATED
     virtual TQRect querySubControlMetrics( ComplexControl control,
 					  const TQWidget *widget,
 					  SubControl sc,
 					  const TQStyleOption& = TQStyleOption::Default ) const = 0;
+
+    // New API
+    virtual TQRect querySubControlMetrics( ComplexControl control,
+					  TQStyleControlElementData ceData,
+					  ControlElementFlags elementFlags,
+					  SubControl sc,
+					  const TQStyleOption& = TQStyleOption::Default,
+					  const TQWidget *widget = 0 ) const = 0;
+
+    // Old API
+    // DEPRECATED
     virtual SubControl querySubControl( ComplexControl control,
 					const TQWidget *widget,
 					const TQPoint &pos,
 					const TQStyleOption& = TQStyleOption::Default ) const = 0;
 
+    // New API
+    virtual SubControl querySubControl( ComplexControl control,
+					TQStyleControlElementData ceData,
+					ControlElementFlags elementFlags,
+					const TQPoint &pos,
+					const TQStyleOption& = TQStyleOption::Default,
+					const TQWidget *widget = 0 ) const = 0;
+
 
     enum PixelMetric {
 	PM_ButtonMargin,
@@ -508,7 +787,15 @@ public:
 	PM_CustomBase =		0xf0000000
     };
 
+    // Old API
+    // DEPRECATED
+    virtual int pixelMetric( PixelMetric metric,
+			     const TQWidget *widget = 0 ) const = 0;
+
+    // New API
     virtual int pixelMetric( PixelMetric metric,
+			     TQStyleControlElementData ceData,
+			     ControlElementFlags elementFlags,
 			     const TQWidget *widget = 0 ) const = 0;
 
 
@@ -536,11 +823,20 @@ public:
 	CT_CustomBase =		0xf0000000
     };
 
+    // Old API
+    // DEPRECATED
     virtual TQSize sizeFromContents( ContentsType contents,
 				    const TQWidget *widget,
 				    const TQSize &contentsSize,
 				    const TQStyleOption& = TQStyleOption::Default ) const = 0;
 
+    virtual TQSize sizeFromContents( ContentsType contents,
+				    TQStyleControlElementData ceData,
+				    ControlElementFlags elementFlags,
+				    const TQSize &contentsSize,
+				    const TQStyleOption& = TQStyleOption::Default,
+				    const TQWidget *widget = 0 ) const = 0;
+
     enum StyleHint  {
 	// ...
 	// the general hints
@@ -683,16 +979,30 @@ public:
 	// when the mouse is over the button
 	SH_ToolButton_Uses3D,
 
+	// bool - hide underlined accelerators uless Alt key is currently down
+	SH_HideUnderlineAcceleratorWhenAltUp,
+
 	// do not add any values below/greater than this
 	SH_CustomBase =		0xf0000000
     };
 
+    // Old API
+    // DEPRECATED
     virtual int styleHint( StyleHint stylehint,
 			   const TQWidget *widget = 0,
 			   const TQStyleOption& = TQStyleOption::Default,
 			   TQStyleHintReturn* returnData = 0
 			   ) const = 0;
 
+    // New API
+    virtual int styleHint( StyleHint stylehint,
+			   TQStyleControlElementData ceData,
+			   ControlElementFlags elementFlags,
+			   const TQStyleOption& = TQStyleOption::Default,
+			   TQStyleHintReturn* returnData = 0,
+			   const TQWidget *widget = 0
+			   ) const = 0;
+
 
     enum StylePixmap {
 	SP_TitleBarMinButton,
@@ -711,39 +1021,86 @@ public:
 	SP_CustomBase =		0xf0000000
     };
 
+    // Old API
+    // DEPRECATED
     virtual TQPixmap stylePixmap( StylePixmap stylepixmap,
 				 const TQWidget *widget = 0,
 				 const TQStyleOption& = TQStyleOption::Default ) const = 0;
 
+    virtual TQPixmap stylePixmap( StylePixmap stylepixmap,
+				 TQStyleControlElementData ceData,
+				 ControlElementFlags elementFlags,
+				 const TQStyleOption& = TQStyleOption::Default,
+				 const TQWidget *widget = 0 ) const = 0;
+
 
+    // Old API
+    // DEPRECATED
     static TQRect visualRect( const TQRect &logical, const TQWidget *w );
 
+    // New API
+    static TQRect visualRect( const TQRect &logical, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags );
+
     static TQRect visualRect( const TQRect &logical, const TQRect &bounding );
 
 
+    // Object event handling API
+    typedef TQMap<void*, TQStyle*> ObjectEventSourceToHandlerMap;
+    typedef TQMap<void*, TQStyleControlElementData> ObjectEventSourceDataToHandlerMap;
+    typedef TQMap<void*, ControlElementFlags> ObjectEventSourceFlagsToHandlerMap;
+    typedef bool (*EventHandlerInstallationHook)(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler);
+    typedef bool (*EventHandlerRemovalHook)(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler);
+    void installObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler );
+    void removeObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler );
+    void setEventHandlerInstallationHook( EventHandlerInstallationHook );
+    void setEventHandlerRemovalHook( EventHandlerRemovalHook hook );
+    virtual bool objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e );
+
+    enum WidgetActionRequest {
+	WAR_Repaint,
+	WAR_RepaintRect,
+	WAR_EnableMouseTracking,
+	WAR_DisableMouseTracking,
+	WAR_FrameSetStyle,
+	WAR_FrameSetLineWidth,
+	WAR_SetLayoutMargin,
+	WAR_SetPalette,
+	WAR_SetBackgroundMode,
+	WAR_SetFont,
+	WAR_RepaintAllAccelerators
+    };
 
+    typedef bool (*WidgetActionRequestHook)(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, WidgetActionRequest request, TQStyleWidgetActionRequestData requestData);
+    void setWidgetActionRequestHook( WidgetActionRequestHook );
+    virtual bool widgetActionRequest( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, WidgetActionRequest request, TQStyleWidgetActionRequestData requestData = TQStyleWidgetActionRequestData() );
 
     // Old 2.x TQStyle API
 
 #ifndef QT_NO_COMPAT
     int defaultFrameWidth() const
     {
-	return pixelMetric( PM_DefaultFrameWidth );
+	return pixelMetric( PM_DefaultFrameWidth, TQStyleControlElementData(), CEF_None );
     }
     void tabbarMetrics( const TQWidget* t,
 			int& hf, int& vf, int& ov ) const
     {
-	hf = pixelMetric( PM_TabBarTabHSpace, t );
-	vf = pixelMetric( PM_TabBarTabVSpace, t );
-	ov = pixelMetric( PM_TabBarBaseOverlap, t );
+	hf = pixelMetric( PM_TabBarTabHSpace, TQStyleControlElementData(), CEF_None, t );
+	vf = pixelMetric( PM_TabBarTabVSpace, TQStyleControlElementData(), CEF_None, t );
+	ov = pixelMetric( PM_TabBarBaseOverlap, TQStyleControlElementData(), CEF_None, t );
     }
     TQSize scrollBarExtent() const
     {
-	return TQSize(pixelMetric(PM_ScrollBarExtent),
-		     pixelMetric(PM_ScrollBarExtent));
+	return TQSize(pixelMetric(PM_ScrollBarExtent, TQStyleControlElementData(), CEF_None),
+		     pixelMetric(PM_ScrollBarExtent, TQStyleControlElementData(), CEF_None));
     }
 #endif
 
+public:
+    virtual bool eventFilter( TQObject *, TQEvent * );
+    bool acceleratorsShown() const;
+
+protected:
+    void acceleratorKeypressEventMonitor( TQObject *, TQEvent * );
 
 private:
     TQStylePrivate * d;
@@ -752,7 +1109,22 @@ private:
     TQStyle( const TQStyle & );
     TQStyle& operator=( const TQStyle & );
 #endif
+
+    EventHandlerInstallationHook m_eventHandlerInstallationHook;
+    EventHandlerRemovalHook m_eventHandlerRemovalHook;
+    WidgetActionRequestHook m_widgetActionRequestHook;
+    ObjectEventSourceToHandlerMap m_objectEventSourceToHandlerMap;
+    ObjectEventSourceDataToHandlerMap m_objectEventSourceDataToHandlerMap;
+    ObjectEventSourceFlagsToHandlerMap m_objectEventSourceFlagsToHandlerMap;
+    bool conditionalAcceleratorsEnabled;
 };
 
+inline TQStyle::ControlElementFlags operator|(const TQStyle::ControlElementFlags a, const TQStyle::ControlElementFlags b) { return static_cast<TQStyle::ControlElementFlags>(static_cast<int>(a) | static_cast<int>(b)); }
+// inline TQStyle::ControlElementFlags operator|=(TQStyle::ControlElementFlags &a, const TQStyle::ControlElementFlags b) { a = static_cast<TQStyle::ControlElementFlags>(static_cast<int>(a) | static_cast<int>(b)); return a; }
+
+Q_EXPORT TQStyleControlElementData populateControlElementDataFromWidget(const TQWidget* widget, const TQStyleOption& opt, bool populateReliantFields=true);
+Q_EXPORT TQStyle::ControlElementFlags getControlElementFlagsForObject(const TQObject* object, TQStringList objectTypeList, const TQStyleOption& opt, bool populateReliantFields=true);
+Q_EXPORT TQStringList getObjectTypeListForObject(const TQObject* object);
+
 #endif // QT_NO_STYLE
 #endif // TQSTYLE_H
diff --git a/src/kernel/ntqwidget.h b/src/kernel/ntqwidget.h
index 6529236a..c4a288d4 100644
--- a/src/kernel/ntqwidget.h
+++ b/src/kernel/ntqwidget.h
@@ -456,6 +456,9 @@ public:
     WState		testWState( WState s ) const;
     WFlags		testWFlags( WFlags f ) const;
     NFlags		testNFlags( NFlags f ) const;
+    uint		getWState() const;
+    WFlags		getWFlags() const;
+    NFlags		getNFlags() const;
     static TQWidget *	find( WId );
     static TQWidgetMapper *wmapper();
 
@@ -573,13 +576,10 @@ protected:
 			 bool destroyOldWindow = TRUE );
     virtual void destroy( bool destroyWindow = TRUE,
 			  bool destroySubWindows = TRUE );
-    uint	 getWState() const;
     virtual void setWState( uint );
     void	 clearWState( uint n );
-    WFlags	 getWFlags() const;
     virtual void setWFlags( WFlags );
     void	 clearWFlags( WFlags n );
-    NFlags	 getNFlags() const;
     virtual void setNFlags( NFlags );
     void	 clearNFlags( NFlags n );
 
diff --git a/src/kernel/qapplication_x11.cpp b/src/kernel/qapplication_x11.cpp
index abf1e953..03e7a779 100644
--- a/src/kernel/qapplication_x11.cpp
+++ b/src/kernel/qapplication_x11.cpp
@@ -2147,7 +2147,7 @@ void tqt_init_internal( int *argcptr, char **argv,
 		for (i = 0; i < map->max_keypermod; i++) {
 		    if (map->modifiermap[mapIndex]) {
 			KeySym sym =
-			    XKeycodeToKeysym(appDpy, map->modifiermap[mapIndex], 0);
+			    XkbKeycodeToKeysym(appDpy, map->modifiermap[mapIndex], 0, 0);
 			if ( qt_alt_mask == 0 &&
 			     ( sym == XK_Alt_L || sym == XK_Alt_R ) ) {
 			    qt_alt_mask = 1 << maskIndex;
@@ -2177,7 +2177,7 @@ void tqt_init_internal( int *argcptr, char **argv,
 		for ( i = 0; i < map->max_keypermod; i++ ) {
 		    if ( map->modifiermap[ mapIndex ] ) {
 			KeySym sym =
-			    XKeycodeToKeysym( appDpy, map->modifiermap[ mapIndex ], 0 );
+			    XkbKeycodeToKeysym( appDpy, map->modifiermap[ mapIndex ], 0, 0 );
 			if ( sym == XK_Mode_switch ) {
 			    qt_mode_switch_remove_mask |= 1 << maskIndex;
 			}
diff --git a/src/kernel/qstyle.cpp b/src/kernel/qstyle.cpp
index 25c9b180..26fbf0cb 100644
--- a/src/kernel/qstyle.cpp
+++ b/src/kernel/qstyle.cpp
@@ -44,6 +44,10 @@
 #include "ntqpainter.h"
 #include "ntqbitmap.h"
 #include "ntqpixmapcache.h"
+#include "ntqframe.h"
+#include "ntqlayout.h"
+#include "ntqobjectlist.h"
+#include "ntqwidgetlist.h"
 
 #include <limits.h>
 
@@ -394,6 +398,10 @@ public:
 */
 TQStyle::TQStyle()
 {
+    m_eventHandlerInstallationHook = NULL;
+    m_eventHandlerRemovalHook = NULL;
+    m_widgetActionRequestHook = NULL;
+    conditionalAcceleratorsEnabled = false;
     d = new TQStylePrivate;
 }
 
@@ -414,8 +422,6 @@ TQStyle::~TQStyle()
   style. Current supported values are TQt::WindowsStyle and TQt::MotifStyle.
 */
 
-
-
 /*!
     Initializes the appearance of a widget.
 
@@ -439,8 +445,9 @@ TQStyle::~TQStyle()
 
     \sa unPolish()
 */
-void TQStyle::polish( TQWidget*)
-{
+void TQStyle::polish( TQWidget *widget ) {
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
+	polish(ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), widget);
 }
 
 /*!
@@ -453,10 +460,62 @@ void TQStyle::polish( TQWidget*)
 
     \sa polish()
 */
-void TQStyle::unPolish( TQWidget*)
-{
+void TQStyle::unPolish( TQWidget *widget ) {
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
+	unPolish(ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), widget);
+}
+
+/*!
+    Initializes the appearance of a widget.
+
+    This function is called for every widget at some point after it
+    has been fully created but just \e before it is shown the very
+    first time.
+
+    Reasonable actions in this function might be to install a widget
+    event handler for the style. An example of highly unreasonable
+    use would be setting the geometry! With TQt 3.0's style engine
+    you will rarely need to write your own polish(); instead reimplement
+    drawItem(), drawPrimitive(), etc.
+
+    The \a objectTypes object may provide enough information to
+    allow class-specific customizations. But be careful not to
+    hard-code things too much because new TQStyle subclasses are
+    expected to work reasonably with all current and \e future
+    widgets.
+
+    You may specify either a TQWidget pointer or a custom pointer.
+    If a custom pointer is specified, you must be careful to intercept any event
+    handler installation/removal calls via setEventHandlerInstallationHook and
+    setEventHandlerRemovalHook.
+
+    \sa unPolish()
+*/
+void TQStyle::polish( TQStyleControlElementData ceData, ControlElementFlags, void *ptr ) {
+	if (ceData.widgetObjectTypes.contains("TQWidget")) {
+		// Enable dynamic hide/show of accelerator shortcuts
+		TQWidget* widget = reinterpret_cast<TQWidget*>(ptr);
+		widget->installEventFilter(this);
+	}
 }
 
+/*!
+    Undoes the initialization of a widget's appearance.
+
+    This function is the counterpart to polish. It is called for every
+    polished widget when the style is dynamically changed. The former
+    style has to unpolish its settings before the new style can polish
+    them again.
+
+    \sa polish()
+*/
+void TQStyle::unPolish( TQStyleControlElementData ceData, ControlElementFlags, void *ptr ) {
+	if (ceData.widgetObjectTypes.contains("TQWidget")) {
+		// Disable dynamic hide/show of accelerator shortcuts
+		TQWidget* widget = reinterpret_cast<TQWidget*>(ptr);
+		widget->installEventFilter(this);
+	}
+}
 
 /*!
     \overload
@@ -464,8 +523,10 @@ void TQStyle::unPolish( TQWidget*)
 
     \sa unPolish()
 */
-void TQStyle::polish( TQApplication*)
-{
+void TQStyle::polish( TQApplication *app ) {
+	TQStyleControlElementData ceData;
+	ceData.widgetObjectTypes = getObjectTypeListForObject(app);
+	applicationPolish(ceData, getControlElementFlagsForObject(app, ceData.widgetObjectTypes, TQStyleOption()), app);
 }
 
 /*!
@@ -475,8 +536,41 @@ void TQStyle::polish( TQApplication*)
 
     \sa polish()
 */
-void TQStyle::unPolish( TQApplication*)
-{
+void TQStyle::unPolish( TQApplication *app ) {
+	TQStyleControlElementData ceData;
+	ceData.widgetObjectTypes = getObjectTypeListForObject(app);
+	applicationUnPolish(ceData, getControlElementFlagsForObject(app, ceData.widgetObjectTypes, TQStyleOption()), app);
+}
+
+/*!
+    \overload
+    Late initialization of the TQApplication object or other global application object.
+
+    You may specify either a TQApplication pointer or a custom pointer.
+    If a custom pointer is specified, you must be careful to intercept any event
+    handler installation/removal calls via setEventHandlerInstallationHook and
+    setEventHandlerRemovalHook.
+
+    \sa unPolish()
+*/
+void TQStyle::applicationPolish( TQStyleControlElementData, ControlElementFlags, void * ) {
+	//
+}
+
+/*!
+    \overload
+
+    Undoes the application polish.
+
+    You may specify either a TQApplication pointer or a custom pointer.
+    If a custom pointer is specified, you must be careful to intercept any event
+    handler installation/removal calls via setEventHandlerInstallationHook and
+    setEventHandlerRemovalHook.
+
+    \sa polish()
+*/
+void TQStyle::applicationUnPolish( TQStyleControlElementData, ControlElementFlags, void * ) {
+	//
 }
 
 /*!
@@ -802,11 +896,14 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn void TQStyle::drawPrimitive( PrimitiveElement pe, TQPainter *p, const TQRect &r, const TQColorGroup &cg, SFlags flags, const TQStyleOption& opt) const
+    \fn void TQStyle::drawPrimitive( PrimitiveElement pe, TQPainter *p, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQRect &r, const TQColorGroup &cg, SFlags flags, const TQStyleOption& opt) const
 
     Draws the style PrimitiveElement \a pe using the painter \a p in
     the area \a r. Colors are used from the color group \a cg.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The rect \a r should be in screen coordinates.
 
     The \a flags argument is used to control how the PrimitiveElement
@@ -932,20 +1029,25 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn void TQStyle::drawControl( ControlElement element, TQPainter *p, const TQWidget *widget, const TQRect &r, const TQColorGroup &cg, SFlags how, const TQStyleOption& opt) const
+    \fn void TQStyle::drawControl( ControlElement element, TQPainter *p, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQRect &r, const TQColorGroup &cg, SFlags how, const TQStyleOption& opt, const TQWidget *widget) const
 
     Draws the ControlElement \a element using the painter \a p in the
     area \a r. Colors are used from the color group \a cg.
 
     The rect \a r should be in screen coordinates.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The \a how argument is used to control how the ControlElement is
     drawn. Multiple flags can be OR'ed together. See the table below
     for an explanation of which flags are used with the various
     ControlElements.
 
     The \a widget argument is a pointer to a TQWidget or one of its
-    subclasses. The widget can be cast to the appropriate type based
+    subclasses. Note that usage of the widget argument is deprecated
+    in favor of specifying widget parameters via \a ceData and \a elementFlags.
+    The widget can be cast to the appropriate type based
     on the value of \a element. The \a opt argument can be used to
     pass extra information required when drawing the ControlElement.
     Note that \a opt may be the default value even for ControlElements
@@ -1086,14 +1188,19 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn void TQStyle::drawControlMask( ControlElement element, TQPainter *p, const TQWidget *widget, const TQRect &r, const TQStyleOption& opt) const
+    \fn void TQStyle::drawControlMask( ControlElement element, TQPainter *p, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQRect &r, const TQStyleOption& opt, const TQWidget *widget) const
 
     Draw a bitmask for the ControlElement \a element using the painter
     \a p in the area \a r. See drawControl() for an explanation of the
     use of the \a widget and \a opt arguments.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The rect \a r should be in screen coordinates.
 
+    \a widget is deprecated and should not be used.
+
     \sa drawControl(), ControlElement
 */
 
@@ -1154,15 +1261,19 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn TQRect TQStyle::subRect( SubRect subrect, const TQWidget *widget ) const;
+    \fn TQRect TQStyle::subRect( SubRect subrect, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags, const TQWidget *widget ) const;
 
     Returns the sub-area \a subrect for the \a widget in logical
     coordinates.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The \a widget argument is a pointer to a TQWidget or one of its
-    subclasses. The widget can be cast to the appropriate type based
-    on the value of \a subrect. See the table below for the
-    appropriate \a widget casts:
+    subclasses. Note that usage of \a widget is deprecated in favor
+    of \a ceData and \a elementFlags. The widget can be cast to the
+    appropriate type based on the value of \a subrect. See the table
+    below for the appropriate \a widget casts:
 
     \table
     \header \i SubRect \i Widget Cast
@@ -1282,7 +1393,7 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn void TQStyle::drawComplexControl( ComplexControl control, TQPainter *p, const TQWidget *widget, const TQRect &r, const TQColorGroup &cg, SFlags how, SCFlags sub, SCFlags subActive, const TQStyleOption& opt ) const
+    \fn void TQStyle::drawComplexControl( ComplexControl control, TQPainter *p, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQRect &r, const TQColorGroup &cg, SFlags how, SCFlags sub, SCFlags subActive, const TQStyleOption& opt, const TQWidget *widget ) const
 
     Draws the ComplexControl \a control using the painter \a p in the
     area \a r. Colors are used from the color group \a cg. The \a sub
@@ -1295,6 +1406,9 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
     coordinates into screen coordinates when using drawPrimitive() and
     drawControl().
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The \a how argument is used to control how the ComplexControl is
     drawn. Multiple flags can OR'ed together. See the table below for
     an explanation of which flags are used with the various
@@ -1302,11 +1416,13 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 
     The \a widget argument is a pointer to a TQWidget or one of its
     subclasses. The widget can be cast to the appropriate type based
-    on the value of \a control. The \a opt argument can be used to
-    pass extra information required when drawing the ComplexControl.
-    Note that \a opt may be the default value even for ComplexControls
-    that can make use of the extra options. See the table below for
-    the appropriate \a widget and \a opt usage:
+    on the value of \a control. Note that usage of \a widget is
+    deprecated in favor of \a ceData and \a elementFlags.  The \a opt
+    argument can be used to pass extra information required when
+    drawing the ComplexControl. Note that \a opt may be the default
+    value even for ComplexControls that can make use of the extra
+    options. See the table below for the appropriate \a widget and
+    \a opt usage:
 
     \table
     \header \i ComplexControl<br>\& Widget Cast
@@ -1375,26 +1491,34 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn void TQStyle::drawComplexControlMask( ComplexControl control, TQPainter *p, const TQWidget *widget, const TQRect &r, const TQStyleOption& opt) const
+    \fn void TQStyle::drawComplexControlMask( ComplexControl control, TQPainter *p, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags, const TQRect &r, const TQStyleOption& opt, const TQWidget *widget) const
 
     Draw a bitmask for the ComplexControl \a control using the painter
     \a p in the area \a r. See drawComplexControl() for an explanation
     of the use of the \a widget and \a opt arguments.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The rect \a r should be in logical coordinates. Reimplementations
     of this function should use visualRect() to change the logical
     corrdinates into screen coordinates when using drawPrimitive() and
     drawControl().
 
+    Note that usage of \a widget is deprecated in favor of \a ceData and \a elementFlags.
+
     \sa drawComplexControl() ComplexControl
 */
 
 /*!
-    \fn TQRect TQStyle::querySubControlMetrics( ComplexControl control, const TQWidget *widget, SubControl subcontrol, const TQStyleOption& opt = TQStyleOption::Default ) const;
+    \fn TQRect TQStyle::querySubControlMetrics( ComplexControl control, TQStyleControlElementData ceData, ControlElementFlags elementFlags, SubControl subcontrol, const TQStyleOption& opt = TQStyleOption::Default, const TQWidget *widget = 0 ) const;
 
     Returns the rect for the SubControl \a subcontrol for \a widget in
     logical coordinates.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The \a widget argument is a pointer to a TQWidget or one of its
     subclasses. The widget can be cast to the appropriate type based
     on the value of \a control. The \a opt argument can be used to
@@ -1403,11 +1527,13 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
     that can make use of the extra options. See drawComplexControl()
     for an explanation of the \a widget and \a opt arguments.
 
+    Note that usage of \a widget is deprecated in favor of \a ceData and \a elementFlags.
+
     \sa drawComplexControl(), ComplexControl, SubControl
 */
 
 /*!
-    \fn SubControl TQStyle::querySubControl( ComplexControl control, const TQWidget *widget, const TQPoint &pos, const TQStyleOption& opt = TQStyleOption::Default ) const;
+    \fn SubControl TQStyle::querySubControl( ComplexControl control, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQPoint &pos, const TQStyleOption& opt = TQStyleOption::Default, const TQWidget *widget = 0 ) const;
 
     Returns the SubControl for \a widget at the point \a pos. The \a
     widget argument is a pointer to a TQWidget or one of its
@@ -1418,11 +1544,16 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
     that can make use of the extra options. See drawComplexControl()
     for an explanation of the \a widget and \a opt arguments.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     Note that \a pos is passed in screen coordinates. When using
     querySubControlMetrics() to check for hits and misses, use
     visualRect() to change the logical coordinates into screen
     coordinates.
 
+    Note that usage of \a widget is deprecated in favor of \a ceData and \a elementFlags.
+
     \sa drawComplexControl(), ComplexControl, SubControl, querySubControlMetrics()
 */
 
@@ -1528,14 +1659,20 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn int TQStyle::pixelMetric( PixelMetric metric, const TQWidget *widget = 0 ) const;
+    \fn int TQStyle::pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0 ) const;
+
+    Returns the pixel metric for \a metric.
+
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
 
-    Returns the pixel metric for \a metric. The \a widget argument is
-    a pointer to a TQWidget or one of its subclasses. The widget can be
-    cast to the appropriate type based on the value of \a metric. Note
-    that \a widget may be zero even for PixelMetrics that can make use
-    of \a widget. See the table below for the appropriate \a widget
-    casts:
+    The \a widget argument is a pointer to a TQWidget or one of its
+    subclasses. The widget can be cast to the appropriate type based
+    on the value of \a metric. Note that \a widget may be zero even
+    for PixelMetrics that can make use of \a widget. Note also that
+    usage of \a widget is deprecated in favor of \a ceData and
+    \a elementFlags.  See the table below for the appropriate
+    \a widget casts:
 
     \table
     \header \i PixelMetric \i Widget Cast
@@ -1584,18 +1721,22 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn TQSize TQStyle::sizeFromContents( ContentsType contents, const TQWidget *widget, const TQSize &contentsSize, const TQStyleOption& opt = TQStyleOption::Default ) const;
+    \fn TQSize TQStyle::sizeFromContents( ContentsType contents, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQSize &contentsSize, const TQStyleOption& opt = TQStyleOption::Default, const TQWidget *widget = 0 ) const;
 
     Returns the size of \a widget based on the contents size \a
     contentsSize.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The \a widget argument is a pointer to a TQWidget or one of its
     subclasses. The widget can be cast to the appropriate type based
     on the value of \a contents. The \a opt argument can be used to
     pass extra information required when calculating the size. Note
     that \a opt may be the default value even for ContentsTypes that
-    can make use of the extra options. See the table below for the
-    appropriate \a widget and \a opt usage:
+    can make use of the extra options. Note that usage of \a widget
+    is deprecated in favor of \a ceData and \a elementFlags. See the
+    table below for the appropriate \a widget and \a opt usage:
 
     \table
     \header \i ContentsType \i Widget Cast \i Options \i Notes
@@ -1770,12 +1911,18 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn int TQStyle::styleHint( StyleHint stylehint, const TQWidget *widget = 0, const TQStyleOption &opt = TQStyleOption::Default, TQStyleHintReturn *returnData = 0 ) const;
+    \fn int TQStyle::styleHint( StyleHint stylehint, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQStyleOption &opt = TQStyleOption::Default, TQStyleHintReturn *returnData = 0, const TQWidget *widget = 0 ) const;
 
     Returns the style hint \a stylehint for \a widget. Currently, \a
     widget, \a opt, and \a returnData are unused; they're included to
     allow for future enhancements.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
+    Note that usage of \a widget is deprecated in favor of \a ceData
+    and \a elementFlags.
+
     For an explanation of the return value see \l StyleHint.
 */
 
@@ -1811,10 +1958,13 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 */
 
 /*!
-    \fn TQPixmap TQStyle::stylePixmap( StylePixmap stylepixmap, const TQWidget *widget = 0, const TQStyleOption& opt = TQStyleOption::Default ) const;
+    \fn TQPixmap TQStyle::stylePixmap( StylePixmap stylepixmap, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQStyleOption& opt = TQStyleOption::Default, const TQWidget *widget = 0 ) const;
 
     Returns a pixmap for \a stylepixmap.
 
+    \a ceData and \a elementFlags provide additional information about
+    the widget for which the PrimitiveElement is being drawn.
+
     The \a opt argument can be used to pass extra information required
     when drawing the ControlElement. Note that \a opt may be the
     default value even for StylePixmaps that can make use of the extra
@@ -1822,8 +1972,9 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
 
     The \a widget argument is a pointer to a TQWidget or one of its
     subclasses. The widget can be cast to the appropriate type based
-    on the value of \a stylepixmap. See the table below for the
-    appropriate \a widget casts:
+    on the value of \a stylepixmap. Note that usage of \a widget is
+    deprecated in favor of \a ceData and \a elementFlags.See the table
+    below for the appropriate \a widget casts:
 
     \table
     \header \i StylePixmap \i Widget Cast
@@ -1847,11 +1998,33 @@ void TQStyle::drawItem( TQPainter *p, const TQRect &r,
     function is provided to aid style implementors in supporting
     right-to-left mode.
 
+    Note that this function is deprecated in favor of visualRect( const TQRect &logical, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags );
+
     \sa TQApplication::reverseLayout()
 */
 TQRect TQStyle::visualRect( const TQRect &logical, const TQWidget *w )
 {
-    TQRect boundingRect = w->rect();
+    TQStyleControlElementData ceData;
+    ceData.rect = w->rect();
+    return visualRect(logical, ceData, CEF_None);
+}
+
+/*!
+    \fn TQRect TQStyle::visualRect( const TQRect &logical, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags );
+
+    Returns the rect \a logical in screen coordinates. The bounding
+    rect for the widget described by \a ceData and \a elementFlags
+    is used to perform the translation. This function is provided to
+    aid style implementors in supporting
+    right-to-left mode.
+
+    \sa TQApplication::reverseLayout()
+*/
+TQRect TQStyle::visualRect( const TQRect &logical, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags )
+{
+    Q_UNUSED(elementFlags)
+
+    TQRect boundingRect = ceData.rect;
     TQRect r = logical;
     if ( TQApplication::reverseLayout() )
 	r.moveBy( 2*(boundingRect.right() - logical.right()) +
@@ -1879,6 +2052,279 @@ TQRect TQStyle::visualRect( const TQRect &logical, const TQRect &boundingRect )
 }
 
 /*!
+    \fn void TQStyle::installObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler );
+
+    Intercepts events generated by \a source and sends them to \a handler via
+    the bool TQStyle::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e ) virtual method.
+
+    \sa void TQStyle::removeObjectEventHandler( TQObject* source, TQStyle* handler )
+    \sa bool TQStyle::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e )
+*/
+void TQStyle::installObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler ) {
+	bool cbret = false;
+	if (m_eventHandlerInstallationHook) {
+		cbret = (*m_eventHandlerInstallationHook)(ceData, elementFlags, source, handler);
+	}
+	if (!cbret) {
+		if (ceData.widgetObjectTypes.contains("TQObject")) {
+			TQObject* o = reinterpret_cast<TQObject*>(source);
+			o->installEventFilter(this);
+			m_objectEventSourceToHandlerMap[source] = handler;
+			m_objectEventSourceDataToHandlerMap[source] = ceData;
+			m_objectEventSourceFlagsToHandlerMap[source] = elementFlags;
+		}
+	}
+}
+
+/*!
+    \fn void TQStyle::removeObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler );
+
+    Stops intercepting events generated by \a source.
+
+    \sa void TQStyle::installObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler )
+*/
+void TQStyle::removeObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler ) {
+	bool cbret = false;
+	if (m_eventHandlerRemovalHook) {
+		cbret = (*m_eventHandlerRemovalHook)(ceData, elementFlags, source, handler);
+	}
+	if (!cbret) {
+		if (ceData.widgetObjectTypes.contains("TQObject")) {
+			TQObject* o = reinterpret_cast<TQObject*>(source);
+			m_objectEventSourceToHandlerMap.remove(source);
+			m_objectEventSourceDataToHandlerMap.remove(source);
+			m_objectEventSourceFlagsToHandlerMap.remove(source);
+			o->removeEventFilter(this);
+		}
+	}
+}
+
+/*!
+    \fn void TQStyle::setEventHandlerInstallationHook( EventHandlerInstallationHook hook );
+
+    Sets a callback function \a hook which will be called whenever a new intercept request
+    is made via the TQStyle::installObjectEventHandler method.  The callback function must
+    use this definition: bool callbackFunction( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler ).
+
+    \sa void TQStyle::installObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler )
+*/
+void TQStyle::setEventHandlerInstallationHook( EventHandlerInstallationHook hook ) {
+	m_eventHandlerInstallationHook = hook;
+}
+
+/*!
+    \fn void TQStyle::setEventHandlerRemovalHook( EventHandlerRemovalHook hook );
+
+    Sets a callback function \a hook which will be called whenever a new intercept deactivation request
+    is made via the TQStyle::removeObjectEventHandler method.  The callback function must
+    use this definition: bool callbackFunction( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler ).
+
+    \sa void TQStyle::removeObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler )
+*/
+void TQStyle::setEventHandlerRemovalHook( EventHandlerRemovalHook hook ) {
+	m_eventHandlerRemovalHook = hook;
+}
+
+/*!
+    \fn bool TQStyle::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e );
+
+    Override this virtual function to intercept events requested by a previous call to
+    TQStyle::installObjectEventHandler.
+
+    \sa void TQStyle::installObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler )
+    \sa void TQStyle::removeObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler )
+*/
+bool TQStyle::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e ) {
+	Q_UNUSED(ceData);
+	Q_UNUSED(elementFlags);
+	Q_UNUSED(source);
+	Q_UNUSED(e);
+	return false;
+}
+
+/*!
+    \fn bool TQStyle::eventFilter(TQObject *o, TQEvent *e);
+    \internal
+*/
+bool TQStyle::eventFilter(TQObject *o, TQEvent *e) {
+	acceleratorKeypressEventMonitor(o, e);
+
+	if (m_objectEventSourceToHandlerMap.contains(o)) {
+		TQStyle* handler = m_objectEventSourceToHandlerMap[o];
+		TQStyleControlElementData ceData = m_objectEventSourceDataToHandlerMap[o];
+		ControlElementFlags elementFlags = m_objectEventSourceFlagsToHandlerMap[o];
+		bool ret = handler->objectEventHandler(ceData, elementFlags, o, e);
+		if (ret) {
+			return ret;
+		}
+		else {
+			return TQObject::eventFilter(o, e);
+		}
+	}
+	else {
+		return TQObject::eventFilter(o, e);
+	}
+}
+
+/*!
+    \fn void TQStyle::setWidgetActionRequestHook( WidgetActionRequestHook hook );
+
+    Sets a callback function \a hook which will be called whenever a new widget action request
+    is made via the TQStyle::installObjectEventHandler method.  The callback function must
+    use this definition: bool callbackFunction( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler ).
+
+    \sa void TQStyle::installObjectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQStyle* handler )
+*/
+void TQStyle::setWidgetActionRequestHook( WidgetActionRequestHook hook ) {
+	m_widgetActionRequestHook = hook;
+}
+
+/*!
+    \fn bool widgetActionRequestHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, WidgetActionRequest request );
+
+    Handles widget action requests.  Return FALSE to continue processing in base classes, TRUE to eat the request and halt processing.
+*/
+bool TQStyle::widgetActionRequest( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, WidgetActionRequest request, TQStyleWidgetActionRequestData requestData ) {
+	bool cbret = false;
+	if (m_widgetActionRequestHook) {
+		cbret = (*m_widgetActionRequestHook)(ceData, elementFlags, source, request, requestData);
+	}
+	if (!cbret) {
+		if (ceData.widgetObjectTypes.contains("TQWidget")) {
+			TQWidget* widget = reinterpret_cast<TQWidget*>(source);
+			if (request == WAR_Repaint) {
+				widget->repaint(FALSE);
+			}
+			else if (request == WAR_RepaintRect) {
+				widget->repaint(requestData.rect, FALSE);
+			}
+			else if (request == WAR_EnableMouseTracking) {
+				widget->setMouseTracking(TRUE);
+			}
+			else if (request == WAR_DisableMouseTracking) {
+				widget->setMouseTracking(FALSE);
+			}
+			else if (request == WAR_FrameSetStyle) {
+				TQFrame* frame = dynamic_cast<TQFrame*>(widget);
+				if (frame) {
+					frame->setFrameStyle(requestData.metric1);
+				}
+			}
+			else if (request == WAR_FrameSetLineWidth) {
+				TQFrame* frame = dynamic_cast<TQFrame*>(widget);
+				if (frame) {
+					frame->setLineWidth(requestData.metric1);
+				}
+			}
+			else if (request == WAR_SetLayoutMargin) {
+				TQLayout* layout = widget->layout();
+				if (layout) {
+					layout->setMargin(requestData.metric1);
+				}
+			}
+			else if (request == WAR_SetPalette) {
+				widget->setPalette(requestData.palette);
+			}
+			else if (request == WAR_SetBackgroundMode) {
+				widget->setBackgroundMode((TQt::BackgroundMode)requestData.metric1);
+			}
+			else if (request == WAR_SetFont) {
+				widget->setFont(requestData.font);
+			}
+			else if (request == WAR_RepaintAllAccelerators) {
+				TQWidgetList *list = TQApplication::topLevelWidgets();
+				TQWidgetListIt it( *list );
+				TQWidget * widget;
+				while ((widget=it.current()) != 0) {
+					++it;
+
+					TQObjectList *l = widget->queryList("TQWidget");
+					TQObjectListIt it2( *l );
+					TQWidget *w;
+					while ( (w = (TQWidget*)it2.current()) != 0 ) {
+						++it2;
+						if (w->isTopLevel() || !w->isVisible() || w->style().styleHint(SH_UnderlineAccelerator, TQStyleControlElementData(), CEF_None, w)) {
+							l->removeRef(w);
+						}
+					}
+
+					// Repaint all relevant widgets
+					it2.toFirst();
+					while ( (w = (TQWidget*)it2.current()) != 0 ) {
+						++it2;
+						w->repaint(FALSE);
+					}
+					delete l;
+				}
+    				delete list;
+			}
+			return true;
+		}
+	}
+	return true;
+}
+
+void TQStyle::acceleratorKeypressEventMonitor( TQObject *o, TQEvent *e ) {
+	if (styleHint(SH_HideUnderlineAcceleratorWhenAltUp, TQStyleControlElementData(), CEF_None, TQStyleOption::Default, NULL, NULL) != 0) {
+		TQWidget *widget = dynamic_cast<TQWidget*>(o);
+		if (widget) {
+			switch(e->type()) {
+				case TQEvent::KeyPress:
+					if (((TQKeyEvent*)e)->key() == Key_Alt) {
+						conditionalAcceleratorsEnabled = true;
+						widgetActionRequest(TQStyleControlElementData(), CEF_None, o, WAR_RepaintAllAccelerators);
+					}
+					break;
+				case TQEvent::KeyRelease:
+					if (((TQKeyEvent*)e)->key() == Key_Alt) {
+						conditionalAcceleratorsEnabled = false;
+						widgetActionRequest(TQStyleControlElementData(), CEF_None, o, WAR_RepaintAllAccelerators);
+					}
+					break;
+				default:
+					break;
+			}
+		}
+	}
+	else {
+		conditionalAcceleratorsEnabled = false;
+	}
+}
+
+bool TQStyle::acceleratorsShown() const {
+	if (styleHint(SH_HideUnderlineAcceleratorWhenAltUp, TQStyleControlElementData(), CEF_None, TQStyleOption::Default, NULL, NULL) != 0) {
+			return conditionalAcceleratorsEnabled;
+	}
+	else {
+		return true;
+	}
+}
+
+TQStyleWidgetActionRequestData::TQStyleWidgetActionRequestData() {
+	//
+}
+TQStyleWidgetActionRequestData::TQStyleWidgetActionRequestData(int param1, int param2) {
+	metric1 = param1;
+	metric2 = param2;
+}
+
+TQStyleWidgetActionRequestData::TQStyleWidgetActionRequestData(TQPalette param) {
+	palette = param;
+}
+
+TQStyleWidgetActionRequestData::TQStyleWidgetActionRequestData(TQFont param) {
+	font = param;
+}
+
+TQStyleWidgetActionRequestData::TQStyleWidgetActionRequestData(TQRect param) {
+	rect = param;
+}
+
+TQStyleWidgetActionRequestData::~TQStyleWidgetActionRequestData() {
+	//
+}
+
+/*!
   \fn int TQStyle::defaultFrameWidth() const
   \obsolete
 */
diff --git a/src/styles/ntqcdestyle.h b/src/styles/ntqcdestyle.h
index 5266130b..13b2c024 100644
--- a/src/styles/ntqcdestyle.h
+++ b/src/styles/ntqcdestyle.h
@@ -62,18 +62,22 @@ public:
     TQCDEStyle( bool useHighlightCols = FALSE );
     virtual ~TQCDEStyle();
 
-    int pixelMetric( PixelMetric metric, const TQWidget *widget = 0 ) const;
+    int pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0 ) const;
 
     void drawControl( ControlElement element,
 		      TQPainter *p,
-		      const TQWidget *widget,
+		      TQStyleControlElementData ceData,
+		      ControlElementFlags elementFlags,
 		      const TQRect &r,
 		      const TQColorGroup &cg,
 		      SFlags how = Style_Default,
-		      const TQStyleOption& = TQStyleOption::Default ) const;
+		      const TQStyleOption& = TQStyleOption::Default,
+		      const TQWidget *widget = 0 ) const;
 
     void drawPrimitive( PrimitiveElement pe,
 			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
 			const TQRect &r,
 			const TQColorGroup &cg,
 			SFlags flags = Style_Default,
diff --git a/src/styles/ntqcommonstyle.h b/src/styles/ntqcommonstyle.h
index 6fd636fd..ed02fe41 100644
--- a/src/styles/ntqcommonstyle.h
+++ b/src/styles/ntqcommonstyle.h
@@ -55,6 +55,8 @@ public:
     TQCommonStyle();
     ~TQCommonStyle();
 
+    // Old API
+    // DEPRECATED
     void drawPrimitive( PrimitiveElement pe,
 			TQPainter *p,
 			const TQRect &r,
@@ -62,22 +64,63 @@ public:
 			SFlags flags = Style_Default,
 			const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    void drawPrimitive( PrimitiveElement pe,
+			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
+			const TQRect &r,
+			const TQColorGroup &cg,
+			SFlags flags = Style_Default,
+			const TQStyleOption& = TQStyleOption::Default ) const;
+
+    // Old API
+    // DEPRECATED
     void drawControl( ControlElement element,
-		      TQPainter *p,
-		      const TQWidget *widget,
-		      const TQRect &r,
-		      const TQColorGroup &cg,
-		      SFlags how = Style_Default,
-		      const TQStyleOption& = TQStyleOption::Default ) const;
+			TQPainter *p,
+			const TQWidget *widget,
+			const TQRect &r,
+			const TQColorGroup &cg,
+			SFlags how = Style_Default,
+			const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    void drawControl( ControlElement element,
+			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
+			const TQRect &r,
+			const TQColorGroup &cg,
+			SFlags how = Style_Default,
+			const TQStyleOption& = TQStyleOption::Default,
+			const TQWidget *widget = 0 ) const;
+
+    // Old API
+    // DEPRECATED
     void drawControlMask( ControlElement element,
-			  TQPainter *p,
-			  const TQWidget *widget,
-			  const TQRect &r,
-			  const TQStyleOption& = TQStyleOption::Default ) const;
+			TQPainter *p,
+			const TQWidget *widget,
+			const TQRect &r,
+			const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    void drawControlMask( ControlElement element,
+			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
+			const TQRect &r,
+			const TQStyleOption& = TQStyleOption::Default,
+			const TQWidget *widget = 0 ) const;
+
+    // Old API
+    // DEPRECATED
     TQRect subRect( SubRect r, const TQWidget *widget ) const;
 
+    // New API
+    TQRect subRect( SubRect r, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags, const TQWidget *widget ) const;
+
+    // Old API
+    // DEPRECATED
     void drawComplexControl( ComplexControl control,
 			     TQPainter *p,
 			     const TQWidget *widget,
@@ -92,35 +135,111 @@ public:
 			     SCFlags subActive = SC_None,
 			     const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    void drawComplexControl( ComplexControl control,
+			     TQPainter *p,
+			     TQStyleControlElementData ceData,
+			     ControlElementFlags elementFlags,
+			     const TQRect &r,
+			     const TQColorGroup &cg,
+			     SFlags how = Style_Default,
+#ifdef Q_QDOC
+			     SCFlags sub = SC_All,
+#else
+			     SCFlags sub = (uint)SC_All,
+#endif
+			     SCFlags subActive = SC_None,
+			     const TQStyleOption& = TQStyleOption::Default,
+			     const TQWidget *widget = 0 ) const;
+
+    // Old API
+    // DEPRECATED
     void drawComplexControlMask( ComplexControl control,
 				 TQPainter *p,
 				 const TQWidget *widget,
 				 const TQRect &r,
 				 const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    void drawComplexControlMask( ComplexControl control,
+				 TQPainter *p,
+				 const TQStyleControlElementData ceData,
+				 const ControlElementFlags elementFlags,
+				 const TQRect &r,
+				 const TQStyleOption& = TQStyleOption::Default,
+				 const TQWidget *widget = 0 ) const;
+
+    // Old API
+    // DEPRECATED
     TQRect querySubControlMetrics( ComplexControl control,
 				  const TQWidget *widget,
 				  SubControl sc,
 				  const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    TQRect querySubControlMetrics( ComplexControl control,
+				  TQStyleControlElementData ceData,
+				  ControlElementFlags elementFlags,
+				  SubControl sc,
+				  const TQStyleOption& = TQStyleOption::Default,
+				  const TQWidget *widget = 0 ) const;
+
+    // Old API
+    // DEPRECATED
     SubControl querySubControl( ComplexControl control,
 				const TQWidget *widget,
 				const TQPoint &pos,
 				const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    SubControl querySubControl( ComplexControl control,
+				TQStyleControlElementData ceData,
+				ControlElementFlags elementFlags,
+				const TQPoint &pos,
+				const TQStyleOption& = TQStyleOption::Default,
+				const TQWidget *widget = 0 ) const;
+
+    // Old API
+    // DEPRECATED
     int pixelMetric( PixelMetric m, const TQWidget *widget = 0 ) const;
 
+    // New API
+    int pixelMetric( PixelMetric m, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0 ) const;
+
+    // Old API
+    // DEPRECATED
     TQSize sizeFromContents( ContentsType s,
 			    const TQWidget *widget,
 			    const TQSize &contentsSize,
 			    const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    TQSize sizeFromContents( ContentsType s,
+			    TQStyleControlElementData ceData,
+			    ControlElementFlags elementFlags,
+			    const TQSize &contentsSize,
+			    const TQStyleOption& = TQStyleOption::Default,
+			    const TQWidget *widget = 0 ) const;
+
+    // Old API
+    // DEPRECATED
     int styleHint(StyleHint sh, const TQWidget *, const TQStyleOption &, TQStyleHintReturn *) const;
 
+    // New API
+    int styleHint(StyleHint sh, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQStyleOption &, TQStyleHintReturn *, const TQWidget * w) const;
+
+    // Old API
+    // DEPRECATED
     TQPixmap stylePixmap( StylePixmap sp,
 			 const TQWidget *widget = 0,
 			 const TQStyleOption& = TQStyleOption::Default ) const;
 
+    // New API
+    TQPixmap stylePixmap( StylePixmap sp,
+			 TQStyleControlElementData ceData,
+			 ControlElementFlags elementFlags,
+			 const TQStyleOption& = TQStyleOption::Default,
+			 const TQWidget *widget = 0 ) const;
 
 private:
     // Disabled copy constructor and operator=
@@ -130,8 +249,6 @@ private:
 #endif
 };
 
-
-
 #endif // QT_NO_STYLE
 
 #endif // TQCOMMONSTYLE_H
diff --git a/src/styles/ntqcompactstyle.h b/src/styles/ntqcompactstyle.h
index 2ce20581..a9d34372 100644
--- a/src/styles/ntqcompactstyle.h
+++ b/src/styles/ntqcompactstyle.h
@@ -58,10 +58,10 @@ class Q_EXPORT_STYLE_COMPACT TQCompactStyle : public TQWindowsStyle
 public:
     TQCompactStyle();
 
-    int pixelMetric( PixelMetric metric, const TQWidget *widget = 0 );
+    int pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0 );
 
-    void drawControl( ControlElement element, TQPainter *p, const TQWidget *w, const TQRect &r,
-		      const TQColorGroup &cg, SFlags how = Style_Default, const TQStyleOption& = TQStyleOption::Default );
+    void drawControl( ControlElement element, TQPainter *p, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQRect &r,
+		      const TQColorGroup &cg, SFlags how = Style_Default, const TQStyleOption& = TQStyleOption::Default, const TQWidget *w = 0 );
 
 private:	// Disabled copy constructor and operator=
 #if defined(TQ_DISABLE_COPY)
diff --git a/src/styles/ntqmotifplusstyle.h b/src/styles/ntqmotifplusstyle.h
index 2766320a..8027b933 100644
--- a/src/styles/ntqmotifplusstyle.h
+++ b/src/styles/ntqmotifplusstyle.h
@@ -63,14 +63,16 @@ public:
     virtual ~TQMotifPlusStyle();
 
     void polish(TQPalette &pal);
-    void polish(TQWidget *widget);
-    void unPolish(TQWidget*widget);
+    void polish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *);
+    void unPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *);
 
-    void polish(TQApplication *app);
-    void unPolish(TQApplication *app);
+    void applicationPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *);
+    void applicationUnPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *);
 
     void drawPrimitive( PrimitiveElement pe,
 			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
 			const TQRect &r,
 			const TQColorGroup &cg,
 			SFlags flags = Style_Default,
@@ -78,17 +80,20 @@ public:
 
     void drawControl( ControlElement element,
 		      TQPainter *p,
-		      const TQWidget *widget,
+		      TQStyleControlElementData ceData,
+		      ControlElementFlags elementFlags,
 		      const TQRect &r,
 		      const TQColorGroup &cg,
 		      SFlags how = Style_Default,
-		      const TQStyleOption& = TQStyleOption::Default ) const;
+		      const TQStyleOption& = TQStyleOption::Default,
+		      const TQWidget *widget = 0 ) const;
 
-    TQRect subRect(SubRect r, const TQWidget *widget) const;
+    TQRect subRect(SubRect r, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget) const;
 
     void drawComplexControl(ComplexControl control,
 			    TQPainter *p,
-			    const TQWidget *widget,
+			    TQStyleControlElementData ceData,
+			    ControlElementFlags elementFlags,
 			    const TQRect &r,
 			    const TQColorGroup &cg,
 			    SFlags how = Style_Default,
@@ -98,20 +103,22 @@ public:
 			    SCFlags controls = (uint)SC_All,
 #endif
 			    SCFlags active = SC_None,
-			    const TQStyleOption& = TQStyleOption::Default ) const;
+			    const TQStyleOption& = TQStyleOption::Default,
+			    const TQWidget *widget = 0 ) const;
 
     TQRect querySubControlMetrics(ComplexControl control,
-				 const TQWidget *widget,
+				 TQStyleControlElementData ceData,
+				 ControlElementFlags elementFlags,
 				 SubControl subcontrol,
-				 const TQStyleOption& = TQStyleOption::Default) const;
+				 const TQStyleOption& = TQStyleOption::Default,
+				 const TQWidget *widget = 0) const;
 
-    int pixelMetric(PixelMetric metric, const TQWidget *widget = 0) const;
+    int pixelMetric(PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0) const;
 
-    int styleHint(StyleHint sh, const TQWidget *, const TQStyleOption & = TQStyleOption::Default,
-		  TQStyleHintReturn* = 0) const;
+    int styleHint(StyleHint sh, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQStyleOption & = TQStyleOption::Default,
+		  TQStyleHintReturn* = 0, const TQWidget * = 0) const;
 
-protected:
-    bool eventFilter(TQObject *, TQEvent *);
+    bool objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e );
 
 
 private:
diff --git a/src/styles/ntqmotifstyle.h b/src/styles/ntqmotifstyle.h
index fbfbf250..9b9d3650 100644
--- a/src/styles/ntqmotifstyle.h
+++ b/src/styles/ntqmotifstyle.h
@@ -67,14 +67,16 @@ public:
     bool useHighlightColors() const;
 
     void polish( TQPalette& );
-    void polish( TQWidget* );
-    void polish( TQApplication* );
+    void polish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
+    void applicationPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
 
     void polishPopupMenu( TQPopupMenu* );
 
     // new style API
     void drawPrimitive( PrimitiveElement pe,
 			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
 			const TQRect &r,
 			const TQColorGroup &cg,
 			SFlags flags = Style_Default,
@@ -82,15 +84,18 @@ public:
 
     void drawControl( ControlElement element,
 		      TQPainter *p,
-		      const TQWidget *widget,
+		      TQStyleControlElementData ceData,
+		      ControlElementFlags elementFlags,
 		      const TQRect &r,
 		      const TQColorGroup &cg,
 		      SFlags how = Style_Default,
-		      const TQStyleOption& = TQStyleOption::Default ) const;
+		      const TQStyleOption& = TQStyleOption::Default,
+		      const TQWidget *widget = 0 ) const;
 
     void drawComplexControl( ComplexControl control,
 			     TQPainter *p,
-			     const TQWidget* widget,
+			     TQStyleControlElementData ceData,
+			     ControlElementFlags elementFlags,
 			     const TQRect& r,
 			     const TQColorGroup& cg,
 			     SFlags how = Style_Default,
@@ -100,26 +105,31 @@ public:
 			     SCFlags sub = (uint)SC_All,
 #endif
 			     SCFlags subActive = SC_None,
-			     const TQStyleOption& = TQStyleOption::Default ) const;
+			     const TQStyleOption& = TQStyleOption::Default,
+			     const TQWidget* widget = 0 ) const;
 
     TQRect querySubControlMetrics( ComplexControl control,
-				  const TQWidget *widget,
+				  TQStyleControlElementData ceData,
+				  ControlElementFlags elementFlags,
 				  SubControl sc,
-				  const TQStyleOption& = TQStyleOption::Default ) const;
+				  const TQStyleOption& = TQStyleOption::Default,
+				  const TQWidget *widget = 0 ) const;
 
-    int pixelMetric( PixelMetric metric, const TQWidget *widget = 0 ) const;
+    int pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0 ) const;
 
     TQSize sizeFromContents( ContentsType contents,
-			    const TQWidget *widget,
+			    TQStyleControlElementData ceData,
+			    ControlElementFlags elementFlags,
 			    const TQSize &contentsSize,
-			    const TQStyleOption& = TQStyleOption::Default ) const;
+			    const TQStyleOption& = TQStyleOption::Default,
+			    const TQWidget *widget = 0 ) const;
 
-    TQRect subRect( SubRect r, const TQWidget *widget ) const;
+    TQRect subRect( SubRect r, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const;
 
-    TQPixmap stylePixmap(StylePixmap, const TQWidget * = 0, const TQStyleOption& = TQStyleOption::Default) const;
+    TQPixmap stylePixmap(StylePixmap, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQStyleOption& = TQStyleOption::Default, const TQWidget * = 0) const;
 
-    int styleHint(StyleHint sh, const TQWidget *, const TQStyleOption & = TQStyleOption::Default,
-		  TQStyleHintReturn* = 0) const;
+    int styleHint(StyleHint sh, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQStyleOption & = TQStyleOption::Default,
+		  TQStyleHintReturn* = 0, const TQWidget * = 0) const;
 
 private:
     bool highlightCols;
diff --git a/src/styles/ntqplatinumstyle.h b/src/styles/ntqplatinumstyle.h
index 3b4657e3..f0b0ec7e 100644
--- a/src/styles/ntqplatinumstyle.h
+++ b/src/styles/ntqplatinumstyle.h
@@ -65,6 +65,8 @@ public:
     // new Style Stuff
     void drawPrimitive( PrimitiveElement pe,
 			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
 			const TQRect &r,
 			const TQColorGroup &cg,
 			SFlags flags = Style_Default,
@@ -72,15 +74,18 @@ public:
 
     void drawControl( ControlElement element,
 		      TQPainter *p,
-		      const TQWidget *widget,
+		      TQStyleControlElementData ceData,
+		      ControlElementFlags elementFlags,
 		      const TQRect &r,
 		      const TQColorGroup &cg,
 		      SFlags how = Style_Default,
-		      const TQStyleOption& = TQStyleOption::Default ) const;
+		      const TQStyleOption& = TQStyleOption::Default,
+		      const TQWidget *widget = 0 ) const;
 
     void drawComplexControl( ComplexControl control,
 			     TQPainter *p,
-			     const TQWidget *widget,
+			     TQStyleControlElementData ceData,
+			     ControlElementFlags elementFlags,
 			     const TQRect &r,
 			     const TQColorGroup &cg,
 			     SFlags how = Style_Default,
@@ -90,16 +95,19 @@ public:
 			     SCFlags sub = (uint)SC_All,
 #endif
 			     SCFlags subActive = SC_None,
-			     const TQStyleOption& = TQStyleOption::Default ) const;
+			     const TQStyleOption& = TQStyleOption::Default,
+			     const TQWidget *widget = 0 ) const;
 
     TQRect querySubControlMetrics( ComplexControl control,
-				  const TQWidget *widget,
+				  TQStyleControlElementData ceData,
+				  ControlElementFlags elementFlags,
 				  SubControl sc,
-				  const TQStyleOption& = TQStyleOption::Default ) const;
+				  const TQStyleOption& = TQStyleOption::Default,
+				  const TQWidget *widget = 0 ) const;
 
-    int pixelMetric( PixelMetric metric, const TQWidget *widget = 0 ) const;
+    int pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0 ) const;
 
-    TQRect subRect( SubRect r, const TQWidget *widget ) const;
+    TQRect subRect( SubRect r, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const;
 
 protected:
      TQColor mixedColor(const TQColor &, const TQColor &) const;
diff --git a/src/styles/ntqsgistyle.h b/src/styles/ntqsgistyle.h
index b724a5b8..73be2ae8 100644
--- a/src/styles/ntqsgistyle.h
+++ b/src/styles/ntqsgistyle.h
@@ -67,13 +67,15 @@ public:
 #if !defined(Q_NO_USING_KEYWORD)
     using TQMotifStyle::polish;
 #endif
-    void polish( TQWidget* );
-    void unPolish( TQWidget* );
-    void polish( TQApplication* );
-    void unPolish( TQApplication* );
+    void polish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
+    void unPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
+    void applicationPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
+    void applicationUnPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void * );
 
     void drawPrimitive( PrimitiveElement pe,
 			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
 			const TQRect &r,
 			const TQColorGroup &cg,
 			SFlags flags = Style_Default,
@@ -81,15 +83,18 @@ public:
 
     void drawControl( ControlElement element,
 		      TQPainter *p,
-		      const TQWidget *widget,
+		      TQStyleControlElementData ceData,
+		      ControlElementFlags elementFlags,
 		      const TQRect &r,
 		      const TQColorGroup &cg,
 		      SFlags how = Style_Default,
-		      const TQStyleOption& = TQStyleOption::Default ) const;
+		      const TQStyleOption& = TQStyleOption::Default,
+		      const TQWidget *widget = 0 ) const;
 
     void drawComplexControl( ComplexControl control,
 			     TQPainter *p,
-			     const TQWidget* widget,
+			     TQStyleControlElementData ceData,
+			     ControlElementFlags elementFlags,
 			     const TQRect& r,
 			     const TQColorGroup& cg,
 			     SFlags how = Style_Default,
@@ -99,23 +104,27 @@ public:
 			     SCFlags sub = (uint)SC_All,
 #endif
 			     SCFlags subActive = SC_None,
-			     const TQStyleOption& = TQStyleOption::Default ) const;
+			     const TQStyleOption& = TQStyleOption::Default,
+			     const TQWidget* widget = 0 ) const;
 
-    int pixelMetric( PixelMetric metric, const TQWidget *widget = 0 ) const;
+    int pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget = 0 ) const;
 
     TQSize sizeFromContents( ContentsType contents,
-			    const TQWidget *widget,
+			    TQStyleControlElementData ceData,
+			    ControlElementFlags elementFlags,
 			    const TQSize &contentsSize,
-			    const TQStyleOption& = TQStyleOption::Default ) const;
+			    const TQStyleOption& = TQStyleOption::Default,
+			    const TQWidget *widget = 0 ) const;
 
-    TQRect subRect( SubRect r, const TQWidget *widget ) const;
+    TQRect subRect( SubRect r, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const;
     TQRect querySubControlMetrics( ComplexControl control,
-				  const TQWidget *widget,
+				  TQStyleControlElementData ceData,
+				  ControlElementFlags elementFlags,
 				  SubControl sc,
-				  const TQStyleOption& = TQStyleOption::Default ) const;
+				  const TQStyleOption& = TQStyleOption::Default,
+				  const TQWidget *widget = 0 ) const;
 
-protected:
-    bool eventFilter( TQObject*, TQEvent*);
+    bool objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e );
 
 private:
     TQSGIStylePrivate *d;
diff --git a/src/styles/ntqwindowsstyle.h b/src/styles/ntqwindowsstyle.h
index 5f7d4d7a..d626c3e3 100644
--- a/src/styles/ntqwindowsstyle.h
+++ b/src/styles/ntqwindowsstyle.h
@@ -61,11 +61,11 @@ public:
     TQWindowsStyle();
     ~TQWindowsStyle();
 
-    void polish(TQApplication*);
-    void unPolish(TQApplication*);
+    void applicationPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *);
+    void applicationUnPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *);
 
-    void polish(TQWidget*);
-    void unPolish(TQWidget*);
+    void polish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *);
+    void unPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *);
 
     void polish( TQPalette & );
 
@@ -74,6 +74,8 @@ public:
     // new stuff
     void drawPrimitive( PrimitiveElement pe,
 			TQPainter *p,
+			TQStyleControlElementData ceData,
+			ControlElementFlags elementFlags,
 			const TQRect &r,
 			const TQColorGroup &cg,
 			SFlags flags = Style_Default,
@@ -81,15 +83,18 @@ public:
 
     void drawControl( ControlElement element,
 		      TQPainter *p,
-		      const TQWidget *widget,
+		      TQStyleControlElementData ceData,
+		      ControlElementFlags elementFlags,
 		      const TQRect &r,
 		      const TQColorGroup &cg,
 		      SFlags flags = Style_Default,
-		      const TQStyleOption& = TQStyleOption::Default ) const;
+		      const TQStyleOption& = TQStyleOption::Default,
+		      const TQWidget *widget = 0 ) const;
 
     void drawComplexControl( ComplexControl control,
 			     TQPainter* p,
-			     const TQWidget* widget,
+			     TQStyleControlElementData ceData,
+			     ControlElementFlags elementFlags,
 			     const TQRect& r,
 			     const TQColorGroup& cg,
 			     SFlags flags = Style_Default,
@@ -99,25 +104,33 @@ public:
 			     SCFlags sub = (uint)SC_All,
 #endif
 			     SCFlags subActive = SC_None,
-			     const TQStyleOption& = TQStyleOption::Default ) const;
+			     const TQStyleOption& = TQStyleOption::Default,
+			     const TQWidget* widget = 0 ) const;
 
     int pixelMetric( PixelMetric metric,
+		     TQStyleControlElementData ceData,
+		     ControlElementFlags elementFlags,
 		     const TQWidget *widget = 0 ) const;
 
     TQSize sizeFromContents( ContentsType contents,
-			    const TQWidget *widget,
+			    TQStyleControlElementData ceData,
+			    ControlElementFlags elementFlags,
 			    const TQSize &contentsSize,
-			    const TQStyleOption& = TQStyleOption::Default ) const;
+			    const TQStyleOption& = TQStyleOption::Default,
+			    const TQWidget *widget = 0 ) const;
 
-    int styleHint(StyleHint sh, const TQWidget *, const TQStyleOption & = TQStyleOption::Default,
-		  TQStyleHintReturn* = 0) const;
+    int styleHint(StyleHint sh, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQStyleOption & = TQStyleOption::Default,
+		  TQStyleHintReturn* = 0, const TQWidget* = 0) const;
 
     TQPixmap stylePixmap( StylePixmap stylepixmap,
-			 const TQWidget *widget = 0,
-			 const TQStyleOption& = TQStyleOption::Default ) const;
+			 TQStyleControlElementData ceData,
+			 ControlElementFlags elementFlags,
+			 const TQStyleOption& = TQStyleOption::Default,
+			 const TQWidget *widget = 0 ) const;
 
-    TQRect subRect( SubRect r, const TQWidget *widget ) const;
+    TQRect subRect( SubRect r, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags, const TQWidget *widget ) const;
 
+    bool objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e );
 
 private:
     class Private;
diff --git a/src/styles/qcdestyle.cpp b/src/styles/qcdestyle.cpp
index 7a4f2693..1b01c81d 100644
--- a/src/styles/qcdestyle.cpp
+++ b/src/styles/qcdestyle.cpp
@@ -87,7 +87,7 @@ TQCDEStyle::~TQCDEStyle()
 
 /*!\reimp
 */
-int TQCDEStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) const
+int TQCDEStyle::pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const
 {
     int ret;
 
@@ -102,7 +102,7 @@ int TQCDEStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) const
 	ret = 13;
 	break;
     default:
-	ret = TQMotifStyle::pixelMetric( metric, widget );
+	ret = TQMotifStyle::pixelMetric( metric, ceData, elementFlags, widget );
 	break;
     }
     return ret;
@@ -112,11 +112,13 @@ int TQCDEStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) const
 */
 void TQCDEStyle::drawControl( ControlElement element,
 			     TQPainter *p,
-			     const TQWidget *widget,
+			     TQStyleControlElementData ceData,
+			     ControlElementFlags elementFlags,
 			     const TQRect &r,
 			     const TQColorGroup &cg,
 			     SFlags how,
-			     const TQStyleOption& opt ) const
+			     const TQStyleOption& opt,
+			     const TQWidget *widget ) const
 {
 
     switch( element ) {
@@ -127,11 +129,11 @@ void TQCDEStyle::drawControl( ControlElement element,
 				 &cg.brush( TQColorGroup::Button ) );
 	    else  // other item
 		p->fillRect( r, cg.brush( TQColorGroup::Button ) );
-	    TQCommonStyle::drawControl( element, p, widget, r, cg, how, opt );
+	    TQCommonStyle::drawControl( element, p, ceData, elementFlags, r, cg, how, opt, widget );
 	    break;
 	}
     default:
-	TQMotifStyle::drawControl( element, p, widget, r, cg, how, opt );
+	TQMotifStyle::drawControl( element, p, ceData, elementFlags, r, cg, how, opt, widget );
     break;
     }
 
@@ -142,6 +144,8 @@ void TQCDEStyle::drawControl( ControlElement element,
 */
 void TQCDEStyle::drawPrimitive( PrimitiveElement pe,
 			       TQPainter *p,
+			       TQStyleControlElementData ceData,
+			       ControlElementFlags elementFlags,
 			       const TQRect &r,
 			       const TQColorGroup &cg,
 			       SFlags flags,
@@ -154,7 +158,7 @@ void TQCDEStyle::drawPrimitive( PrimitiveElement pe,
 	bool on = flags & Style_On;
 	bool showUp = !( down ^ on );
 	TQBrush fill = showUp || flags & Style_NoChange ? cg.brush( TQColorGroup::Button ) : cg.brush( TQColorGroup::Mid );
-	qDrawShadePanel( p, r, cg, !showUp, pixelMetric( PM_DefaultFrameWidth ), &cg.brush( TQColorGroup::Button ) );
+	qDrawShadePanel( p, r, cg, !showUp, pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags ), &cg.brush( TQColorGroup::Button ) );
 
 	if ( !( flags & Style_Off ) ) {
 	    TQPointArray a( 7 * 2 );
@@ -360,7 +364,7 @@ void TQCDEStyle::drawPrimitive( PrimitiveElement pe,
     }
 	break;
     default:
-	TQMotifStyle::drawPrimitive( pe, p, r, cg, flags, opt );
+	TQMotifStyle::drawPrimitive( pe, p, ceData, elementFlags, r, cg, flags, opt );
     }
 }
 
diff --git a/src/styles/qcommonstyle.cpp b/src/styles/qcommonstyle.cpp
index 4b51be9f..20c6c999 100644
--- a/src/styles/qcommonstyle.cpp
+++ b/src/styles/qcommonstyle.cpp
@@ -49,9 +49,11 @@
 #include "ntqpixmap.h"
 #include "ntqpushbutton.h"
 #include "ntqtabbar.h"
+#include "ntqlineedit.h"
 #include "ntqscrollbar.h"
 #include "ntqtoolbutton.h"
 #include "ntqtoolbar.h"
+#include "ntqcombobox.h"
 #include "ntqdockarea.h"
 #include "ntqheader.h"
 #include "ntqspinbox.h"
@@ -135,6 +137,405 @@ static const char * const check_list_controller_xpm[] = {
 "                ",
 "                "};
 
+#include <ntqmetaobject.h>
+
+TQStringList getObjectTypeListForObject(const TQObject* object) {
+	TQStringList objectTypes;
+
+	if (object) {
+		TQMetaObject* objectMetaObject = object->metaObject();
+		const char* name;
+	
+		while (objectMetaObject) {
+			name = objectMetaObject->className();
+			objectTypes.append(TQString(name));
+			objectMetaObject = objectMetaObject->superClass();
+		}
+	}
+
+	return objectTypes;
+}
+
+TQStyle::ControlElementFlags getControlElementFlagsForObject(const TQObject* object, TQStringList objectTypeList, const TQStyleOption& opt, bool populateReliantFields) {
+	TQStyle::ControlElementFlags cef = (TQStyle::ControlElementFlags)0;
+
+	if (object) {
+		if (objectTypeList.contains("TQPushButton")) {
+			const TQPushButton *button = dynamic_cast<const TQPushButton*>(object);
+			if (button) {
+				if (button->isDefault())			cef = cef | TQStyle::CEF_IsDefault;
+				if (button->autoDefault())			cef = cef | TQStyle::CEF_AutoDefault;
+				if (button->isMenuButton())			cef = cef | TQStyle::CEF_IsMenuWidget;
+				if (button->isToggleButton())			cef = cef | TQStyle::CEF_BiState;
+				if (button->isFlat())				cef = cef | TQStyle::CEF_IsFlat;
+			}
+		}
+		if (objectTypeList.contains("TQToolButton")) {
+			const TQToolButton *button = dynamic_cast<const TQToolButton*>(object);
+			if (button) {
+				if (button->isToggleButton())			cef = cef | TQStyle::CEF_BiState;
+				if (button->usesTextLabel())			cef = cef | TQStyle::CEF_UsesTextLabel;
+				if (button->usesBigPixmap())			cef = cef | TQStyle::CEF_UsesBigPixmap;
+				if (button->popup())				cef = cef | TQStyle::CEF_HasPopupMenu;
+			}
+		}
+		if (objectTypeList.contains("TQButton")) {
+			const TQButton *button = dynamic_cast<const TQButton*>(object);
+			if (button) {
+				if (button->isDown())				cef = cef | TQStyle::CEF_IsDown;
+				if (button->isOn())				cef = cef | TQStyle::CEF_IsOn;
+				if (button->isEnabled())			cef = cef | TQStyle::CEF_IsEnabled;
+				if (button->isToggleButton())			cef = cef | TQStyle::CEF_BiState;
+			}
+		}
+		if (objectTypeList.contains("TQTabBar")) {
+			const TQTabBar *tb = dynamic_cast<const TQTabBar*>(object);
+			TQTab * t = opt.tab();
+			if ((t) && (tb)) {
+				if (t->identifier() == tb->currentTab())	cef = cef | TQStyle::CEF_IsActive;
+			}
+		}
+		if (objectTypeList.contains("TQToolBox")) {
+			const TQToolBox *tb = dynamic_cast<const TQToolBox*>(object);
+			if (tb) {
+				if (!tb->currentItem())				cef = cef | TQStyle::CEF_IsContainerEmpty;
+			}
+		}
+		if (objectTypeList.contains("TQProgressBar")) {
+			const TQProgressBar *pb = dynamic_cast<const TQProgressBar*>(object);
+			if (pb) {
+				if (pb->centerIndicator())			cef = cef | TQStyle::CEF_CenterIndicator;
+				if (pb->indicatorFollowsStyle())		cef = cef | TQStyle::CEF_IndicatorFollowsStyle;
+			}
+		}
+		if (objectTypeList.contains("TQPopupMenu")) {
+			const TQPopupMenu *pm = dynamic_cast<const TQPopupMenu*>(object);
+			if (pm) {
+				if (pm->isCheckable())				cef = cef | TQStyle::CEF_IsCheckable;
+			}
+		}
+		if (objectTypeList.contains("TQComboBox")) {
+			const TQComboBox *cb = dynamic_cast<const TQComboBox*>(object);
+			if (cb) {
+				if (cb->editable())				cef = cef | TQStyle::CEF_IsEditable;
+			}
+		}
+		// Generic flags
+		const TQWidget* widget = dynamic_cast<const TQWidget*>(object);
+		if (widget) {
+			if (widget->parentWidget())				cef = cef | TQStyle::CEF_HasParentWidget;
+			if (widget->focusProxy())				cef = cef | TQStyle::CEF_HasFocusProxy;
+			if (widget->hasFocus())					cef = cef | TQStyle::CEF_HasFocus;
+			if (populateReliantFields) {
+				if (widget->isActiveWindow())			cef = cef | TQStyle::CEF_IsActiveWindow;
+				if (widget->isTopLevel())			cef = cef | TQStyle::CEF_IsTopLevel;
+				if (widget->isVisible())			cef = cef | TQStyle::CEF_IsVisible;
+			}
+		}
+	}
+	else {
+		cef = cef | TQStyle::CEF_UseGenericParameters;
+	}
+
+	return cef;
+}
+
+TQStyleControlElementData populateControlElementDataFromWidget(const TQWidget* widget, const TQStyleOption& opt, bool populateReliantFields) {
+	TQStyleControlElementData ceData;
+
+	if (widget) {
+		ceData.widgetObjectTypes = getObjectTypeListForObject(widget);
+		ceData.allDataPopulated = populateReliantFields;
+		const TQPixmap* erasePixmap = widget->backgroundPixmap();
+		if (erasePixmap) {
+			ceData.bgPixmap = *erasePixmap;
+		}
+		if (populateReliantFields) {
+			ceData.bgBrush = widget->backgroundBrush();
+		}
+		ceData.wflags = widget->getWFlags();
+		ceData.bgColor = widget->eraseColor();
+		ceData.bgOffset = widget->backgroundOffset();
+		ceData.backgroundMode = widget->backgroundMode();
+		if (populateReliantFields) {
+			ceData.fgColor = widget->foregroundColor();
+			ceData.colorGroup = widget->colorGroup();
+		}
+		ceData.geometry = widget->geometry();
+		ceData.rect = widget->rect();
+		ceData.pos = widget->pos();
+		const TQPixmap* icon = widget->icon();
+		if (icon) {
+			ceData.icon = *icon;
+		}
+		ceData.palette = widget->palette();
+		ceData.font = widget->font();
+		if (ceData.widgetObjectTypes.contains("TQPushButton")) {
+			const TQPushButton *button = dynamic_cast<const TQPushButton*>(widget);
+			if (button) {
+				TQIconSet* iconSet = 0;
+				const TQPixmap* fgPixmap = 0;
+				iconSet = button->iconSet();
+				fgPixmap = button->pixmap();
+				if (iconSet) {
+					ceData.iconSet = *iconSet;
+				}
+				if (fgPixmap) {
+					ceData.fgPixmap = *fgPixmap;
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQToolButton")) {
+			const TQToolButton *button = dynamic_cast<const TQToolButton*>(widget);
+			if (button) {
+				const TQPixmap* fgPixmap = 0;
+				ceData.iconSet = button->iconSet();
+				fgPixmap = button->pixmap();
+				if (fgPixmap) {
+					ceData.fgPixmap = *fgPixmap;
+				}
+				ceData.textLabel = button->textLabel();
+				ceData.toolButtonTextPosition = button->textPosition();
+				ceData.popupDelay = button->popupDelay();
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQCheckBox")) {
+			const TQCheckBox *button = dynamic_cast<const TQCheckBox*>(widget);
+			if (button) {
+				const TQPixmap* fgPixmap = 0;
+				fgPixmap = button->pixmap();
+				if (fgPixmap) {
+					ceData.fgPixmap = *fgPixmap;
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQRadioButton")) {
+			const TQRadioButton *button = dynamic_cast<const TQRadioButton*>(widget);
+			if (button) {
+				const TQPixmap* fgPixmap = 0;
+				fgPixmap = button->pixmap();
+				if (fgPixmap) {
+					ceData.fgPixmap = *fgPixmap;
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQButton")) {
+			const TQButton *button = dynamic_cast<const TQButton*>(widget);
+			if (button) {
+				ceData.text = button->text();
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQTabBar")) {
+			const TQTabBar *tb = dynamic_cast<const TQTabBar*>(widget);
+			if (tb) {
+				ceData.tabBarData.tabCount = tb->count();
+				ceData.tabBarData.shape = tb->shape();
+				ceData.tabBarData.identIndexMap.clear();
+				const TQTab* currentTab;
+				for (int i=0; i<tb->count(); ++i) {
+					currentTab = tb->tabAt(i);
+					if (currentTab) {
+						ceData.tabBarData.identIndexMap[currentTab->identifier()] = tb->indexOf(currentTab->identifier());
+					}
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQToolBox")) {
+			const TQToolBox *tb = dynamic_cast<const TQToolBox*>(widget);
+			if (tb) {
+				const TQWidget* currentItem = tb->currentItem();
+				if (currentItem) {
+					ceData.activeItemPaletteBgColor = currentItem->paletteBackgroundColor();
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQProgressBar")) {
+			const TQProgressBar *pb = dynamic_cast<const TQProgressBar*>(widget);
+			if (pb) {
+				ceData.currentStep = pb->progress();
+				ceData.totalSteps = pb->totalSteps();
+				ceData.progressText = pb->progressString();
+				ceData.percentageVisible = pb->percentageVisible();
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQHeader")) {
+			const TQHeader *header = dynamic_cast<const TQHeader*>(widget);
+			if (header) {
+				int section = opt.headerSection();
+				TQIconSet* iconSet = 0;
+				iconSet = header->iconSet(section);
+				ceData.textLabel = header->label(section);
+				if (iconSet) {
+					ceData.iconSet = *iconSet;
+				}
+			}
+		}
+		// Complex Controls
+		if (ceData.widgetObjectTypes.contains("TQScrollBar")) {
+			const TQScrollBar *sb = dynamic_cast<const TQScrollBar*>(widget);
+			if (sb) {
+				ceData.orientation = sb->orientation();
+				ceData.minSteps = sb->minValue();
+				ceData.maxSteps = sb->maxValue();
+				ceData.currentStep = sb->value();
+				ceData.startStep = sb->sliderStart();
+				ceData.lineStep = sb->lineStep();
+				ceData.pageStep = sb->pageStep();
+				if (populateReliantFields) {
+					ceData.sliderRect = sb->sliderRect();
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQSlider")) {
+			const TQSlider *sl = dynamic_cast<const TQSlider*>(widget);
+			if (sl) {
+				ceData.orientation = sl->orientation();
+				ceData.tickMarkSetting = sl->tickmarks();
+				ceData.tickInterval = sl->tickInterval();
+				ceData.currentStep = sl->value();
+				ceData.startStep = sl->sliderStart();
+				ceData.lineStep = sl->lineStep();
+				ceData.pageStep = sl->pageStep();
+				if (populateReliantFields) {
+					ceData.sliderRect = sl->sliderRect();
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQDialogButtons")) {
+			const TQDialogButtons *dlgbtns = dynamic_cast<const TQDialogButtons*>(widget);
+			if (dlgbtns) {
+				ceData.orientation = dlgbtns->orientation();
+				ceData.dlgVisibleButtons = dlgbtns->visibleButtons();
+				TQDialogButtons::Button btns[] = { TQDialogButtons::All, TQDialogButtons::Reject, TQDialogButtons::Accept, TQDialogButtons::Apply, TQDialogButtons::Retry, TQDialogButtons::Ignore, TQDialogButtons::Abort, TQDialogButtons::Help };
+				for(unsigned int i = 0; i < (sizeof(btns)/sizeof(btns[0])); i++) {
+					if (ceData.dlgVisibleButtons & btns[i]) {
+						ceData.dlgVisibleSizeHints[btns[i]] = dlgbtns->sizeHint(btns[i]);
+					}
+				}
+
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQTitleBar")) {
+			const TQTitleBar *tb = dynamic_cast<const TQTitleBar*>(widget);
+			if (tb) {
+				ceData.titleBarData.hasWindow = !!(tb->window());
+				if (ceData.titleBarData.hasWindow) {
+					ceData.titleBarData.windowState = tb->window()->windowState();
+				}
+				if (populateReliantFields) {
+					ceData.titleBarData.usesActiveColor = tb->usesActiveColor();
+				}
+				ceData.titleBarData.visibleText = tb->visibleText();
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQSpinWidget")) {
+			const TQSpinWidget *sw = dynamic_cast<const TQSpinWidget*>(widget);
+			if (sw) {
+				ceData.spinWidgetData.buttonSymbols = sw->buttonSymbols();
+				ceData.spinWidgetData.upRect = sw->upRect();
+				ceData.spinWidgetData.downRect = sw->downRect();
+				ceData.spinWidgetData.upEnabled = sw->isUpEnabled();
+				ceData.spinWidgetData.downEnabled = sw->isDownEnabled();
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQListView")) {
+			const TQListView *lv = dynamic_cast<const TQListView*>(widget);
+			if (lv) {
+				ceData.listViewData.rootDecorated = lv->rootIsDecorated();
+				ceData.listViewData.itemMargin = lv->itemMargin();
+				TQWidget* viewport = lv->viewport();
+				if (viewport) {
+					ceData.viewportData.widgetObjectTypes = getObjectTypeListForObject(viewport);
+					ceData.viewportData.allDataPopulated = populateReliantFields;
+					const TQPixmap* erasePixmap = viewport->backgroundPixmap();
+					if (erasePixmap) {
+						ceData.viewportData.bgPixmap = *erasePixmap;
+					}
+					if (populateReliantFields) {
+						ceData.viewportData.bgBrush = viewport->backgroundBrush();
+					}
+					ceData.viewportData.wflags = viewport->getWFlags();
+					ceData.viewportData.bgColor = viewport->eraseColor();
+					ceData.viewportData.bgOffset = viewport->backgroundOffset();
+					ceData.viewportData.backgroundMode = viewport->backgroundMode();
+					if (populateReliantFields) {
+						ceData.viewportData.fgColor = viewport->foregroundColor();
+						ceData.viewportData.colorGroup = viewport->colorGroup();
+					}
+					ceData.viewportData.geometry = viewport->geometry();
+					ceData.viewportData.rect = viewport->rect();
+					ceData.viewportData.pos = viewport->pos();
+					const TQPixmap* icon = viewport->icon();
+					if (icon) {
+						ceData.viewportData.icon = *icon;
+					}
+					ceData.viewportData.palette = viewport->palette();
+					ceData.viewportData.font = viewport->font();
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQComboBox")) {
+			const TQComboBox *cb = dynamic_cast<const TQComboBox*>(widget);
+			if (cb) {
+				const TQLineEdit* lineEdit = cb->lineEdit();
+				if (lineEdit) {
+					ceData.comboBoxLineEditFlags = getControlElementFlagsForObject(lineEdit, ceData.widgetObjectTypes, TQStyleOption::Default);
+				}
+			}
+		}
+		if (ceData.widgetObjectTypes.contains("TQFrame")) {
+			const TQFrame *frame = dynamic_cast<const TQFrame*>(widget);
+			if (frame) {
+				ceData.frameStyle = frame->frameStyle();
+			}
+		}
+
+		const TQWidget* parentWidget = widget->parentWidget();
+		if (parentWidget) {
+			ceData.parentWidgetData.widgetObjectTypes = getObjectTypeListForObject(parentWidget);
+			ceData.parentWidgetData.allDataPopulated = populateReliantFields;
+			const TQPixmap* erasePixmap = parentWidget->backgroundPixmap();
+			if (erasePixmap) {
+				ceData.parentWidgetData.bgPixmap = *erasePixmap;
+			}
+			if (populateReliantFields) {
+				ceData.parentWidgetData.bgBrush = parentWidget->backgroundBrush();
+			}
+			ceData.parentWidgetData.wflags = parentWidget->getWFlags();
+			ceData.parentWidgetData.bgColor = parentWidget->eraseColor();
+			ceData.parentWidgetData.bgOffset = parentWidget->backgroundOffset();
+			ceData.parentWidgetData.backgroundMode = parentWidget->backgroundMode();
+			if (populateReliantFields) {
+				ceData.parentWidgetData.fgColor = parentWidget->foregroundColor();
+				ceData.parentWidgetData.colorGroup = parentWidget->colorGroup();
+			}
+			ceData.parentWidgetData.geometry = parentWidget->geometry();
+			ceData.parentWidgetData.rect = parentWidget->rect();
+			ceData.parentWidgetData.pos = parentWidget->pos();
+			const TQPixmap* icon = parentWidget->icon();
+			if (icon) {
+				ceData.parentWidgetData.icon = *icon;
+			}
+			ceData.parentWidgetData.palette = parentWidget->palette();
+			ceData.parentWidgetData.font = parentWidget->font();
+
+			const TQDockWindow * dw = dynamic_cast<const TQDockWindow*>(parentWidget);
+			if (dw) {
+				if (dw->area()) {
+					ceData.dwData.hasDockArea = true;
+					ceData.dwData.areaOrientation = dw->area()->orientation();
+				}
+				else {
+					ceData.dwData.hasDockArea = false;
+				}
+				ceData.dwData.closeEnabled = dw->isCloseEnabled();
+			}
+		}
+	}
+
+	return ceData;
+}
+
 /*! \reimp */
 void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 				  TQPainter *p,
@@ -143,6 +544,32 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 				  SFlags flags,
 				  const TQStyleOption& opt ) const
 {
+	const TQWidget* widget = 0;
+
+	// Determine if the request needs widget information and set widget appropriately
+	// FIXME
+	if ((pe == PE_CheckListController) || (pe == PE_CheckListExclusiveIndicator) || (pe == PE_CheckListIndicator)) {
+		TQCheckListItem *item = opt.checkListItem();
+		if (item) {
+			TQListView *lv = item->listView();
+			widget = dynamic_cast<TQWidget*>(lv);
+		}
+	}
+
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
+	drawPrimitive(pe, p, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), r, cg, flags, opt);
+}
+
+/*! \reimp */
+void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
+				  TQPainter *p,
+				  TQStyleControlElementData ceData,
+				  ControlElementFlags elementFlags,
+				  const TQRect &r,
+				  const TQColorGroup &cg,
+				  SFlags flags,
+				  const TQStyleOption& opt ) const
+{
     activePainter = p;
 
     switch (pe) {
@@ -152,7 +579,6 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 	break; }
     case PE_CheckListExclusiveIndicator: {
 	TQCheckListItem *item = opt.checkListItem();
-	TQListView *lv = item->listView();
 	if(!item)
 	    return;
 	int x = r.x(), y = r.y();
@@ -174,7 +600,7 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 	if ( flags & Style_Enabled )
 	    p->setPen( cg.text() );
 	else
-	    p->setPen( TQPen( lv->palette().color( TQPalette::Disabled, TQColorGroup::Text ) ) );
+	    p->setPen( TQPen( ceData.palette.color( TQPalette::Disabled, TQColorGroup::Text ) ) );
 	TQPointArray a( TQCOORDARRLEN(pts1), pts1 );
 	a.translate( x, y );
 	//p->setPen( cg.dark() );
@@ -205,21 +631,20 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 	break; }
     case PE_CheckListIndicator: {
 	TQCheckListItem *item = opt.checkListItem();
-	TQListView *lv = item->listView();
 	if(!item)
 	    return;
-	int x = r.x(), y = r.y(), w = r.width(), h = r.width(), marg = lv->itemMargin();
+	int x = r.x(), y = r.y(), w = r.width(), h = r.width(), marg = ceData.listViewData.itemMargin;
 
 	if ( flags & Style_Enabled )
 	    p->setPen( TQPen( cg.text(), 2 ) );
 	else
-	    p->setPen( TQPen( lv->palette().color( TQPalette::Disabled, TQColorGroup::Text ),
+	    p->setPen( TQPen( ceData.palette.color( TQPalette::Disabled, TQColorGroup::Text ),
 			     2 ) );
 	bool parentControl = FALSE;
 	if ( item->parent() && item->parent()->rtti() == 1  &&
 	     ((TQCheckListItem*) item->parent())->type() == TQCheckListItem::Controller )
 	    parentControl = TRUE;
-	if ( flags & Style_Selected && !lv->rootIsDecorated() && !parentControl ) {
+	if ( flags & Style_Selected && !ceData.listViewData.rootDecorated && !parentControl ) {
 	    p->fillRect( 0, 0, x + marg + w + 4, item->height(),
 			 cg.brush( TQColorGroup::Highlight ) );
 	    if ( item->isEnabled() )
@@ -322,7 +747,7 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
     case PE_SpinWidgetPlus:
     case PE_SpinWidgetMinus: {
 	p->save();
-	int fw = pixelMetric( PM_DefaultFrameWidth, 0 );
+	int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, 0 );
 	TQRect br;
 	br.setRect( r.x() + fw, r.y() + fw, r.width() - fw*2,
 		    r.height() - fw*2 );
@@ -353,7 +778,7 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 
     case PE_SpinWidgetUp:
     case PE_SpinWidgetDown: {
-	int fw = pixelMetric( PM_DefaultFrameWidth, 0 );
+	int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, 0 );
 	TQRect br;
 	br.setRect( r.x() + fw, r.y() + fw, r.width() - fw*2,
 		    r.height() - fw*2 );
@@ -378,8 +803,8 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 	int bsx = 0;
 	int bsy = 0;
 	if ( flags & Style_Sunken ) {
-	    bsx = pixelMetric(PM_ButtonShiftHorizontal);
-	    bsy = pixelMetric(PM_ButtonShiftVertical);
+	    bsx = pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags);
+	    bsy = pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags);
 	}
 	p->save();
 	p->translate( sx + bsx, sy + bsy );
@@ -464,21 +889,21 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 
     case PE_Panel:
     case PE_PanelPopup: {
-	int lw = opt.isDefault() ? pixelMetric(PM_DefaultFrameWidth)
+	int lw = opt.isDefault() ? pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags)
 		    : opt.lineWidth();
 
 	qDrawShadePanel(p, r, cg, (flags & Style_Sunken), lw);
 	break; }
 
     case PE_PanelDockWindow: {
-	int lw = opt.isDefault() ? pixelMetric(PM_DockWindowFrameWidth)
+	int lw = opt.isDefault() ? pixelMetric(PM_DockWindowFrameWidth, ceData, elementFlags)
 		    : opt.lineWidth();
 
 	qDrawShadePanel(p, r, cg, FALSE, lw);
 	break; }
 
     case PE_PanelMenuBar: {
-	int lw = opt.isDefault() ? pixelMetric(PM_MenuBarFrameWidth)
+	int lw = opt.isDefault() ? pixelMetric(PM_MenuBarFrameWidth, ceData, elementFlags)
 		    : opt.lineWidth();
 
 	qDrawShadePanel(p, r, cg, FALSE, lw, &cg.brush(TQColorGroup::Button));
@@ -565,7 +990,7 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
 	break; }
 
     case PE_PanelGroupBox: //We really do not need PE_GroupBoxFrame anymore, nasty holdover ###
-	drawPrimitive( PE_GroupBoxFrame, p, r, cg, flags, opt );
+	drawPrimitive( PE_GroupBoxFrame, p, ceData, elementFlags, r, cg, flags, opt );
 	break;
     case PE_GroupBoxFrame: {
 #ifndef QT_NO_FRAME
@@ -587,11 +1012,11 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
     case PE_PanelLineEdit:
     case PE_PanelTabWidget:
     case PE_WindowFrame:
-	drawPrimitive( PE_Panel, p, r, cg, flags, opt );
+	drawPrimitive( PE_Panel, p, ceData, elementFlags, r, cg, flags, opt );
 	break;
 
     case PE_RubberBand:
-	drawPrimitive(PE_FocusRect, p, r, cg, flags, opt);
+	drawPrimitive(PE_FocusRect, p, ceData, elementFlags, r, cg, flags, opt);
 	break;
     default:
 	break;
@@ -600,6 +1025,25 @@ void TQCommonStyle::drawPrimitive( PrimitiveElement pe,
     activePainter = 0;
 }
 
+void qt_style_erase_region(TQPainter* p, const TQRegion& region, TQStyleControlElementData ceData) {
+	TQRegion reg = region;
+
+	TQPoint offset = ceData.bgOffset;
+	int ox = offset.x();
+	int oy = offset.y();
+
+	TQRegion origcr = p->clipRegion();
+	p->setClipRegion(region);
+	if (!ceData.bgPixmap.isNull()) {
+		p->drawTiledPixmap(0, 0, ceData.geometry.width(), ceData.geometry.height(), ceData.bgPixmap, ox, oy);
+	}
+	else {
+		p->fillRect(ceData.rect, ceData.bgColor);
+	}
+	p->setClipRegion(origcr);
+	return;
+}
+
 /*! \reimp */
 void TQCommonStyle::drawControl( ControlElement element,
 				TQPainter *p,
@@ -610,12 +1054,27 @@ void TQCommonStyle::drawControl( ControlElement element,
 				const TQStyleOption& opt ) const
 {
 #if defined(QT_CHECK_STATE)
-    if (! widget) {
-	tqWarning("TQCommonStyle::drawControl: widget parameter cannot be zero!");
-	return;
-    }
+	if (!widget) {
+		tqWarning("TQCommonStyle::drawControl: widget parameter cannot be zero!");
+		return;
+	}
 #endif
 
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, opt);
+	drawControl(element, p, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, opt), r, cg, flags, opt, widget);
+}
+
+/*! \reimp */
+void TQCommonStyle::drawControl( ControlElement element,
+				TQPainter *p,
+				TQStyleControlElementData ceData,
+				ControlElementFlags elementFlags,
+				const TQRect &r,
+				const TQColorGroup &cg,
+				SFlags flags,
+				const TQStyleOption& opt,
+				const TQWidget *widget ) const
+{
     activePainter = p;
 
     switch (element) {
@@ -625,18 +1084,18 @@ void TQCommonStyle::drawControl( ControlElement element,
 	    reg = p->clipRegion();
 	else
 	    reg = r;
-	((TQWidget *)widget)->erase( reg );
+	qt_style_erase_region(p, reg, ceData);
 	break; }
     case CE_PushButton:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
 	    TQRect br = r;
-	    int dbi = pixelMetric(PM_ButtonDefaultIndicator, widget);
+	    int dbi = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget);
 
-	    if (button->isDefault() || button->autoDefault()) {
-		if ( button->isDefault())
-		    drawPrimitive(PE_ButtonDefault, p, br, cg, flags);
+	    if ((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault)) {
+		if (elementFlags & CEF_IsDefault) {
+		    drawPrimitive(PE_ButtonDefault, p, ceData, elementFlags, br, cg, flags);
+		}
 
 		br.setCoords(br.left()   + dbi,
 			     br.top()    + dbi,
@@ -645,9 +1104,9 @@ void TQCommonStyle::drawControl( ControlElement element,
 	    }
 
 	    p->save();
-	    p->setBrushOrigin( -widget->backgroundOffset().x(),
-			       -widget->backgroundOffset().y() );
-	    drawPrimitive(PE_ButtonCommand, p, br, cg, flags);
+	    p->setBrushOrigin( -ceData.bgOffset.x(),
+			       -ceData.bgOffset.y() );
+	    drawPrimitive(PE_ButtonCommand, p, ceData, elementFlags, br, cg, flags);
 	    p->restore();
 #endif
 	    break;
@@ -656,43 +1115,42 @@ void TQCommonStyle::drawControl( ControlElement element,
     case CE_PushButtonLabel:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
 	    TQRect ir = r;
 
-	    if (button->isDown() || button->isOn()) {
+	    if ((elementFlags & CEF_IsDown) || (elementFlags & CEF_IsOn)) {
 		flags |= Style_Sunken;
-		ir.moveBy(pixelMetric(PM_ButtonShiftHorizontal, widget),
-			  pixelMetric(PM_ButtonShiftVertical, widget));
+		ir.moveBy(pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget),
+			  pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget));
 	    }
 
-	    if (button->isMenuButton()) {
-		int mbi = pixelMetric(PM_MenuButtonIndicator, widget);
+	    if (elementFlags & CEF_IsMenuWidget) {
+		int mbi = pixelMetric(PM_MenuButtonIndicator, ceData, elementFlags, widget);
 		TQRect ar(ir.right() - mbi, ir.y() + 2, mbi - 4, ir.height() - 4);
-		drawPrimitive(PE_ArrowDown, p, ar, cg, flags, opt);
+		drawPrimitive(PE_ArrowDown, p, ceData, elementFlags, ar, cg, flags, opt);
 		ir.setWidth(ir.width() - mbi);
 	    }
 
 	    int tf=AlignVCenter | ShowPrefix;
-	    if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
+	    if ((!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget)) || ((styleHint(SH_HideUnderlineAcceleratorWhenAltUp, ceData, elementFlags, TQStyleOption::Default, 0, widget)) && (!acceleratorsShown())))
 		tf |= NoAccel;
 
 #ifndef QT_NO_ICONSET
-	    if ( button->iconSet() && ! button->iconSet()->isNull() ) {
+	    if ( !ceData.iconSet.isNull() ) {
 		TQIconSet::Mode mode =
-		    button->isEnabled() ? TQIconSet::Normal : TQIconSet::Disabled;
-		if ( mode == TQIconSet::Normal && button->hasFocus() )
+		    (elementFlags & CEF_IsEnabled) ? TQIconSet::Normal : TQIconSet::Disabled;
+		if ( mode == TQIconSet::Normal && (elementFlags & CEF_HasFocus) )
 		    mode = TQIconSet::Active;
 
 		TQIconSet::State state = TQIconSet::Off;
-		if ( button->isToggleButton() && button->isOn() )
+		if ( (elementFlags & CEF_BiState) && (elementFlags & CEF_IsOn) )
 		    state = TQIconSet::On;
 
-		TQPixmap pixmap = button->iconSet()->pixmap( TQIconSet::Small, mode, state );
+		TQPixmap pixmap = ceData.iconSet.pixmap( TQIconSet::Small, mode, state );
 		int pixw = pixmap.width();
 		int pixh = pixmap.height();
 
 		//Center the icon if there is neither text nor pixmap
-		if ( button->text().isEmpty() && !button->pixmap() )
+		if ( ceData.text.isEmpty() && ceData.fgPixmap.isNull() )
 		    p->drawPixmap( ir.x() + ir.width() / 2 - pixw / 2, ir.y() + ir.height() / 2 - pixh / 2, pixmap );
 		else
 		    p->drawPixmap( ir.x() + 2, ir.y() + ir.height() / 2 - pixh / 2, pixmap );
@@ -700,66 +1158,62 @@ void TQCommonStyle::drawControl( ControlElement element,
 		ir.moveBy(pixw + 4, 0);
 		ir.setWidth(ir.width() - (pixw + 4));
 		// left-align text if there is
-		if (!button->text().isEmpty())
+		if (!ceData.text.isEmpty())
 		    tf |= AlignLeft;
-		else if (button->pixmap())
+		else if (!ceData.fgPixmap.isNull())
 		    tf |= AlignHCenter;
 	    } else
 #endif //QT_NO_ICONSET
 		tf |= AlignHCenter;
 	    drawItem(p, ir, tf, cg,
-		     flags & Style_Enabled, button->pixmap(), button->text(),
-		     button->text().length(), &(cg.buttonText()) );
+		     flags & Style_Enabled, (ceData.fgPixmap.isNull())?NULL:&ceData.fgPixmap, ceData.text,
+		     ceData.text.length(), &(cg.buttonText()) );
 
 	    if (flags & Style_HasFocus)
-		drawPrimitive(PE_FocusRect, p, subRect(SR_PushButtonFocusRect, widget),
+		drawPrimitive(PE_FocusRect, p, ceData, elementFlags, subRect(SR_PushButtonFocusRect, ceData, elementFlags, widget),
 			      cg, flags);
 #endif
 	    break;
 	}
 
     case CE_CheckBox:
-	drawPrimitive(PE_Indicator, p, r, cg, flags, opt);
+	drawPrimitive(PE_Indicator, p, ceData, elementFlags, r, cg, flags, opt);
 	break;
 
     case CE_CheckBoxLabel:
 	{
 #ifndef QT_NO_CHECKBOX
-	    const TQCheckBox *checkbox = (const TQCheckBox *) widget;
-
 	    int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
-	    if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
+	    if ((!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget)) || ((styleHint(SH_HideUnderlineAcceleratorWhenAltUp, ceData, elementFlags, TQStyleOption::Default, 0, widget)) && (!acceleratorsShown())))
 		alignment |= NoAccel;
 
 	    drawItem(p, r, alignment | AlignVCenter | ShowPrefix, cg,
-		     flags & Style_Enabled, checkbox->pixmap(), checkbox->text());
+		     flags & Style_Enabled, (ceData.fgPixmap.isNull())?NULL:&ceData.fgPixmap, ceData.text);
 
 	    if (flags & Style_HasFocus) {
-		TQRect fr = visualRect(subRect(SR_CheckBoxFocusRect, widget), widget);
-		drawPrimitive(PE_FocusRect, p, fr, cg, flags);
+		TQRect fr = visualRect(subRect(SR_CheckBoxFocusRect, ceData, elementFlags, widget), ceData, elementFlags);
+		drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, flags);
 	    }
 #endif
 	    break;
 	}
 
     case CE_RadioButton:
-	drawPrimitive(PE_ExclusiveIndicator, p, r, cg, flags, opt);
+	drawPrimitive(PE_ExclusiveIndicator, p, ceData, elementFlags, r, cg, flags, opt);
 	break;
 
     case CE_RadioButtonLabel:
 	{
 #ifndef QT_NO_RADIOBUTTON
-	    const TQRadioButton *radiobutton = (const TQRadioButton *) widget;
-
 	    int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
-	    if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
+	    if ((!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget)) || ((styleHint(SH_HideUnderlineAcceleratorWhenAltUp, ceData, elementFlags, TQStyleOption::Default, 0, widget)) && (!acceleratorsShown())))
 		alignment |= NoAccel;
 	    drawItem(p, r, alignment | AlignVCenter | ShowPrefix, cg,
-		     flags & Style_Enabled, radiobutton->pixmap(), radiobutton->text());
+		     flags & Style_Enabled, (ceData.fgPixmap.isNull())?NULL:&ceData.fgPixmap, ceData.text);
 
 	    if (flags & Style_HasFocus) {
-		TQRect fr = visualRect(subRect(SR_RadioButtonFocusRect, widget), widget);
-		drawPrimitive(PE_FocusRect, p, fr, cg, flags);
+		TQRect fr = visualRect(subRect(SR_RadioButtonFocusRect, ceData, elementFlags, widget), ceData, elementFlags);
+		drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, flags);
 	    }
 #endif
 	    break;
@@ -768,10 +1222,8 @@ void TQCommonStyle::drawControl( ControlElement element,
 #ifndef QT_NO_TABBAR
     case CE_TabBarTab:
 	{
-	    const TQTabBar * tb = (const TQTabBar *) widget;
-
-	    if ( tb->shape() == TQTabBar::TriangularAbove ||
-		 tb->shape() == TQTabBar::TriangularBelow ) {
+	    if ( ceData.tabBarData.shape == TQTabBar::TriangularAbove ||
+		 ceData.tabBarData.shape == TQTabBar::TriangularBelow ) {
 		// triangular, above or below
 		int y;
 		int x;
@@ -790,7 +1242,7 @@ void TQCommonStyle::drawControl( ControlElement element,
 		for ( i = 0; i < 5; i++ )
 		    a.setPoint( 9-i, right - a.point( i ).x(), a.point( i ).y() );
 
-		if ( tb->shape() == TQTabBar::TriangularAbove )
+		if ( ceData.tabBarData.shape == TQTabBar::TriangularAbove )
 		    for ( i = 0; i < 10; i++ )
 			a.setPoint( i, a.point(i).x(),
 				    r.height() - 1 - a.point( i ).y() );
@@ -813,22 +1265,21 @@ void TQCommonStyle::drawControl( ControlElement element,
 	    if ( opt.isDefault() )
 		break;
 
-	    const TQTabBar * tb = (const TQTabBar *) widget;
 	    TQTab * t = opt.tab();
 
 	    TQRect tr = r;
-	    if ( t->identifier() == tb->currentTab() )
+	    if (elementFlags & CEF_IsActive)
 		tr.setBottom( tr.bottom() -
-			      pixelMetric( TQStyle::PM_DefaultFrameWidth, tb ) );
+			      pixelMetric( TQStyle::PM_DefaultFrameWidth, ceData, elementFlags, widget ) );
 
 	    int alignment = AlignCenter | ShowPrefix;
-	    if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
+	    if ((!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget)) || ((styleHint(SH_HideUnderlineAcceleratorWhenAltUp, ceData, elementFlags, TQStyleOption::Default, 0, widget)) && (!acceleratorsShown())))
 		alignment |= NoAccel;
 	    drawItem( p, tr, alignment, cg,
 		      flags & Style_Enabled, 0, t->text() );
 
 	    if ( (flags & Style_HasFocus) && !t->text().isEmpty() )
-		drawPrimitive( PE_FocusRect, p, r, cg );
+		drawPrimitive( PE_FocusRect, p, ceData, elementFlags, r, cg );
 	    break;
 	}
 #endif // QT_NO_TABBAR
@@ -845,10 +1296,8 @@ void TQCommonStyle::drawControl( ControlElement element,
 	    a.setPoint( 5, r.width() - 1, r.height() + 1 );
 	    a.setPoint( 6, -1, r.height() + 1 );
 
-	    const TQToolBox *tb = (const TQToolBox*)widget;
-
-	    if ( flags & Style_Selected && tb->currentItem() )
-		p->setBrush( tb->currentItem()->paletteBackgroundColor() );
+	    if ( flags & Style_Selected && !(elementFlags & CEF_IsContainerEmpty) )
+		p->setBrush( ceData.activeItemPaletteBgColor );
 	    else
 		p->setBrush( cg.brush(TQColorGroup::Background) );
 
@@ -869,32 +1318,31 @@ void TQCommonStyle::drawControl( ControlElement element,
 #ifndef QT_NO_PROGRESSBAR
     case CE_ProgressBarContents:
 	{
-	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
 	    // Correct the highlight color if same as background,
 	    // or else we cannot see the progress...
 	    TQColorGroup cgh = cg;
 	    if ( cgh.highlight() == cgh.background() )
-		cgh.setColor( TQColorGroup::Highlight, progressbar->palette().active().highlight() );
+		cgh.setColor( TQColorGroup::Highlight, ceData.palette.active().highlight() );
 	    bool reverse = TQApplication::reverseLayout();
 	    int fw = 2;
 	    int w = r.width() - 2*fw;
-	    if ( !progressbar->totalSteps() ) {
+	    if ( !ceData.totalSteps ) {
 		// draw busy indicator
-		int x = progressbar->progress() % (w * 2);
+		int x = ceData.currentStep % (w * 2);
 		if (x > w)
 		    x = 2 * w - x;
 		x = reverse ? r.right() - x : x + r.x();
 		p->setPen( TQPen(cgh.highlight(), 4) );
 		p->drawLine(x, r.y() + 1, x, r.height() - fw);
 	    } else {
-		const int unit_width = pixelMetric(PM_ProgressBarChunkWidth, widget);
+		const int unit_width = pixelMetric(PM_ProgressBarChunkWidth, ceData, elementFlags, widget);
 		int u;
 		if ( unit_width > 1 )
 		    u = (r.width()+unit_width/3) / unit_width;
 		else
 		    u = w / unit_width;
-		int p_v = progressbar->progress();
-		int t_s = progressbar->totalSteps() ? progressbar->totalSteps() : 1;
+		int p_v = ceData.currentStep;
+		int t_s = ceData.totalSteps ? ceData.totalSteps : 1;
 
 		if ( u > 0 && p_v >= INT_MAX / u && t_s >= u ) {
 		    // scale down to something usable.
@@ -917,7 +1365,7 @@ void TQCommonStyle::drawControl( ControlElement element,
 		int x0 = reverse ? r.right() - ((unit_width > 1) ?
 						unit_width : fw) : r.x() + fw;
 		for (int i=0; i<nu; i++) {
-		    drawPrimitive( PE_ProgressBarChunk, p,
+		    drawPrimitive( PE_ProgressBarChunk, p, ceData, elementFlags,
 				   TQRect( x0+x, r.y(), unit_width, r.height() ),
 				   cgh, Style_Default, opt );
 		    x += reverse ? -unit_width: unit_width;
@@ -928,7 +1376,7 @@ void TQCommonStyle::drawControl( ControlElement element,
 		if (nu < tnu) {
 		    int pixels_left = w - (nu*unit_width);
 		    int offset = reverse ? x0+x+unit_width-pixels_left : x0+x;
-		    drawPrimitive( PE_ProgressBarChunk, p,
+		    drawPrimitive( PE_ProgressBarChunk, p, ceData, elementFlags,
 				   TQRect( offset, r.y(), pixels_left,
 					  r.height() ), cgh, Style_Default,
 				   opt );
@@ -939,14 +1387,13 @@ void TQCommonStyle::drawControl( ControlElement element,
 
     case CE_ProgressBarLabel:
 	{
-	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
 	    TQColor penColor = cg.highlightedText();
 	    TQColor *pcolor = 0;
-	    if ( progressbar->centerIndicator() && !progressbar->indicatorFollowsStyle() &&
-		 progressbar->progress()*2 >= progressbar->totalSteps() )
+	    if ( (elementFlags & CEF_CenterIndicator) && !(elementFlags & CEF_IndicatorFollowsStyle) &&
+		 ceData.currentStep*2 >= ceData.totalSteps )
 		pcolor = &penColor;
 	    drawItem(p, r, AlignCenter | SingleLine, cg, flags & Style_Enabled, 0,
-		     progressbar->progressString(), -1, pcolor );
+		     ceData.progressText, -1, pcolor );
 	}
 	break;
 #endif // QT_NO_PROGRESSBAR
@@ -959,7 +1406,7 @@ void TQCommonStyle::drawControl( ControlElement element,
 
 	    TQMenuItem *mi = opt.menuItem();
 	    int alignment = AlignCenter|ShowPrefix|DontClip|SingleLine;
-	    if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
+	    if ((!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget)) || ((styleHint(SH_HideUnderlineAcceleratorWhenAltUp, ceData, elementFlags, TQStyleOption::Default, 0, widget)) && (!acceleratorsShown())))
 		alignment |= NoAccel;
 	    drawItem( p, r, alignment, cg,
 		      flags & Style_Enabled, mi->pixmap(), mi->text(), -1,
@@ -971,7 +1418,6 @@ void TQCommonStyle::drawControl( ControlElement element,
 #ifndef QT_NO_TOOLBUTTON
     case CE_ToolButtonLabel:
 	{
-	    const TQToolButton *toolbutton = (const TQToolButton *) widget;
 	    TQRect rect = r;
 	    TQt::ArrowType arrowType = opt.isDefault()
 			? TQt::DownArrow : opt.arrowType();
@@ -979,8 +1425,8 @@ void TQCommonStyle::drawControl( ControlElement element,
 	    int shiftX = 0;
 	    int shiftY = 0;
 	    if (flags & (Style_Down | Style_On)) {
-		shiftX = pixelMetric(PM_ButtonShiftHorizontal, widget);
-		shiftY = pixelMetric(PM_ButtonShiftVertical, widget);
+		shiftX = pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget);
+		shiftY = pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget);
 	    }
 
 	    if (!opt.isDefault()) {
@@ -994,45 +1440,45 @@ void TQCommonStyle::drawControl( ControlElement element,
 		}
 
 		rect.moveBy(shiftX, shiftY);
-		drawPrimitive(pe, p, rect, cg, flags, opt);
+		drawPrimitive(pe, p, ceData, elementFlags, rect, cg, flags, opt);
 	    } else {
-		TQColor btext = toolbutton->paletteForegroundColor();
+		TQColor btext = ceData.fgColor;
 
-		if (toolbutton->iconSet().isNull() &&
-		    ! toolbutton->text().isNull() &&
-		    ! toolbutton->usesTextLabel()) {
+		if (ceData.iconSet.isNull() &&
+		    ! ceData.text.isNull() &&
+		    ! (elementFlags & CEF_UsesTextLabel)) {
 		    int alignment = AlignCenter | ShowPrefix;
-		    if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
+		    if ((!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget)) || ((styleHint(SH_HideUnderlineAcceleratorWhenAltUp, ceData, elementFlags, TQStyleOption::Default, 0, widget)) && (!acceleratorsShown())))
 			alignment |= NoAccel;
 
 		    rect.moveBy(shiftX, shiftY);
 		    drawItem(p, rect, alignment, cg,
-			     flags & Style_Enabled, 0, toolbutton->text(),
-			     toolbutton->text().length(), &btext);
+			     flags & Style_Enabled, 0, ceData.text,
+			     ceData.text.length(), &btext);
 		} else {
 		    TQPixmap pm;
 		    TQIconSet::Size size =
-			toolbutton->usesBigPixmap() ? TQIconSet::Large : TQIconSet::Small;
+			(elementFlags & CEF_UsesBigPixmap) ? TQIconSet::Large : TQIconSet::Small;
 		    TQIconSet::State state =
-			toolbutton->isOn() ? TQIconSet::On : TQIconSet::Off;
+			(elementFlags & CEF_IsOn) ? TQIconSet::On : TQIconSet::Off;
 		    TQIconSet::Mode mode;
-		    if (! toolbutton->isEnabled())
+		    if (! (elementFlags & CEF_IsEnabled))
 			mode = TQIconSet::Disabled;
 		    else if (flags & (Style_Down | Style_On) ||
 			     ((flags & Style_Raised) && (flags & Style_AutoRaise)))
 			mode = TQIconSet::Active;
 		    else
 			mode = TQIconSet::Normal;
-		    pm = toolbutton->iconSet().pixmap( size, mode, state );
+		    pm = ceData.iconSet.pixmap( size, mode, state );
 
-		    if ( toolbutton->usesTextLabel() ) {
-			p->setFont( toolbutton->font() );
+		    if (elementFlags & CEF_UsesTextLabel) {
+			p->setFont( ceData.font );
 			TQRect pr = rect, tr = rect;
 			int alignment = ShowPrefix;
-			if (!styleHint(SH_UnderlineAccelerator, widget, TQStyleOption::Default, 0))
+			if ((!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget)) || ((styleHint(SH_HideUnderlineAcceleratorWhenAltUp, ceData, elementFlags, TQStyleOption::Default, 0, widget)) && (!acceleratorsShown())))
 			    alignment |= NoAccel;
 
-			if ( toolbutton->textPosition() == TQToolButton::Under ) {
+			if ( ceData.toolButtonTextPosition == TQToolButton::Under ) {
 			    int fh = p->fontMetrics().height();
 			    pr.addCoords( 0, 1, 0, -fh-3 );
 			    tr.addCoords( 0, pr.bottom(), 0, -3 );
@@ -1050,8 +1496,8 @@ void TQCommonStyle::drawControl( ControlElement element,
 
 			tr.moveBy(shiftX, shiftY);
 			drawItem( p, tr, alignment, cg,
-				  flags & Style_Enabled, 0, toolbutton->textLabel(),
-				  toolbutton->textLabel().length(), &btext);
+				  flags & Style_Enabled, 0, ceData.textLabel,
+				  ceData.textLabel.length(), &btext);
 		    } else {
 			rect.moveBy(shiftX, shiftY);
 			drawItem( p, rect, AlignCenter, cg, TRUE, &pm, TQString::null );
@@ -1066,10 +1512,8 @@ void TQCommonStyle::drawControl( ControlElement element,
         case CE_HeaderLabel:
 	{
 	    TQRect rect = r;
-	    const TQHeader* header = (const TQHeader *) widget;
-	    int section = opt.headerSection();
 
-	    TQIconSet* icon = header->iconSet( section );
+	    TQIconSet* icon = &ceData.iconSet;
 	    if ( icon ) {
 		TQPixmap pixmap = icon->pixmap( TQIconSet::Small,
 					       flags & Style_Enabled ?
@@ -1090,7 +1534,7 @@ void TQCommonStyle::drawControl( ControlElement element,
 
             if (rect.isValid())
                 drawItem ( p, rect, AlignVCenter, cg, flags & Style_Enabled,
-                           0, header->label( section ), -1, &(cg.buttonText()) );
+                           0, ceData.textLabel, -1, &(cg.buttonText()) );
 	}
 #endif // QT_NO_HEADER
     default:
@@ -1100,13 +1544,27 @@ void TQCommonStyle::drawControl( ControlElement element,
     activePainter = 0;
 }
 
-/*! \reimp */
 void TQCommonStyle::drawControlMask( ControlElement control,
 				    TQPainter *p,
 				    const TQWidget *widget,
 				    const TQRect &r,
 				    const TQStyleOption& opt ) const
 {
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, opt);
+	drawControlMask(control, p, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, opt), r, opt, widget);
+}
+
+/*! \reimp */
+void TQCommonStyle::drawControlMask( ControlElement control,
+				TQPainter *p,
+				TQStyleControlElementData ceData,
+				ControlElementFlags elementFlags,
+				const TQRect &r,
+				const TQStyleOption& opt,
+				const TQWidget *widget ) const
+{
+    Q_UNUSED(ceData);
+    Q_UNUSED(elementFlags);
     Q_UNUSED(widget);
 
     activePainter = p;
@@ -1115,15 +1573,15 @@ void TQCommonStyle::drawControlMask( ControlElement control,
 
     switch (control) {
     case CE_PushButton:
-	drawPrimitive(PE_ButtonCommand, p, r, cg, Style_Default, opt);
+	drawPrimitive(PE_ButtonCommand, p, ceData, elementFlags, r, cg, Style_Default, opt);
 	break;
 
     case CE_CheckBox:
-	drawPrimitive(PE_IndicatorMask, p, r, cg, Style_Default, opt);
+	drawPrimitive(PE_IndicatorMask, p, ceData, elementFlags, r, cg, Style_Default, opt);
 	break;
 
     case CE_RadioButton:
-	drawPrimitive(PE_ExclusiveIndicatorMask, p, r, cg, Style_Default, opt);
+	drawPrimitive(PE_ExclusiveIndicatorMask, p, ceData, elementFlags, r, cg, Style_Default, opt);
 	break;
 
     default:
@@ -1138,13 +1596,20 @@ void TQCommonStyle::drawControlMask( ControlElement control,
 TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 {
 #if defined(QT_CHECK_STATE)
-    if (! widget) {
-	tqWarning("TQCommonStyle::subRect: widget parameter cannot be zero!");
-	return TQRect();
-    }
+	if (! widget) {
+		tqWarning("TQCommonStyle::subRect: widget parameter cannot be zero!");
+		return TQRect();
+	}
 #endif
 
-    TQRect rect, wrect(widget->rect());
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
+	return subRect(r, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), widget);
+}
+
+/*! \reimp */
+TQRect TQCommonStyle::subRect(SubRect r, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags, const TQWidget *widget) const
+{
+    TQRect rect, wrect(ceData.rect);
 
     switch (r) {
 #ifndef QT_NO_DIALOGBUTTONS
@@ -1175,22 +1640,21 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 	else if(r == SR_DialogButtonAbort)
 	    srch = TQDialogButtons::Abort;
 
-	const int bwidth = pixelMetric(PM_DialogButtonsButtonWidth, widget),
-		 bheight = pixelMetric(PM_DialogButtonsButtonHeight, widget),
-		  bspace = pixelMetric(PM_DialogButtonsSeparator, widget),
-		      fw = pixelMetric(PM_DefaultFrameWidth, widget);
-	const TQDialogButtons *dbtns = (const TQDialogButtons *) widget;
+	const int bwidth = pixelMetric(PM_DialogButtonsButtonWidth, ceData, elementFlags, widget),
+		 bheight = pixelMetric(PM_DialogButtonsButtonHeight, ceData, elementFlags, widget),
+		  bspace = pixelMetric(PM_DialogButtonsSeparator, ceData, elementFlags, widget),
+		      fw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget);
 	int start = fw;
-	if(dbtns->orientation() == Horizontal)
+	if(ceData.orientation == Horizontal)
 	    start = wrect.right() - fw;
 	TQDialogButtons::Button btns[] = { TQDialogButtons::All, TQDialogButtons::Reject, TQDialogButtons::Accept, //reverse order (right to left)
 					  TQDialogButtons::Apply, TQDialogButtons::Retry, TQDialogButtons::Ignore, TQDialogButtons::Abort,
 					  TQDialogButtons::Help };
 	for(unsigned int i = 0, cnt = 0; i < (sizeof(btns)/sizeof(btns[0])); i++) {
-	    if(dbtns->isButtonVisible(btns[i])) {
-		TQSize szH = dbtns->sizeHint(btns[i]);
+	    if (ceData.dlgVisibleButtons & btns[i]) {
+		TQSize szH = ceData.dlgVisibleSizeHints[btns[i]];
 		int mwidth = TQMAX(bwidth, szH.width()), mheight = TQMAX(bheight, szH.height());
-		if(dbtns->orientation() == Horizontal) {
+		if(ceData.orientation == Horizontal) {
 		    start -= mwidth;
 		    if(cnt)
 			start -= bspace;
@@ -1200,7 +1664,7 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 		}
 		cnt++;
 		if(btns[i] == srch) {
-		    if(dbtns->orientation() == Horizontal)
+		    if(ceData.orientation == Horizontal)
 			return TQRect(start, wrect.bottom() - fw - mheight, mwidth, mheight);
 		    else
 			return TQRect(fw, start, mwidth, mheight);
@@ -1208,7 +1672,7 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 	    }
 	}
 	if(r == SR_DialogButtonCustom) {
-	    if(dbtns->orientation() == Horizontal)
+	    if(ceData.orientation == Horizontal)
 		return TQRect(fw, fw, start - fw - bspace, wrect.height() - (fw*2));
 	    else
 		return TQRect(fw, start, wrect.width() - (fw*2), wrect.height() - start - (fw*2));
@@ -1218,12 +1682,11 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
     case SR_PushButtonContents:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
 	    int dx1, dx2;
 
-	    dx1 = pixelMetric(PM_DefaultFrameWidth, widget);
-	    if (button->isDefault() || button->autoDefault())
-		dx1 += pixelMetric(PM_ButtonDefaultIndicator, widget);
+	    dx1 = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget);
+	    if ((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault))
+		dx1 += pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget);
 	    dx2 = dx1 * 2;
 
 	    rect.setRect(wrect.x()      + dx1,
@@ -1237,14 +1700,13 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
     case SR_PushButtonFocusRect:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
 	    int dbw1 = 0, dbw2 = 0;
-	    if (button->isDefault() || button->autoDefault()) {
-		dbw1 = pixelMetric(PM_ButtonDefaultIndicator, widget);
+	    if ((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault)) {
+		dbw1 = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget);
 		dbw2 = dbw1 * 2;
 	    }
 
-	    int dfw1 = pixelMetric(PM_DefaultFrameWidth, widget) * 2,
+	    int dfw1 = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) * 2,
 		dfw2 = dfw1 * 2;
 
 	    rect.setRect(wrect.x()      + dfw1 + dbw1,
@@ -1257,16 +1719,16 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 
     case SR_CheckBoxIndicator:
 	{
-	    int h = pixelMetric( PM_IndicatorHeight, widget );
+	    int h = pixelMetric( PM_IndicatorHeight, ceData, elementFlags, widget );
 	    rect.setRect(0, ( wrect.height() - h ) / 2,
-			 pixelMetric( PM_IndicatorWidth, widget ), h );
+			 pixelMetric( PM_IndicatorWidth, ceData, elementFlags, widget ), h );
 	    break;
 	}
 
     case SR_CheckBoxContents:
 	{
 #ifndef QT_NO_CHECKBOX
-	    TQRect ir = subRect(SR_CheckBoxIndicator, widget);
+	    TQRect ir = subRect(SR_CheckBoxIndicator, ceData, elementFlags, widget);
 	    rect.setRect(ir.right() + 6, wrect.y(),
 			 wrect.width() - ir.width() - 6, wrect.height());
 #endif
@@ -1276,23 +1738,22 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
     case SR_CheckBoxFocusRect:
 	{
 #ifndef QT_NO_CHECKBOX
-	    const TQCheckBox *checkbox = (const TQCheckBox *) widget;
-	    if ( !checkbox->pixmap() && checkbox->text().isEmpty() ) {
-		rect = subRect( SR_CheckBoxIndicator, widget );
+	    if ( ceData.fgPixmap.isNull() && ceData.text.isEmpty() ) {
+		rect = subRect( SR_CheckBoxIndicator, ceData, elementFlags, widget );
 		rect.addCoords( 1, 1, -1, -1 );
 		break;
 	    }
-	    TQRect cr = subRect(SR_CheckBoxContents, widget);
+	    TQRect cr = subRect(SR_CheckBoxContents, ceData, elementFlags, widget);
 
 	    // don't create a painter if we have an active one
 	    TQPainter *p = 0;
 	    if (! activePainter)
-		p = new TQPainter(checkbox);
+		p = new TQPainter(widget);
 	    rect = itemRect((activePainter ? activePainter : p),
 			    cr, AlignLeft | AlignVCenter | ShowPrefix,
-			    checkbox->isEnabled(),
-			    checkbox->pixmap(),
-			    checkbox->text());
+			    (elementFlags & CEF_IsEnabled),
+			    (ceData.fgPixmap.isNull())?NULL:&ceData.fgPixmap,
+			    ceData.text);
 
 	    delete p;
 
@@ -1304,15 +1765,15 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 
     case SR_RadioButtonIndicator:
 	{
-	    int h = pixelMetric( PM_ExclusiveIndicatorHeight, widget );
+	    int h = pixelMetric( PM_ExclusiveIndicatorHeight, ceData, elementFlags, widget );
 	    rect.setRect(0, ( wrect.height() - h ) / 2,
-			 pixelMetric( PM_ExclusiveIndicatorWidth, widget ), h );
+			 pixelMetric( PM_ExclusiveIndicatorWidth, ceData, elementFlags, widget ), h );
 	    break;
 	}
 
     case SR_RadioButtonContents:
 	{
-	    TQRect ir = subRect(SR_RadioButtonIndicator, widget);
+	    TQRect ir = subRect(SR_RadioButtonIndicator, ceData, elementFlags, widget);
 	    rect.setRect(ir.right() + 6, wrect.y(),
 			 wrect.width() - ir.width() - 6, wrect.height());
 	    break;
@@ -1321,23 +1782,22 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
     case SR_RadioButtonFocusRect:
 	{
 #ifndef QT_NO_RADIOBUTTON
-	    const TQRadioButton *radiobutton = (const TQRadioButton *) widget;
-	    if ( !radiobutton->pixmap() && radiobutton->text().isEmpty() ) {
-		rect = subRect( SR_RadioButtonIndicator, widget );
+	    if ( ceData.fgPixmap.isNull() && ceData.text.isEmpty() ) {
+		rect = subRect( SR_RadioButtonIndicator, ceData, elementFlags, widget );
 		rect.addCoords( 1, 1, -1, -1 );
 		break;
 	    }
-	    TQRect cr = subRect(SR_RadioButtonContents, widget);
+	    TQRect cr = subRect(SR_RadioButtonContents, ceData, elementFlags, widget);
 
 	    // don't create a painter if we have an active one
 	    TQPainter *p = 0;
 	    if (! activePainter)
-		p = new TQPainter(radiobutton);
+		p = new TQPainter(widget);
 	    rect = itemRect((activePainter ? activePainter : p),
 			    cr, AlignLeft | AlignVCenter | ShowPrefix,
-			    radiobutton->isEnabled(),
-			    radiobutton->pixmap(),
-			    radiobutton->text());
+			    (elementFlags & CEF_IsEnabled),
+			    (ceData.fgPixmap.isNull())?NULL:&ceData.fgPixmap,
+			    ceData.text);
 	    delete p;
 
 	    rect.addCoords( -3, -2, 3, 2 );
@@ -1347,21 +1807,20 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 	}
 
     case SR_ComboBoxFocusRect:
-	rect.setRect(3, 3, widget->width()-6-16, widget->height()-6);
+	rect.setRect(3, 3, ceData.rect.width()-6-16, ceData.rect.height()-6);
 	break;
 
 #ifndef QT_NO_SLIDER
     case SR_SliderFocusRect:
 	{
-	    const TQSlider * sl = (const TQSlider *) widget;
-	    int tickOffset = pixelMetric( PM_SliderTickmarkOffset, sl );
-	    int thickness  = pixelMetric( PM_SliderControlThickness, sl );
+	    int tickOffset = pixelMetric( PM_SliderTickmarkOffset, ceData, elementFlags, widget );
+	    int thickness  = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
 
-	    if ( sl->orientation() == Horizontal )
-		rect.setRect( 0, tickOffset-1, sl->width(), thickness+2 );
+	    if ( ceData.orientation == Horizontal )
+		rect.setRect( 0, tickOffset-1, ceData.rect.width(), thickness+2 );
 	    else
-		rect.setRect( tickOffset-1, 0, thickness+2, sl->height() );
-	    rect = rect.intersect( sl->rect() ); // ## is this really necessary?
+		rect.setRect( tickOffset-1, 0, thickness+2, ceData.rect.height() );
+	    rect = rect.intersect( ceData.rect ); // ## is this really necessary?
 	    break;
 	}
 #endif // QT_NO_SLIDER
@@ -1369,18 +1828,16 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 #ifndef QT_NO_MAINWINDOW
     case SR_DockWindowHandleRect:
 	{
-	    if (! widget->parentWidget())
+	    if (!(elementFlags & CEF_HasParentWidget))
 		break;
 
-	    const TQDockWindow * dw = (const TQDockWindow *) widget->parentWidget();
-
-	    if ( !dw->area() || !dw->isCloseEnabled() )
-		rect.setRect( 0, 0, widget->width(), widget->height() );
+	    if ( !ceData.dwData.hasDockArea || !ceData.dwData.closeEnabled )
+		rect.setRect( 0, 0, ceData.rect.width(), ceData.rect.height() );
 	    else {
-		if ( dw->area()->orientation() == Horizontal )
-		    rect.setRect(0, 15, widget->width(), widget->height() - 15);
+		if ( ceData.dwData.areaOrientation == Horizontal )
+		    rect.setRect(0, 15, ceData.rect.width(), ceData.rect.height() - 15);
 		else
-		    rect.setRect(0, 1, widget->width() - 15, widget->height() - 1);
+		    rect.setRect(0, 1, ceData.rect.width() - 15, ceData.rect.height() - 1);
 	    }
 	    break;
 	}
@@ -1390,15 +1847,14 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
     case SR_ProgressBarContents:
 	{
 #ifndef QT_NO_PROGRESSBAR
-	    TQFontMetrics fm( ( widget ? widget->fontMetrics() :
+	    TQFontMetrics fm( ( (!(elementFlags & CEF_UseGenericParameters)) ? TQFontMetrics(ceData.font) :
 			       TQApplication::fontMetrics() ) );
-	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
 	    int textw = 0;
-	    if (progressbar->percentageVisible())
+	    if (ceData.percentageVisible)
 		textw = fm.width("100%") + 6;
 
-	    if (progressbar->indicatorFollowsStyle() ||
-		! progressbar->centerIndicator())
+	    if ((elementFlags & CEF_IndicatorFollowsStyle) ||
+		! (elementFlags & CEF_CenterIndicator))
 		rect.setCoords(wrect.left(), wrect.top(),
 			       wrect.right() - textw, wrect.bottom());
 	    else
@@ -1410,15 +1866,14 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
     case SR_ProgressBarLabel:
 	{
 #ifndef QT_NO_PROGRESSBAR
-	    TQFontMetrics fm( ( widget ? widget->fontMetrics() :
+	    TQFontMetrics fm( ( (!(elementFlags & CEF_UseGenericParameters)) ? TQFontMetrics(ceData.font) :
 			       TQApplication::fontMetrics() ) );
-	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
 	    int textw = 0;
-	    if (progressbar->percentageVisible())
+	    if (ceData.percentageVisible)
 		textw = fm.width("100%") + 6;
 
-	    if (progressbar->indicatorFollowsStyle() ||
-		! progressbar->centerIndicator())
+	    if ((elementFlags & CEF_IndicatorFollowsStyle) ||
+		! (elementFlags & CEF_CenterIndicator))
 		rect.setCoords(wrect.right() - textw, wrect.top(),
 			       wrect.right(), wrect.bottom());
 	    else
@@ -1428,7 +1883,7 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 	}
 
     case SR_ToolButtonContents:
-	rect = querySubControlMetrics(CC_ToolButton, widget, SC_ToolButton);
+	rect = querySubControlMetrics(CC_ToolButton, ceData, elementFlags, SC_ToolButton, TQStyleOption::Default, widget);
 	break;
 
     case SR_ToolBoxTabContents:
@@ -1448,17 +1903,17 @@ TQRect TQCommonStyle::subRect(SubRect r, const TQWidget *widget) const
 /*
   I really need this and I don't want to expose it in TQRangeControl..
 */
-static int qPositionFromValue( const TQRangeControl * rc, int logical_val,
+static int qPositionFromValue( TQStyleControlElementData ceData, int logical_val,
 			       int span )
 {
-    if ( span <= 0 || logical_val < rc->minValue() ||
-	 rc->maxValue() <= rc->minValue() )
+    if ( span <= 0 || logical_val < ceData.minSteps ||
+	 ceData.maxSteps <= ceData.minSteps )
 	return 0;
-    if ( logical_val > rc->maxValue() )
+    if ( logical_val > ceData.maxSteps )
 	return span;
 
-    uint range = rc->maxValue() - rc->minValue();
-    uint p = logical_val - rc->minValue();
+    uint range = ceData.maxSteps - ceData.minSteps;
+    uint p = logical_val - ceData.minSteps;
 
     if ( range > (uint)INT_MAX/4096 ) {
 	const int scale = 4096*2;
@@ -1490,85 +1945,101 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 				       const TQStyleOption& opt ) const
 {
 #if defined(QT_CHECK_STATE)
-    if (! widget) {
-	tqWarning("TQCommonStyle::drawComplexControl: widget parameter cannot be zero!");
-	return;
-    }
+	if (! widget) {
+		tqWarning("TQCommonStyle::drawComplexControl: widget parameter cannot be zero!");
+		return;
+	}
 #endif
 
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
+	drawComplexControl(control, p, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), r, cg, flags, controls, active, opt, widget);
+}
+
+/*! \reimp */
+void TQCommonStyle::drawComplexControl( ComplexControl control,
+				       TQPainter *p,
+				       TQStyleControlElementData ceData,
+				       ControlElementFlags elementFlags,
+				       const TQRect &r,
+				       const TQColorGroup &cg,
+				       SFlags flags,
+				       SCFlags controls,
+				       SCFlags active,
+				       const TQStyleOption& opt,
+				       const TQWidget *widget ) const
+{
     activePainter = p;
 
     switch (control) {
 #ifndef QT_NO_SCROLLBAR
     case CC_ScrollBar:
 	{
-	    const TQScrollBar *scrollbar = (const TQScrollBar *) widget;
 	    TQRect addline, subline, addpage, subpage, slider, first, last;
-	    bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue());
+	    bool maxedOut = (ceData.minSteps == ceData.maxSteps);
 
-	    subline = querySubControlMetrics(control, widget, SC_ScrollBarSubLine, opt);
-	    addline = querySubControlMetrics(control, widget, SC_ScrollBarAddLine, opt);
-	    subpage = querySubControlMetrics(control, widget, SC_ScrollBarSubPage, opt);
-	    addpage = querySubControlMetrics(control, widget, SC_ScrollBarAddPage, opt);
-	    slider  = querySubControlMetrics(control, widget, SC_ScrollBarSlider,  opt);
-	    first   = querySubControlMetrics(control, widget, SC_ScrollBarFirst,   opt);
-	    last    = querySubControlMetrics(control, widget, SC_ScrollBarLast,    opt);
+	    subline = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubLine, opt, widget);
+	    addline = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddLine, opt, widget);
+	    subpage = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubPage, opt, widget);
+	    addpage = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddPage, opt, widget);
+	    slider  = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSlider,  opt, widget);
+	    first   = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarFirst,   opt, widget);
+	    last    = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarLast,    opt, widget);
 
        	    if ((controls & SC_ScrollBarSubLine) && subline.isValid())
-		drawPrimitive(PE_ScrollBarSubLine, p, subline, cg,
+		drawPrimitive(PE_ScrollBarSubLine, p, ceData, elementFlags, subline, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarSubLine) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : 0));
 	    if ((controls & SC_ScrollBarAddLine) && addline.isValid())
-		drawPrimitive(PE_ScrollBarAddLine, p, addline, cg,
+		drawPrimitive(PE_ScrollBarAddLine, p, ceData, elementFlags, addline, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarAddLine) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : 0));
 	    if ((controls & SC_ScrollBarSubPage) && subpage.isValid())
-		drawPrimitive(PE_ScrollBarSubPage, p, subpage, cg,
+		drawPrimitive(PE_ScrollBarSubPage, p, ceData, elementFlags, subpage, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarSubPage) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : 0));
 	    if ((controls & SC_ScrollBarAddPage) && addpage.isValid())
-		drawPrimitive(PE_ScrollBarAddPage, p, addpage, cg,
+		drawPrimitive(PE_ScrollBarAddPage, p, ceData, elementFlags, addpage, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarAddPage) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : 0));
        	    if ((controls & SC_ScrollBarFirst) && first.isValid())
-		drawPrimitive(PE_ScrollBarFirst, p, first, cg,
+		drawPrimitive(PE_ScrollBarFirst, p, ceData, elementFlags, first, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarFirst) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : 0));
 	    if ((controls & SC_ScrollBarLast) && last.isValid())
-		drawPrimitive(PE_ScrollBarLast, p, last, cg,
+		drawPrimitive(PE_ScrollBarLast, p, ceData, elementFlags, last, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarLast) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : 0));
 	    if ((controls & SC_ScrollBarSlider) && slider.isValid()) {
-		drawPrimitive(PE_ScrollBarSlider, p, slider, cg,
+		drawPrimitive(PE_ScrollBarSlider, p, ceData, elementFlags, slider, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarSlider) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : 0));
 
 		// ### perhaps this should not be able to accept focus if maxedOut?
-		if (scrollbar->hasFocus()) {
+		if (elementFlags & CEF_HasFocus) {
 		    TQRect fr(slider.x() + 2, slider.y() + 2,
 			     slider.width() - 5, slider.height() - 5);
-		    drawPrimitive(PE_FocusRect, p, fr, cg, Style_Default);
+		    drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, Style_Default);
 		}
 	    }
 
@@ -1579,15 +2050,13 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 #ifndef QT_NO_TOOLBUTTON
     case CC_ToolButton:
 	{
-	    const TQToolButton *toolbutton = (const TQToolButton *) widget;
-
 	    TQColorGroup c = cg;
-	    if ( toolbutton->backgroundMode() != PaletteButton )
+	    if ( ceData.backgroundMode != PaletteButton )
 		c.setBrush( TQColorGroup::Button,
-			    toolbutton->paletteBackgroundColor() );
+			    ceData.bgColor );
 	    TQRect button, menuarea;
-	    button   = visualRect( querySubControlMetrics(control, widget, SC_ToolButton, opt), widget );
-	    menuarea = visualRect( querySubControlMetrics(control, widget, SC_ToolButtonMenu, opt), widget );
+	    button   = visualRect( querySubControlMetrics(control, ceData, elementFlags, SC_ToolButton, opt, widget), ceData, elementFlags );
+	    menuarea = visualRect( querySubControlMetrics(control, ceData, elementFlags, SC_ToolButtonMenu, opt, widget), ceData, elementFlags );
 
 	    SFlags bflags = flags,
 		   mflags = flags;
@@ -1599,27 +2068,26 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 
 	    if (controls & SC_ToolButton) {
 		if (bflags & (Style_Down | Style_On | Style_Raised)) {
-		    drawPrimitive(PE_ButtonTool, p, button, c, bflags, opt);
-		} else if ( toolbutton->parentWidget() &&
-			  toolbutton->parentWidget()->backgroundPixmap() &&
-			  ! toolbutton->parentWidget()->backgroundPixmap()->isNull() ) {
+		    drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, button, c, bflags, opt);
+		} else if ( (elementFlags & CEF_HasParentWidget) &&
+			  ! ceData.parentWidgetData.bgPixmap.isNull() ) {
 		    TQPixmap pixmap =
-			*(toolbutton->parentWidget()->backgroundPixmap());
+			ceData.parentWidgetData.bgPixmap;
 
-		    p->drawTiledPixmap( r, pixmap, toolbutton->pos() );
+		    p->drawTiledPixmap( r, pixmap, ceData.pos );
 		}
 	    }
 
 	    if (controls & SC_ToolButtonMenu) {
 		if (mflags & (Style_Down | Style_On | Style_Raised))
-		    drawPrimitive(PE_ButtonDropDown, p, menuarea, c, mflags, opt);
-		drawPrimitive(PE_ArrowDown, p, menuarea, c, mflags, opt);
+		    drawPrimitive(PE_ButtonDropDown, p, ceData, elementFlags, menuarea, c, mflags, opt);
+		drawPrimitive(PE_ArrowDown, p, ceData, elementFlags, menuarea, c, mflags, opt);
 	    }
 
-	    if (toolbutton->hasFocus() && !toolbutton->focusProxy()) {
-		TQRect fr = toolbutton->rect();
+	    if ((elementFlags & CEF_HasFocus) && !(elementFlags & CEF_HasFocusProxy)) {
+		TQRect fr = ceData.rect;
 		fr.addCoords(3, 3, -3, -3);
-		drawPrimitive(PE_FocusRect, p, fr, c);
+		drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, c);
 	    }
 
 	    break;
@@ -1629,10 +2097,9 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 #ifndef QT_NO_TITLEBAR
     case CC_TitleBar:
 	{
-	    const TQTitleBar *titlebar = (const TQTitleBar *) widget;
 	    if ( controls & SC_TitleBarLabel ) {
-		TQColorGroup cgroup = titlebar->usesActiveColor() ?
-		    titlebar->palette().active() : titlebar->palette().inactive();
+		TQColorGroup cgroup = (ceData.titleBarData.usesActiveColor) ?
+		    ceData.palette.active() : ceData.palette.inactive();
 
 		TQColor left = cgroup.highlight();
 		TQColor right = cgroup.base();
@@ -1642,27 +2109,27 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 		    double gS = left.green();
 		    double bS = left.blue();
 
-		    const double rD = double(right.red() - rS) / titlebar->width();
-		    const double gD = double(right.green() - gS) / titlebar->width();
-		    const double bD = double(right.blue() - bS) / titlebar->width();
+		    const double rD = double(right.red() - rS) / ceData.rect.width();
+		    const double gD = double(right.green() - gS) / ceData.rect.width();
+		    const double bD = double(right.blue() - bS) / ceData.rect.width();
 
-		    const int w = titlebar->width();
+		    const int w = ceData.rect.width();
 		    for ( int sx = 0; sx < w; sx++ ) {
 			rS+=rD;
 			gS+=gD;
 			bS+=bD;
 			p->setPen( TQColor( (int)rS, (int)gS, (int)bS ) );
-			p->drawLine( sx, 0, sx, titlebar->height() );
+			p->drawLine( sx, 0, sx, ceData.rect.height() );
 		    }
 		} else {
-		    p->fillRect( titlebar->rect(), left );
+		    p->fillRect( ceData.rect, left );
 		}
 
-		TQRect ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarLabel ), widget );
+		TQRect ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarLabel, TQStyleOption::Default, widget ), ceData, elementFlags );
 
 		p->setPen( cgroup.highlightedText() );
 		p->drawText(ir.x()+2, ir.y(), ir.width()-2, ir.height(),
-			    AlignAuto | AlignVCenter | SingleLine, titlebar->visibleText() );
+			    AlignAuto | AlignVCenter | SingleLine, ceData.titleBarData.visibleText );
 	    }
 
 	    TQRect ir;
@@ -1670,46 +2137,46 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 	    TQPixmap pm;
 
 	    if ( controls & SC_TitleBarCloseButton ) {
-		ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarCloseButton ), widget );
+		ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarCloseButton, TQStyleOption::Default, widget ), ceData, elementFlags );
 		down = active & SC_TitleBarCloseButton;
 		if ( widget->testWFlags( WStyle_Tool )
 #ifndef QT_NO_MAINWINDOW
 		     || ::tqt_cast<TQDockWindow*>(widget)
 #endif
 		    )
-		    pm = stylePixmap(SP_DockWindowCloseButton, widget);
+		    pm = stylePixmap(SP_DockWindowCloseButton, ceData, elementFlags, TQStyleOption::Default, widget);
 		else
-		    pm = stylePixmap(SP_TitleBarCloseButton, widget);
-    		drawPrimitive(PE_ButtonTool, p, ir, titlebar->colorGroup(),
+		    pm = stylePixmap(SP_TitleBarCloseButton, ceData, elementFlags, TQStyleOption::Default, widget);
+    		drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, ir, ceData.colorGroup,
 			      down ? Style_Down : Style_Raised);
 
 		p->save();
 		if( down )
-		    p->translate( pixelMetric(PM_ButtonShiftHorizontal, widget),
-				  pixelMetric(PM_ButtonShiftVertical, widget) );
-		drawItem( p, ir, AlignCenter, titlebar->colorGroup(), TRUE, &pm, TQString::null );
+		    p->translate( pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget),
+				  pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget) );
+		drawItem( p, ir, AlignCenter, ceData.colorGroup, TRUE, &pm, TQString::null );
 		p->restore();
 	    }
 
-	    if ( titlebar->window() ) {
+	    if ( ceData.titleBarData.hasWindow ) {
 		if ( controls & SC_TitleBarMaxButton ) {
-		    ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarMaxButton ), widget );
+		    ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarMaxButton, TQStyleOption::Default, widget ), ceData, elementFlags );
 
 		    down = active & SC_TitleBarMaxButton;
-		    pm = TQPixmap(stylePixmap(SP_TitleBarMaxButton, widget));
-		    drawPrimitive(PE_ButtonTool, p, ir, titlebar->colorGroup(),
+		    pm = TQPixmap(stylePixmap(SP_TitleBarMaxButton, ceData, elementFlags, TQStyleOption::Default, widget));
+		    drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, ir, ceData.colorGroup,
 				  down ? Style_Down : Style_Raised);
 
 		    p->save();
 		    if( down )
-			p->translate( pixelMetric(PM_ButtonShiftHorizontal, widget),
-				      pixelMetric(PM_ButtonShiftVertical, widget) );
-    		    drawItem( p, ir, AlignCenter, titlebar->colorGroup(), TRUE, &pm, TQString::null );
+			p->translate( pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget),
+				      pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget) );
+    		    drawItem( p, ir, AlignCenter, ceData.colorGroup, TRUE, &pm, TQString::null );
 		    p->restore();
 		}
 
 		if ( controls & SC_TitleBarNormalButton || controls & SC_TitleBarMinButton ) {
-		    ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarMinButton ), widget );
+		    ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarMinButton, TQStyleOption::Default, widget ), ceData, elementFlags );
 		    TQStyle::SubControl ctrl = (controls & SC_TitleBarNormalButton ?
 					       SC_TitleBarNormalButton :
 					       SC_TitleBarMinButton);
@@ -1717,53 +2184,53 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 						   SP_TitleBarNormalButton :
 						   SP_TitleBarMinButton);
 		    down = active & ctrl;
-		    pm = TQPixmap(stylePixmap(spixmap, widget));
-		    drawPrimitive(PE_ButtonTool, p, ir, titlebar->colorGroup(),
+		    pm = TQPixmap(stylePixmap(spixmap, ceData, elementFlags, TQStyleOption::Default, widget));
+		    drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, ir, ceData.colorGroup,
 				  down ? Style_Down : Style_Raised);
 
 		    p->save();
 		    if( down )
-			p->translate( pixelMetric(PM_ButtonShiftHorizontal, widget),
-				      pixelMetric(PM_ButtonShiftVertical, widget) );
-		    drawItem( p, ir, AlignCenter, titlebar->colorGroup(), TRUE, &pm, TQString::null );
+			p->translate( pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget),
+				      pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget) );
+		    drawItem( p, ir, AlignCenter, ceData.colorGroup, TRUE, &pm, TQString::null );
 		    p->restore();
 		}
 
 		if ( controls & SC_TitleBarShadeButton ) {
-		    ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarShadeButton ), widget );
+		    ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarShadeButton, TQStyleOption::Default, widget ), ceData, elementFlags );
 
 		    down = active & SC_TitleBarShadeButton;
-		    pm = TQPixmap(stylePixmap(SP_TitleBarShadeButton, widget));
-		    drawPrimitive(PE_ButtonTool, p, ir, titlebar->colorGroup(),
+		    pm = TQPixmap(stylePixmap(SP_TitleBarShadeButton, ceData, elementFlags, TQStyleOption::Default, widget));
+		    drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, ir, ceData.colorGroup,
 				  down ? Style_Down : Style_Raised);
 		    p->save();
 		    if( down )
-			p->translate( pixelMetric(PM_ButtonShiftHorizontal, widget),
-				      pixelMetric(PM_ButtonShiftVertical, widget) );
-		    drawItem( p, ir, AlignCenter, titlebar->colorGroup(), TRUE, &pm, TQString::null );
+			p->translate( pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget),
+				      pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget) );
+		    drawItem( p, ir, AlignCenter, ceData.colorGroup, TRUE, &pm, TQString::null );
 		    p->restore();
 		}
 
 		if ( controls & SC_TitleBarUnshadeButton ) {
-		    ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarUnshadeButton ), widget );
+		    ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarUnshadeButton, TQStyleOption::Default, widget ), ceData, elementFlags );
 
 		    down = active & SC_TitleBarUnshadeButton;
-		    pm = TQPixmap(stylePixmap(SP_TitleBarUnshadeButton, widget));
-		    drawPrimitive(PE_ButtonTool, p, ir, titlebar->colorGroup(),
+		    pm = TQPixmap(stylePixmap(SP_TitleBarUnshadeButton, ceData, elementFlags, TQStyleOption::Default, widget));
+		    drawPrimitive(PE_ButtonTool, p, ceData, elementFlags, ir, ceData.colorGroup,
 				  down ? Style_Down : Style_Raised);
 		    p->save();
 		    if( down )
-			p->translate( pixelMetric(PM_ButtonShiftHorizontal, widget),
-				      pixelMetric(PM_ButtonShiftVertical, widget) );
-		    drawItem( p, ir, AlignCenter, titlebar->colorGroup(), TRUE, &pm, TQString::null );
+			p->translate( pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget),
+				      pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget) );
+		    drawItem( p, ir, AlignCenter, ceData.colorGroup, TRUE, &pm, TQString::null );
 		    p->restore();
 		}
 	    }
 #ifndef QT_NO_WIDGET_TOPEXTRA
 	    if ( controls & SC_TitleBarSysMenu ) {
-		if ( titlebar->icon() ) {
-		    ir = visualRect( querySubControlMetrics( CC_TitleBar, widget, SC_TitleBarSysMenu ), widget );
-		    drawItem( p, ir, AlignCenter, titlebar->colorGroup(), TRUE, titlebar->icon(), TQString::null );
+		if ( !ceData.icon.isNull() ) {
+		    ir = visualRect( querySubControlMetrics( CC_TitleBar, ceData, elementFlags, SC_TitleBarSysMenu, TQStyleOption::Default, widget ), ceData, elementFlags );
+		    drawItem( p, ir, AlignCenter, ceData.colorGroup, TRUE, (ceData.icon.isNull())?NULL:&ceData.icon, TQString::null );
 		}
 	    }
 #endif
@@ -1773,7 +2240,6 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 
     case CC_SpinWidget: {
 #ifndef QT_NO_SPINWIDGET
-	const TQSpinWidget * sw = (const TQSpinWidget *) widget;
 	SFlags flags;
 	PrimitiveElement pe;
 
@@ -1787,15 +2253,15 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 		flags |= Style_Sunken;
 	    } else
 		flags |= Style_Raised;
-	    if ( sw->buttonSymbols() == TQSpinWidget::PlusMinus )
+	    if ( ceData.spinWidgetData.buttonSymbols == TQSpinWidget::PlusMinus )
 		pe = PE_SpinWidgetPlus;
 	    else
 		pe = PE_SpinWidgetUp;
 
-	    TQRect re = sw->upRect();
-	    TQColorGroup ucg = sw->isUpEnabled() ? cg : sw->palette().disabled();
-	    drawPrimitive(PE_ButtonBevel, p, re, ucg, flags);
-	    drawPrimitive(pe, p, re, ucg, flags);
+	    TQRect re = ceData.spinWidgetData.upRect;
+	    TQColorGroup ucg = ceData.spinWidgetData.upEnabled ? cg : ceData.palette.disabled();
+	    drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, re, ucg, flags);
+	    drawPrimitive(pe, p, ceData, elementFlags, re, ucg, flags);
 	}
 
 	if ( controls & SC_SpinWidgetDown ) {
@@ -1805,15 +2271,15 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 		flags |= Style_Sunken;
 	    } else
 		flags |= Style_Raised;
-	    if ( sw->buttonSymbols() == TQSpinWidget::PlusMinus )
+	    if ( ceData.spinWidgetData.buttonSymbols == TQSpinWidget::PlusMinus )
 		pe = PE_SpinWidgetMinus;
 	    else
 		pe = PE_SpinWidgetDown;
 
-	    TQRect re = sw->downRect();
-	    TQColorGroup dcg = sw->isDownEnabled() ? cg : sw->palette().disabled();
-	    drawPrimitive(PE_ButtonBevel, p, re, dcg, flags);
-	    drawPrimitive(pe, p, re, dcg, flags);
+	    TQRect re = ceData.spinWidgetData.downRect;
+	    TQColorGroup dcg = ceData.spinWidgetData.downEnabled ? cg : ceData.palette.disabled();
+	    drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, re, dcg, flags);
+	    drawPrimitive(pe, p, ceData, elementFlags, re, dcg, flags);
 	}
 #endif
 	break; }
@@ -1822,19 +2288,18 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
     case CC_Slider:
 	switch ( controls ) {
 	case SC_SliderTickmarks: {
-	    const TQSlider * sl = (const TQSlider *) widget;
-	    int tickOffset = pixelMetric( PM_SliderTickmarkOffset, sl );
-	    int ticks = sl->tickmarks();
-	    int thickness = pixelMetric( PM_SliderControlThickness, sl );
-	    int len = pixelMetric( PM_SliderLength, sl );
-	    int available = pixelMetric( PM_SliderSpaceAvailable, sl );
-	    int interval = sl->tickInterval();
+	    int tickOffset = pixelMetric( PM_SliderTickmarkOffset, ceData, elementFlags, widget );
+	    int ticks = ceData.tickMarkSetting;
+	    int thickness = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
+	    int len = pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
+	    int available = pixelMetric( PM_SliderSpaceAvailable, ceData, elementFlags, widget );
+	    int interval = ceData.tickInterval;
 
 	    if ( interval <= 0 ) {
-		interval = sl->lineStep();
-		if ( qPositionFromValue( sl, interval, available ) -
-		     qPositionFromValue( sl, 0, available ) < 3 )
-		    interval = sl->pageStep();
+		interval = ceData.lineStep;
+		if ( qPositionFromValue( ceData, interval, available ) -
+		     qPositionFromValue( ceData, 0, available ) < 3 )
+		    interval = ceData.pageStep;
 	    }
 
 	    int fudge = len / 2;
@@ -1842,12 +2307,12 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 
 	    if ( ticks & TQSlider::Above ) {
 		p->setPen( cg.foreground() );
-		int v = sl->minValue();
+		int v = ceData.minSteps;
 		if ( !interval )
 		    interval = 1;
-		while ( v <= sl->maxValue() + 1 ) {
-		    pos = qPositionFromValue( sl, v, available ) + fudge;
-		    if ( sl->orientation() == Horizontal )
+		while ( v <= ceData.maxSteps + 1 ) {
+		    pos = qPositionFromValue( ceData, v, available ) + fudge;
+		    if ( ceData.orientation == Horizontal )
 			p->drawLine( pos, 0, pos, tickOffset-2 );
 		    else
 			p->drawLine( 0, pos, tickOffset-2, pos );
@@ -1857,12 +2322,12 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 
 	    if ( ticks & TQSlider::Below ) {
 		p->setPen( cg.foreground() );
-		int v = sl->minValue();
+		int v = ceData.minSteps;
 		if ( !interval )
 		    interval = 1;
-		while ( v <= sl->maxValue() + 1 ) {
-		    pos = qPositionFromValue( sl, v, available ) + fudge;
-		    if ( sl->orientation() == Horizontal )
+		while ( v <= ceData.maxSteps + 1 ) {
+		    pos = qPositionFromValue( ceData, v, available ) + fudge;
+		    if ( ceData.orientation == Horizontal )
 			p->drawLine( pos, tickOffset+thickness+1, pos,
 				     tickOffset+thickness+1 + available-2 );
 		    else
@@ -1881,8 +2346,7 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
 #ifndef QT_NO_LISTVIEW
     case CC_ListView:
 	if ( controls & SC_ListView ) {
-	    TQListView *listview = (TQListView*)widget;
-	    p->fillRect( r, listview->viewport()->backgroundBrush() );
+	    p->fillRect( r, ceData.viewportData.bgBrush );
 	}
 	break;
 #endif //QT_NO_LISTVIEW
@@ -1893,7 +2357,6 @@ void TQCommonStyle::drawComplexControl( ComplexControl control,
     activePainter = 0;
 }
 
-
 /*! \reimp */
 void TQCommonStyle::drawComplexControlMask( ComplexControl control,
 					   TQPainter *p,
@@ -1901,14 +2364,28 @@ void TQCommonStyle::drawComplexControlMask( ComplexControl control,
 					   const TQRect &r,
 					   const TQStyleOption& opt ) const
 {
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
+	drawComplexControlMask(control, p, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), r, opt, widget);
+}
+
+/*! \reimp */
+void TQCommonStyle::drawComplexControlMask( ComplexControl control,
+					   TQPainter *p,
+					   const TQStyleControlElementData ceData,
+					   const ControlElementFlags elementFlags,
+					   const TQRect &r,
+					   const TQStyleOption& opt,
+					   const TQWidget *widget ) const
+{
     Q_UNUSED(control);
+    Q_UNUSED(ceData);
+    Q_UNUSED(elementFlags);
     Q_UNUSED(widget);
     Q_UNUSED(opt);
 
     p->fillRect(r, color1);
 }
 
-
 /*! \reimp */
 TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
 					    const TQWidget *widget,
@@ -1916,24 +2393,36 @@ TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
 					    const TQStyleOption &opt ) const
 {
 #if defined(QT_CHECK_STATE)
-    if (! widget) {
-	tqWarning("TQCommonStyle::querySubControlMetrics: widget parameter cannot be zero!");
-	return TQRect();
-    }
+	if (! widget) {
+		tqWarning("TQCommonStyle::querySubControlMetrics: widget parameter cannot be zero!");
+		return TQRect();
+	}
 #endif
 
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption(), false);
+	return querySubControlMetrics(control, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), sc, opt, widget);
+}
+
+/*! \reimp */
+TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
+					    TQStyleControlElementData ceData,
+					    ControlElementFlags elementFlags,
+					    SubControl sc,
+					    const TQStyleOption &opt,
+					    const TQWidget *widget ) const
+{
     switch ( control ) {
     case CC_SpinWidget: {
-	int fw = pixelMetric( PM_SpinBoxFrameWidth, widget);
+	int fw = pixelMetric( PM_SpinBoxFrameWidth, ceData, elementFlags, widget);
 	TQSize bs;
-	bs.setHeight( widget->height()/2 - fw );
+	bs.setHeight( ceData.rect.height()/2 - fw );
 	if ( bs.height() < 8 )
 	    bs.setHeight( 8 );
-	bs.setWidth( TQMIN( bs.height() * 8 / 5, widget->width() / 4 ) ); // 1.6 -approximate golden mean
+	bs.setWidth( TQMIN( bs.height() * 8 / 5, ceData.rect.width() / 4 ) ); // 1.6 -approximate golden mean
 	bs = bs.expandedTo( TQApplication::globalStrut() );
 	int y = fw;
 	int x, lx, rx;
-	x = widget->width() - y - bs.width();
+	x = ceData.rect.width() - y - bs.width();
 	lx = fw;
 	rx = x - fw;
 	switch ( sc ) {
@@ -1942,24 +2431,24 @@ TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
 	case SC_SpinWidgetDown:
 	    return TQRect(x, y + bs.height(), bs.width(), bs.height());
 	case SC_SpinWidgetButtonField:
-	    return TQRect(x, y, bs.width(), widget->height() - 2*fw);
+	    return TQRect(x, y, bs.width(), ceData.rect.height() - 2*fw);
 	case SC_SpinWidgetEditField:
-	    return TQRect(lx, fw, rx, widget->height() - 2*fw);
+	    return TQRect(lx, fw, rx, ceData.rect.height() - 2*fw);
 	case SC_SpinWidgetFrame:
-	    return widget->rect();
+	    return ceData.rect;
 	default:
 	    break;
 	}
 	break; }
 
     case CC_ComboBox: {
-	int x = 0, y = 0, wi = widget->width(), he = widget->height();
+	int x = 0, y = 0, wi = ceData.rect.width(), he = ceData.rect.height();
 	int xpos = x;
 	xpos += wi - 2 - 16;
 
 	switch ( sc ) {
 	case SC_ComboBoxFrame:
-	    return widget->rect();
+	    return ceData.rect;
 	case SC_ComboBoxArrow:
 	    return TQRect(xpos, y+2, 16, he-4);
 	case SC_ComboBoxEditField:
@@ -1973,21 +2462,20 @@ TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
 
 #ifndef QT_NO_SCROLLBAR
     case CC_ScrollBar: {
-	const TQScrollBar *scrollbar = (const TQScrollBar *) widget;
 	int sliderstart = 0;
-	int sbextent = pixelMetric(PM_ScrollBarExtent, widget);
-	int maxlen = ((scrollbar->orientation() == TQt::Horizontal) ?
-		      scrollbar->width() : scrollbar->height()) - (sbextent * 2);
+	int sbextent = pixelMetric(PM_ScrollBarExtent, ceData, elementFlags, widget);
+	int maxlen = ((ceData.orientation == TQt::Horizontal) ?
+		      ceData.rect.width() : ceData.rect.height()) - (sbextent * 2);
 	int sliderlen;
 
-	sliderstart = scrollbar->sliderStart();
+	sliderstart = ceData.startStep;
 
 	// calculate slider length
-	if (scrollbar->maxValue() != scrollbar->minValue()) {
-	    uint range = scrollbar->maxValue() - scrollbar->minValue();
-	    sliderlen = (TQ_LLONG(scrollbar->pageStep()) * maxlen) / (range + scrollbar->pageStep());
+	if (ceData.maxSteps != ceData.minSteps) {
+	    uint range = ceData.maxSteps - ceData.minSteps;
+	    sliderlen = (TQ_LLONG(ceData.pageStep) * maxlen) / (range + ceData.pageStep);
 
-	    int slidermin = pixelMetric( PM_ScrollBarSliderMin, widget );
+	    int slidermin = pixelMetric( PM_ScrollBarSliderMin, ceData, elementFlags, widget );
 	    if ( sliderlen < slidermin || range > INT_MAX / 2 )
 		sliderlen = slidermin;
 	    if ( sliderlen > maxlen )
@@ -1997,44 +2485,44 @@ TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
 
 	switch (sc) {
 	case SC_ScrollBarSubLine:	    // top/left button
-	    if (scrollbar->orientation() == TQt::Horizontal) {
-		int buttonWidth = TQMIN(scrollbar->width()/2, sbextent);
+	    if (ceData.orientation == TQt::Horizontal) {
+		int buttonWidth = TQMIN(ceData.rect.width()/2, sbextent);
 		return TQRect( 0, 0, buttonWidth, sbextent );
 	    } else {
-		int buttonHeight = TQMIN(scrollbar->height()/2, sbextent);
+		int buttonHeight = TQMIN(ceData.rect.height()/2, sbextent);
 		return TQRect( 0, 0, sbextent, buttonHeight );
 	    }
 
 	case SC_ScrollBarAddLine:	    // bottom/right button
-	    if (scrollbar->orientation() == TQt::Horizontal) {
-		int buttonWidth = TQMIN(scrollbar->width()/2, sbextent);
-		return TQRect( scrollbar->width() - buttonWidth, 0, buttonWidth, sbextent );
+	    if (ceData.orientation == TQt::Horizontal) {
+		int buttonWidth = TQMIN(ceData.rect.width()/2, sbextent);
+		return TQRect( ceData.rect.width() - buttonWidth, 0, buttonWidth, sbextent );
 	    } else {
-		int buttonHeight = TQMIN(scrollbar->height()/2, sbextent);
-		return TQRect( 0, scrollbar->height() - buttonHeight, sbextent, buttonHeight );
+		int buttonHeight = TQMIN(ceData.rect.height()/2, sbextent);
+		return TQRect( 0, ceData.rect.height() - buttonHeight, sbextent, buttonHeight );
 	    }
 
 	case SC_ScrollBarSubPage:	    // between top/left button and slider
-	    if (scrollbar->orientation() == TQt::Horizontal)
+	    if (ceData.orientation == TQt::Horizontal)
 		return TQRect(sbextent, 0, sliderstart - sbextent, sbextent);
 	    return TQRect(0, sbextent, sbextent, sliderstart - sbextent);
 
 	case SC_ScrollBarAddPage:	    // between bottom/right button and slider
-	    if (scrollbar->orientation() == TQt::Horizontal)
+	    if (ceData.orientation == TQt::Horizontal)
 		return TQRect(sliderstart + sliderlen, 0,
 			     maxlen - sliderstart - sliderlen + sbextent, sbextent);
 	    return TQRect(0, sliderstart + sliderlen,
 			 sbextent, maxlen - sliderstart - sliderlen + sbextent);
 
 	case SC_ScrollBarGroove:
-	    if (scrollbar->orientation() == TQt::Horizontal)
-		return TQRect(sbextent, 0, scrollbar->width() - sbextent * 2,
-			     scrollbar->height());
-	    return TQRect(0, sbextent, scrollbar->width(),
-			 scrollbar->height() - sbextent * 2);
+	    if (ceData.orientation == TQt::Horizontal)
+		return TQRect(sbextent, 0, ceData.rect.width() - sbextent * 2,
+			     ceData.rect.height());
+	    return TQRect(0, sbextent, ceData.rect.width(),
+			 ceData.rect.height() - sbextent * 2);
 
 	case SC_ScrollBarSlider:
-	    if (scrollbar->orientation() == TQt::Horizontal)
+	    if (ceData.orientation == TQt::Horizontal)
 		return TQRect(sliderstart, 0, sliderlen, sbextent);
 	    return TQRect(0, sliderstart, sbextent, sliderlen);
 
@@ -2046,24 +2534,23 @@ TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
 
 #ifndef QT_NO_SLIDER
     case CC_Slider: {
-	    const TQSlider * sl = (const TQSlider *) widget;
-	    int tickOffset = pixelMetric( PM_SliderTickmarkOffset, sl );
-	    int thickness = pixelMetric( PM_SliderControlThickness, sl );
+	    int tickOffset = pixelMetric( PM_SliderTickmarkOffset, ceData, elementFlags, widget );
+	    int thickness = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
 
 	    switch ( sc ) {
 	    case SC_SliderHandle: {
 		    int sliderPos = 0;
-		    int len   = pixelMetric( PM_SliderLength, sl );
+		    int len   = pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
 
-		    sliderPos = sl->sliderStart();
+		    sliderPos = ceData.startStep;
 
-		    if ( sl->orientation() == Horizontal )
+		    if ( ceData.orientation == Horizontal )
 			return TQRect( sliderPos, tickOffset, len, thickness );
 		    return TQRect( tickOffset, sliderPos, thickness, len ); }
 	    case SC_SliderGroove: {
-		if ( sl->orientation() == Horizontal )
-		    return TQRect( 0, tickOffset, sl->width(), thickness );
-		return TQRect( tickOffset, 0, thickness, sl->height() );	}
+		if ( ceData.orientation == Horizontal )
+		    return TQRect( 0, tickOffset, ceData.rect.width(), thickness );
+		return TQRect( tickOffset, 0, thickness, ceData.rect.height() );	}
 
 	    default:
 		break;
@@ -2073,18 +2560,17 @@ TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
 
 #if !defined(QT_NO_TOOLBUTTON) && !defined(QT_NO_POPUPMENU)
     case CC_ToolButton: {
-	    const TQToolButton *toolbutton = (const TQToolButton *) widget;
-	    int mbi = pixelMetric(PM_MenuButtonIndicator, widget);
+	    int mbi = pixelMetric(PM_MenuButtonIndicator, ceData, elementFlags, widget);
 
-	    TQRect rect = toolbutton->rect();
+	    TQRect rect = ceData.rect;
 	    switch (sc) {
 	    case SC_ToolButton:
-		if (toolbutton->popup() && ! toolbutton->popupDelay())
+		if ((elementFlags & CEF_HasPopupMenu) && ! ceData.popupDelay)
 		    rect.addCoords(0, 0, -mbi, 0);
 		return rect;
 
 	    case SC_ToolButtonMenu:
-		if (toolbutton->popup() && ! toolbutton->popupDelay())
+		if ((elementFlags & CEF_HasPopupMenu) && ! ceData.popupDelay)
 		    rect.addCoords(rect.width() - mbi, 0, 0, 0);
 		return rect;
 
@@ -2096,47 +2582,45 @@ TQRect TQCommonStyle::querySubControlMetrics( ComplexControl control,
 
 #ifndef QT_NO_TITLEBAR
     case CC_TitleBar: {
-	    const TQTitleBar *titlebar = (const TQTitleBar *) widget;
 	    const int controlTop = 2;
-	    const int controlHeight = widget->height() - controlTop * 2;
+	    const int controlHeight = ceData.rect.height() - controlTop * 2;
 
 	    switch (sc) {
 	    case SC_TitleBarLabel: {
-		const TQTitleBar *titlebar = (TQTitleBar*)widget;
-		TQRect ir( 0, 0, titlebar->width(), titlebar->height() );
-		if ( titlebar->testWFlags( WStyle_Tool ) ) {
-		    if ( titlebar->testWFlags( WStyle_SysMenu ) )
+		TQRect ir( 0, 0, ceData.rect.width(), ceData.rect.height() );
+		if ( ceData.wflags & WStyle_Tool ) {
+		    if ( ceData.wflags & WStyle_SysMenu )
 			ir.addCoords( 0, 0, -controlHeight-3, 0 );
-		    if ( titlebar->testWFlags( WStyle_MinMax ) )
+		    if ( ceData.wflags & WStyle_MinMax )
 			ir.addCoords( 0, 0, -controlHeight-2, 0 );
 		} else {
-		    if ( titlebar->testWFlags( WStyle_SysMenu ) )
+		    if ( ceData.wflags & WStyle_SysMenu )
 			ir.addCoords( controlHeight+3, 0, -controlHeight-3, 0 );
-		    if ( titlebar->testWFlags( WStyle_Minimize ) )
+		    if ( ceData.wflags & WStyle_Minimize )
 			ir.addCoords( 0, 0, -controlHeight-2, 0 );
-		    if ( titlebar->testWFlags( WStyle_Maximize ) )
+		    if ( ceData.wflags & WStyle_Maximize )
 			ir.addCoords( 0, 0, -controlHeight-2, 0 );
 		}
 		return ir; }
 
 	    case SC_TitleBarCloseButton:
-		return TQRect( titlebar->width() - ( controlHeight + controlTop ),
+		return TQRect( ceData.rect.width() - ( controlHeight + controlTop ),
 			      controlTop, controlHeight, controlHeight );
 
 	    case SC_TitleBarMaxButton:
 	    case SC_TitleBarShadeButton:
 	    case SC_TitleBarUnshadeButton:
-		return TQRect( titlebar->width() - ( ( controlHeight + controlTop ) * 2 ),
+		return TQRect( ceData.rect.width() - ( ( controlHeight + controlTop ) * 2 ),
 			      controlTop, controlHeight, controlHeight );
 
 	    case SC_TitleBarMinButton:
 	    case SC_TitleBarNormalButton: {
 		int offset = controlHeight + controlTop;
-		if ( !titlebar->testWFlags( WStyle_Maximize ) )
+		if ( !( ceData.wflags & WStyle_Maximize ) )
 		    offset *= 2;
 		else
 		    offset *= 3;
-		return TQRect( titlebar->width() - offset, controlTop, controlHeight, controlHeight );
+		return TQRect( ceData.rect.width() - offset, controlTop, controlHeight, controlHeight );
 	    }
 
 	    case SC_TitleBarSysMenu:
@@ -2160,6 +2644,18 @@ TQStyle::SubControl TQCommonStyle::querySubControl(ComplexControl control,
 						 const TQPoint &pos,
 						 const TQStyleOption& opt ) const
 {
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, opt);
+	return querySubControl(control, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, opt), pos, opt, widget);
+}
+
+/*! \reimp */
+TQStyle::SubControl TQCommonStyle::querySubControl(ComplexControl control,
+						 TQStyleControlElementData ceData,
+						 ControlElementFlags elementFlags,
+						 const TQPoint &pos,
+						 const TQStyleOption& opt,
+						 const TQWidget *widget ) const
+{
     SubControl ret = SC_None;
 
     switch (control) {
@@ -2180,8 +2676,8 @@ TQStyle::SubControl TQCommonStyle::querySubControl(ComplexControl control,
 
 	    // we can do this because subcontrols were designed to be masks as well...
 	    while (ret == SC_None && ctrl <= SC_ScrollBarGroove) {
-		r = querySubControlMetrics(control, widget,
-					   (TQStyle::SubControl) ctrl, opt);
+		r = querySubControlMetrics(control, ceData, elementFlags,
+					   (TQStyle::SubControl) ctrl, opt, widget);
 		if (r.isValid() && r.contains(pos))
 		    ret = (TQStyle::SubControl) ctrl;
 
@@ -2194,27 +2690,26 @@ TQStyle::SubControl TQCommonStyle::querySubControl(ComplexControl control,
     case CC_TitleBar:
 	{
 #ifndef QT_NO_TITLEBAR
-	    const TQTitleBar *titlebar = (TQTitleBar*)widget;
 	    TQRect r;
 	    uint ctrl = SC_TitleBarLabel;
 
 	    // we can do this because subcontrols were designed to be masks as well...
 	    while (ret == SC_None && ctrl <= SC_TitleBarUnshadeButton) {
-		r = visualRect( querySubControlMetrics( control, widget, (TQStyle::SubControl) ctrl, opt ), widget );
+		r = visualRect( querySubControlMetrics( control, ceData, elementFlags, (TQStyle::SubControl) ctrl, opt, widget ), ceData, elementFlags );
 		if (r.isValid() && r.contains(pos))
 		    ret = (TQStyle::SubControl) ctrl;
 
 		ctrl <<= 1;
 	    }
-	    if ( titlebar->window() ) {
-		if (titlebar->testWFlags( WStyle_Tool )) {
+	    if ( ceData.titleBarData.hasWindow ) {
+		if ( ceData.wflags & WStyle_Tool ) {
 		    if ( ret == SC_TitleBarMinButton || ret == SC_TitleBarMaxButton ) {
-			if ( titlebar->window()->isMinimized() )
+			if ( ceData.titleBarData.windowState & WindowMinimized )
 			    ret = SC_TitleBarUnshadeButton;
 			else
 			    ret = SC_TitleBarShadeButton;
 		    }
-		} else if ( ret == SC_TitleBarMinButton && titlebar->window()->isMinimized() ) {
+		} else if ( ret == SC_TitleBarMinButton && (ceData.titleBarData.windowState & WindowMinimized) ) {
 			ret = TQStyle::SC_TitleBarNormalButton;
 		}
 	    }
@@ -2233,6 +2728,13 @@ TQStyle::SubControl TQCommonStyle::querySubControl(ComplexControl control,
 /*! \reimp */
 int TQCommonStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 {
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
+	return pixelMetric(m, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), widget);
+}
+
+/*! \reimp */
+int TQCommonStyle::pixelMetric(PixelMetric m, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget) const
+{
     int ret;
 
     switch (m) {
@@ -2250,20 +2752,17 @@ int TQCommonStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 	ret = 16;
 	break;
     case PM_TitleBarHeight: {
-	if ( widget ) {
-	    if ( widget->testWFlags( WStyle_Tool ) ) {
-		ret = TQMAX( widget->fontMetrics().lineSpacing(), 16 );
+        if ( !(elementFlags & CEF_UseGenericParameters) ) {
+	    if ( ceData.wflags & WStyle_Tool ) {
+		ret = TQMAX( TQFontMetrics(ceData.font).lineSpacing(), 16 );
 #ifndef QT_NO_MAINWINDOW
-	    } else if ( ::tqt_cast<TQDockWindow*>(widget) ) {
-		ret = TQMAX( widget->fontMetrics().lineSpacing(), 13 );
+	    } else if ( ceData.widgetObjectTypes.contains("TQDockWindow") ) {
+		ret = TQMAX( TQFontMetrics(ceData.font).lineSpacing(), 13 );
 #endif
 	    } else {
-		ret = TQMAX( widget->fontMetrics().lineSpacing(), 18 );
+		ret = TQMAX( TQFontMetrics(ceData.font).lineSpacing(), 18 );
 	    }
-	} else {
-	    ret = 0;
 	}
-
 	break; }
     case PM_ScrollBarSliderMin:
 	ret = 9;
@@ -2278,10 +2777,10 @@ int TQCommonStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 	break;
 
     case PM_MenuButtonIndicator:
-	if (! widget)
+	if ( elementFlags & CEF_UseGenericParameters )
 	    ret = 12;
 	else
-	    ret = TQMAX(12, (widget->height() - 4) / 3);
+	    ret = TQMAX(12, (ceData.rect.height() - 4) / 3);
 	break;
 
     case PM_ButtonShiftHorizontal:
@@ -2304,11 +2803,10 @@ int TQCommonStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 
 #ifndef QT_NO_SCROLLBAR
     case PM_ScrollBarExtent:
-	if ( !widget ) {
+	if ( elementFlags & CEF_UseGenericParameters ) {
 	    ret = 16;
 	} else {
-	    const TQScrollBar *bar = (const TQScrollBar*)widget;
-	    int s = bar->orientation() == TQt::Horizontal ?
+	    int s = ceData.orientation == TQt::Horizontal ?
 		    TQApplication::globalStrut().height()
 		    : TQApplication::globalStrut().width();
 	    ret = TQMAX( 16, s );
@@ -2326,16 +2824,15 @@ int TQCommonStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 
     case PM_SliderTickmarkOffset:
 	{
-	    if (! widget) {
+	    if ( elementFlags & CEF_UseGenericParameters ) {
 		ret = 0;
 		break;
 	    }
 
-	    const TQSlider * sl = (const TQSlider *) widget;
-	    int space = (sl->orientation() == Horizontal) ? sl->height() :
-			sl->width();
-	    int thickness = pixelMetric( PM_SliderControlThickness, sl );
-	    int ticks = sl->tickmarks();
+	    int space = (ceData.orientation == Horizontal) ? ceData.rect.height() :
+			ceData.rect.width();
+	    int thickness = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
+	    int ticks = ceData.tickMarkSetting;
 
 	    if ( ticks == TQSlider::Both )
 		ret = (space - thickness) / 2;
@@ -2348,11 +2845,10 @@ int TQCommonStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 
     case PM_SliderSpaceAvailable:
 	{
-	    const TQSlider * sl = (const TQSlider *) widget;
-	    if ( sl->orientation() == Horizontal )
-		ret = sl->width() - pixelMetric( PM_SliderLength, sl );
+	    if ( ceData.orientation == Horizontal )
+		ret = ceData.rect.width() - pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
 	    else
-		ret = sl->height() - pixelMetric( PM_SliderLength, sl );
+		ret = ceData.rect.height() - pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
 	    break;
 	}
 #endif // QT_NO_SLIDER
@@ -2402,9 +2898,8 @@ int TQCommonStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
 #ifndef QT_NO_TABBAR
     case PM_TabBarTabVSpace:
 	{
-	    const TQTabBar * tb = (const TQTabBar *) widget;
-	    if ( tb && ( tb->shape() == TQTabBar::RoundedAbove ||
-			 tb->shape() == TQTabBar::RoundedBelow ) )
+	    if ( ceData.widgetObjectTypes.contains("TQTabBar") && ( ceData.tabBarData.shape == TQTabBar::RoundedAbove ||
+			 ceData.tabBarData.shape == TQTabBar::RoundedBelow ) )
 		ret = 10;
 	    else
 		ret = 0;
@@ -2457,31 +2952,43 @@ int TQCommonStyle::pixelMetric(PixelMetric m, const TQWidget *widget) const
     return ret;
 }
 
-
 /*! \reimp */
 TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
 				     const TQWidget *widget,
 				     const TQSize &contentsSize,
 				     const TQStyleOption& opt ) const
 {
-    TQSize sz(contentsSize);
+	TQSize sz(contentsSize);
 
 #if defined(QT_CHECK_STATE)
-    if (! widget) {
-	tqWarning("TQCommonStyle::sizeFromContents: widget parameter cannot be zero!");
-	return sz;
-    }
+	if (! widget) {
+		tqWarning("TQCommonStyle::sizeFromContents: widget parameter cannot be zero!");
+		return sz;
+	}
 #endif
 
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(widget, TQStyleOption());
+	return sizeFromContents(contents, ceData, getControlElementFlagsForObject(widget, ceData.widgetObjectTypes, TQStyleOption()), contentsSize, opt, widget);
+}
+
+/*! \reimp */
+TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
+				     TQStyleControlElementData ceData,
+				     ControlElementFlags elementFlags,
+				     const TQSize &contentsSize,
+				     const TQStyleOption& opt,
+				     const TQWidget *widget ) const
+{
+    TQSize sz(contentsSize);
+
     switch (contents) {
 #ifndef QT_NO_DIALOGBUTTONS
     case CT_DialogButtons: {
-	const TQDialogButtons *dbtns = (const TQDialogButtons *)widget;
 	int w = contentsSize.width(), h = contentsSize.height();
-	const int bwidth = pixelMetric(PM_DialogButtonsButtonWidth, widget),
-		  bspace = pixelMetric(PM_DialogButtonsSeparator, widget),
-		 bheight = pixelMetric(PM_DialogButtonsButtonHeight, widget);
-	if(dbtns->orientation() == Horizontal) {
+	const int bwidth = pixelMetric(PM_DialogButtonsButtonWidth, ceData, elementFlags, widget),
+		  bspace = pixelMetric(PM_DialogButtonsSeparator, ceData, elementFlags, widget),
+		 bheight = pixelMetric(PM_DialogButtonsButtonHeight, ceData, elementFlags, widget);
+	if(ceData.orientation == Horizontal) {
 	    if(!w)
 		w = bwidth;
 	} else {
@@ -2492,10 +2999,10 @@ TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
 					  TQDialogButtons::Apply, TQDialogButtons::Retry, TQDialogButtons::Ignore, TQDialogButtons::Abort,
 					  TQDialogButtons::Help };
 	for(unsigned int i = 0, cnt = 0; i < (sizeof(btns)/sizeof(btns[0])); i++) {
-	    if(dbtns->isButtonVisible(btns[i])) {
-		TQSize szH = dbtns->sizeHint(btns[i]);
+	    if (ceData.dlgVisibleButtons & btns[i]) {
+		TQSize szH = ceData.dlgVisibleSizeHints[btns[i]];
 		int mwidth = TQMAX(bwidth, szH.width()), mheight = TQMAX(bheight, szH.height());
-		if(dbtns->orientation() == Horizontal)
+		if(ceData.orientation == Horizontal)
 		    h = TQMAX(h, mheight);
 		else
 		    w = TQMAX(w, mwidth);
@@ -2503,30 +3010,29 @@ TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
 		if(cnt)
 		    w += bspace;
 		cnt++;
-		if(dbtns->orientation() == Horizontal)
+		if(ceData.orientation == Horizontal)
 		    w += mwidth;
 		else
 		    h += mheight;
 	    }
 	}
-	const int fw = pixelMetric(PM_DefaultFrameWidth, widget) * 2;
+	const int fw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) * 2;
 	sz = TQSize(w + fw, h + fw);
 	break; }
 #endif //QT_NO_DIALOGBUTTONS
     case CT_PushButton:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
 	    int w = contentsSize.width(),
 		h = contentsSize.height(),
-	       bm = pixelMetric(PM_ButtonMargin, widget),
-	       fw = pixelMetric(PM_DefaultFrameWidth, widget) * 2;
+	       bm = pixelMetric(PM_ButtonMargin, ceData, elementFlags, widget),
+	       fw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) * 2;
 
 	    w += bm + fw;
 	    h += bm + fw;
 
-	    if (button->isDefault() || button->autoDefault()) {
-		int dbw = pixelMetric(PM_ButtonDefaultIndicator, widget) * 2;
+	    if ((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault)) {
+		int dbw = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget) * 2;
 		w += dbw;
 		h += dbw;
 	    }
@@ -2539,10 +3045,9 @@ TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
     case CT_CheckBox:
 	{
 #ifndef QT_NO_CHECKBOX
-	    const TQCheckBox *checkbox = (const TQCheckBox *) widget;
-	    TQRect irect = subRect(SR_CheckBoxIndicator, widget);
-	    int h = pixelMetric( PM_IndicatorHeight, widget );
-	    int margins = (!checkbox->pixmap() && checkbox->text().isEmpty()) ? 0 : 10;
+	    TQRect irect = subRect(SR_CheckBoxIndicator, ceData, elementFlags, widget);
+	    int h = pixelMetric( PM_IndicatorHeight, ceData, elementFlags, widget );
+	    int margins = (ceData.fgPixmap.isNull() && ceData.text.isEmpty()) ? 0 : 10;
 	    sz += TQSize(irect.right() + margins, 4 );
 	    sz.setHeight( TQMAX( sz.height(), h ) );
 #endif
@@ -2552,10 +3057,9 @@ TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
     case CT_RadioButton:
 	{
 #ifndef QT_NO_RADIOBUTTON
-	    const TQRadioButton *radiobutton = (const TQRadioButton *) widget;
-	    TQRect irect = subRect(SR_RadioButtonIndicator, widget);
-	    int h = pixelMetric( PM_ExclusiveIndicatorHeight, widget );
-	    int margins = (!radiobutton->pixmap() && radiobutton->text().isEmpty()) ? 0 : 10;
+	    TQRect irect = subRect(SR_RadioButtonIndicator, ceData, elementFlags, widget);
+	    int h = pixelMetric( PM_ExclusiveIndicatorHeight, ceData, elementFlags, widget );
+	    int margins = (ceData.fgPixmap.isNull() && ceData.text.isEmpty()) ? 0 : 10;
 	    sz += TQSize(irect.right() + margins, 4 );
 	    sz.setHeight( TQMAX( sz.height(), h ) );
 #endif
@@ -2570,7 +3074,7 @@ TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
 
     case CT_ComboBox:
 	{
-	    int dfw = pixelMetric(PM_DefaultFrameWidth, widget) * 2;
+	    int dfw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget) * 2;
 	    sz = TQSize(sz.width() + dfw + 21, sz.height() + dfw );
 	    break;
 	}
@@ -2581,8 +3085,7 @@ TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
 	    if (opt.isDefault())
 		break;
 
-	    const TQPopupMenu *popup = (const TQPopupMenu *) widget;
-	    bool checkable = popup->isCheckable();
+	    bool checkable = (elementFlags & CEF_IsCheckable);
 	    TQMenuItem *mi = opt.menuItem();
 	    int maxpmw = opt.maxIconWidth();
 	    int w = sz.width(), h = sz.height();
@@ -2600,7 +3103,7 @@ TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
 		if (mi->pixmap())
 		    h = TQMAX(h, mi->pixmap()->height() + 4);
 		else
-		    h = TQMAX(h, popup->fontMetrics().height() + 8);
+		    h = TQMAX(h, TQFontMetrics(ceData.font).height() + 8);
 
 		if (mi->iconSet() != 0)
 		    h = TQMAX(h, mi->iconSet()->pixmap(TQIconSet::Small,
@@ -2639,10 +3142,18 @@ TQSize TQCommonStyle::sizeFromContents(ContentsType contents,
     return sz;
 }
 
+/*! \reimp */
+int TQCommonStyle::styleHint(StyleHint sh, const TQWidget * w, const TQStyleOption &so, TQStyleHintReturn *shr) const
+{
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(w, TQStyleOption(), false);
+	return styleHint(sh, ceData, getControlElementFlagsForObject(w, ceData.widgetObjectTypes, TQStyleOption(), false), so, shr, w);
+}
 
 /*! \reimp */
-int TQCommonStyle::styleHint(StyleHint sh, const TQWidget * w, const TQStyleOption &, TQStyleHintReturn *) const
+int TQCommonStyle::styleHint(StyleHint sh, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQStyleOption &, TQStyleHintReturn *, const TQWidget * w) const
 {
+    Q_UNUSED(w);
+
     int ret;
 
     switch (sh) {
@@ -2656,7 +3167,7 @@ int TQCommonStyle::styleHint(StyleHint sh, const TQWidget * w, const TQStyleOpti
 	break;
 
     case SH_GroupBox_TextLabelColor:
-	ret = (int) ( w ? w->paletteForegroundColor().rgb() : 0 );
+	ret = (int) ( (!(elementFlags & CEF_UseGenericParameters)) ? ceData.fgColor.rgb() : 0 );
 	break;
 
     case SH_ListViewExpand_SelectMouseType:
@@ -2709,6 +3220,10 @@ int TQCommonStyle::styleHint(StyleHint sh, const TQWidget * w, const TQStyleOpti
 	ret = 1;
 	break;
 
+    case SH_HideUnderlineAcceleratorWhenAltUp:
+	ret = 0;
+	break;
+
     default:
 	ret = 0;
 	break;
@@ -2718,10 +3233,16 @@ int TQCommonStyle::styleHint(StyleHint sh, const TQWidget * w, const TQStyleOpti
 }
 
 /*! \reimp */
-TQPixmap TQCommonStyle::stylePixmap(StylePixmap, const TQWidget *, const TQStyleOption&) const
+TQPixmap TQCommonStyle::stylePixmap(StylePixmap sp, const TQWidget *w, const TQStyleOption &so) const
 {
-    return TQPixmap();
+	TQStyleControlElementData ceData = populateControlElementDataFromWidget(w, TQStyleOption());
+	return stylePixmap(sp, ceData, getControlElementFlagsForObject(w, ceData.widgetObjectTypes, TQStyleOption()), so, w);
 }
 
+/*! \reimp */
+TQPixmap TQCommonStyle::stylePixmap(StylePixmap, TQStyleControlElementData, ControlElementFlags, const TQStyleOption&, const TQWidget *) const
+{
+    return TQPixmap();
+}
 
 #endif // QT_NO_STYLE
diff --git a/src/styles/qcompactstyle.cpp b/src/styles/qcompactstyle.cpp
index 7dc0ab37..97f6aca8 100644
--- a/src/styles/qcompactstyle.cpp
+++ b/src/styles/qcompactstyle.cpp
@@ -55,7 +55,7 @@ TQCompactStyle::TQCompactStyle()
 }
 
 /*! \reimp */
-int TQCompactStyle::pixelMetric( PixelMetric metric, const TQWidget *widget )
+int TQCompactStyle::pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget )
 {
     int ret;
     switch ( metric ) {
@@ -68,7 +68,7 @@ int TQCompactStyle::pixelMetric( PixelMetric metric, const TQWidget *widget )
 	ret = -1;
 	break;
     default:
-	ret = TQWindowsStyle::pixelMetric( metric, widget );
+	ret = TQWindowsStyle::pixelMetric( metric, ceData, elementFlags, widget );
 	break;
     }
     return ret;
@@ -143,16 +143,15 @@ void drawPopupMenuItem( TQPainter* p, bool checkable,
 }
 
 /*! \reimp */
-void TQCompactStyle::drawControl( ControlElement element, TQPainter *p, const TQWidget *widget, const TQRect &r,
-		  const TQColorGroup &g, SFlags flags, const TQStyleOption& opt )
+void TQCompactStyle::drawControl( ControlElement element, TQPainter *p, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQRect &r,
+		  const TQColorGroup &g, SFlags flags, const TQStyleOption& opt, const TQWidget *widget )
 {
     switch ( element ) {
     case CE_PopupMenuItem:
 	{
-	    if (! widget || opt.isDefault())
+	    if (! (elementFlags & CEF_HasWidget) || opt.isDefault())
 		break;
 
-	    const TQPopupMenu *popupmenu = (const TQPopupMenu *) widget;
 	    TQMenuItem *mi = opt.menuItem();
 	    if ( !mi )
 		break;
@@ -160,7 +159,7 @@ void TQCompactStyle::drawControl( ControlElement element, TQPainter *p, const TQ
 	    int tab = opt.tabWidth();
 	    int maxpmw = opt.maxIconWidth();
 	    bool dis = !(flags & Style_Enabled);
-	    bool checkable = popupmenu->isCheckable();
+	    bool checkable = (elementFlags & CEF_IsCheckable);
 	    bool act = flags & Style_Active;
 	    int x, y, w, h;
 	    r.rect( &x, &y, &w, &h );
@@ -313,7 +312,7 @@ void TQCompactStyle::drawControl( ControlElement element, TQPainter *p, const TQ
 	break;
 
     default:
-	TQWindowsStyle::drawControl( element, p, widget, r, g, flags, opt );
+	TQWindowsStyle::drawControl( element, p, ceData, elementFlags, r, g, flags, opt, widget );
 	break;
     }
 }
diff --git a/src/styles/qmotifplusstyle.cpp b/src/styles/qmotifplusstyle.cpp
index 36358792..2ad7e7f5 100644
--- a/src/styles/qmotifplusstyle.cpp
+++ b/src/styles/qmotifplusstyle.cpp
@@ -69,7 +69,9 @@ struct TQMotifPlusStylePrivate
           scrollbarElement(0), lastElement(0), ref(1)
     { ; }
 
-    TQGuardedPtr<TQWidget> hoverWidget;
+    void* hoverWidget;
+    TQStyleControlElementData hoverWidgetData;
+    TQStyle::ControlElementFlags hoverWidgetFlags;
     bool hovering, sliderActive, mousePressed;
     int scrollbarElement, lastElement, ref;
     TQPoint mousePos;
@@ -176,58 +178,64 @@ void TQMotifPlusStyle::polish(TQPalette &)
 
 
 /*! \reimp */
-void TQMotifPlusStyle::polish(TQWidget *widget)
+void TQMotifPlusStyle::polish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr)
 {
+    if (ceData.widgetObjectTypes.contains("TQWidget")) {
 #ifndef QT_NO_FRAME
-    if (::tqt_cast<TQFrame*>(widget) && ((TQFrame *) widget)->frameStyle() == TQFrame::Panel)
-        ((TQFrame *) widget)->setFrameStyle(TQFrame::WinPanel);
+        if ((ceData.widgetObjectTypes.contains("TQFrame")) && (ceData.frameStyle == TQFrame::Panel)) {
+            widgetActionRequest(ceData, elementFlags, ptr, WAR_FrameSetStyle, TQStyleWidgetActionRequestData(TQFrame::WinPanel));
+        }
 #endif
 
 #ifndef QT_NO_MENUBAR
-    if (::tqt_cast<TQMenuBar*>(widget) && ((TQMenuBar *) widget)->frameStyle() != TQFrame::NoFrame)
-        ((TQMenuBar *) widget)->setFrameStyle(TQFrame::StyledPanel | TQFrame::Raised);
+        if ((ceData.widgetObjectTypes.contains("TQMenuBar")) && (ceData.frameStyle != TQFrame::NoFrame)) {
+            widgetActionRequest(ceData, elementFlags, ptr, WAR_FrameSetStyle, TQStyleWidgetActionRequestData(TQFrame::StyledPanel | TQFrame::Raised));
+        }
 #endif
 
 #ifndef QT_NO_TOOLBAR
-    if (::tqt_cast<TQToolBar*>(widget))
-        widget->layout()->setMargin(2);
+        if (ceData.widgetObjectTypes.contains("TQToolBar")) {
+            widgetActionRequest(ceData, elementFlags, ptr, WAR_SetLayoutMargin, TQStyleWidgetActionRequestData(2));
+        }
 #endif
+    }
     if (useHoveringHighlight) {
-	if (::tqt_cast<TQButton*>(widget) || ::tqt_cast<TQComboBox*>(widget))
-	    widget->installEventFilter(this);
+	if ((ceData.widgetObjectTypes.contains("TQButton")) || (ceData.widgetObjectTypes.contains("TQComboBox"))) {
+	    installObjectEventHandler(ceData, elementFlags, ptr, this);
+	}
 
-	if (::tqt_cast<TQScrollBar*>(widget) || ::tqt_cast<TQSlider*>(widget)) {
-	    widget->setMouseTracking(TRUE);
-	    widget->installEventFilter(this);
+	if ((ceData.widgetObjectTypes.contains("TQScrollBar")) || (ceData.widgetObjectTypes.contains("TQSlider"))) {
+	    widgetActionRequest(ceData, elementFlags, ptr, WAR_EnableMouseTracking);
+	    installObjectEventHandler(ceData, elementFlags, ptr, this);
 	}
     }
 
-    TQMotifStyle::polish(widget);
+    TQMotifStyle::polish(ceData, elementFlags, ptr);
 }
 
 
 /*! \reimp */
-void TQMotifPlusStyle::unPolish(TQWidget *widget)
+void TQMotifPlusStyle::unPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr)
 {
-    widget->removeEventFilter(this);
-    TQMotifStyle::unPolish(widget);
+    removeObjectEventHandler(ceData, elementFlags, ptr, this);
+    TQMotifStyle::unPolish(ceData, elementFlags, ptr);
 }
 
 
 /*! \reimp */
-void TQMotifPlusStyle::polish(TQApplication *)
+void TQMotifPlusStyle::applicationPolish(TQStyleControlElementData, ControlElementFlags, void *)
 {
 }
 
 
 /*! \reimp */
-void TQMotifPlusStyle::unPolish(TQApplication *)
+void TQMotifPlusStyle::applicationUnPolish(TQStyleControlElementData, ControlElementFlags, void *)
 {
 }
 
 
 /*! \reimp */
-int TQMotifPlusStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) const
+int TQMotifPlusStyle::pixelMetric(PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget) const
 {
     int ret;
 
@@ -259,7 +267,7 @@ int TQMotifPlusStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) co
 	break;
 
     default:
-	ret = TQMotifStyle::pixelMetric(metric, widget);
+	ret = TQMotifStyle::pixelMetric(metric, ceData, elementFlags, widget);
 	break;
     }
 
@@ -270,6 +278,8 @@ int TQMotifPlusStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) co
 /*! \reimp */
 void TQMotifPlusStyle::drawPrimitive( PrimitiveElement pe,
 				     TQPainter *p,
+				     TQStyleControlElementData ceData,
+				     ControlElementFlags elementFlags,
 				     const TQRect &r,
 				     const TQColorGroup &cg,
 				     SFlags flags,
@@ -303,11 +313,11 @@ void TQMotifPlusStyle::drawPrimitive( PrimitiveElement pe,
 	break;
 
     case PE_SpinWidgetUp:
-	drawPrimitive(PE_ArrowUp, p, r, cg, flags, opt);
+	drawPrimitive(PE_ArrowUp, p, ceData, elementFlags, r, cg, flags, opt);
 	break;
 
     case PE_SpinWidgetDown:
-	drawPrimitive(PE_ArrowDown, p, r, cg, flags, opt);
+	drawPrimitive(PE_ArrowDown, p, ceData, elementFlags, r, cg, flags, opt);
 	break;
 
     case PE_Indicator:
@@ -632,7 +642,7 @@ void TQMotifPlusStyle::drawPrimitive( PrimitiveElement pe,
 	}
 
     default:
-	TQMotifStyle::drawPrimitive(pe, p, r, cg, flags, opt);
+	TQMotifStyle::drawPrimitive(pe, p, ceData, elementFlags, r, cg, flags, opt);
 	break;
     }
 }
@@ -642,11 +652,13 @@ void TQMotifPlusStyle::drawPrimitive( PrimitiveElement pe,
 */
 void TQMotifPlusStyle::drawControl( ControlElement element,
 				   TQPainter *p,
-				   const TQWidget *widget,
+				   TQStyleControlElementData ceData,
+				   ControlElementFlags elementFlags,
 				   const TQRect &r,
 				   const TQColorGroup &cg,
 				   SFlags flags,
-				   const TQStyleOption& opt ) const
+				   const TQStyleOption& opt,
+				   const TQWidget *widget) const
 {
     if (widget == singleton->hoverWidget)
 	flags |= Style_MouseOver;
@@ -655,12 +667,11 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
     case CE_PushButton:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
 	    TQRect br = r;
-	    int dbi = pixelMetric(PM_ButtonDefaultIndicator, widget);
+	    int dbi = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget);
 
-	    if (button->isDefault() || button->autoDefault()) {
-		if (button->isDefault())
+	    if ((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault)) {
+		if (elementFlags & CEF_IsDefault)
 		    drawMotifPlusShade(p, br, cg, TRUE, FALSE,
 				       &cg.brush(TQColorGroup::Background));
 
@@ -673,9 +684,9 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 	    if (flags & Style_HasFocus)
 		br.addCoords(1, 1, -1, -1);
 	    p->save();
-	    p->setBrushOrigin( -button->backgroundOffset().x(),
-			       -button->backgroundOffset().y() );
-	    drawPrimitive(PE_ButtonCommand, p, br, cg, flags);
+	    p->setBrushOrigin( -ceData.bgOffset.x(),
+			       -ceData.bgOffset.y() );
+	    drawPrimitive(PE_ButtonCommand, p, ceData, elementFlags, br, cg, flags);
 	    p->restore();
 #endif
 	    break;
@@ -684,23 +695,21 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
     case CE_CheckBoxLabel:
 	{
 #ifndef QT_NO_CHECKBOX
-	    const TQCheckBox *checkbox = (const TQCheckBox *) widget;
-
 	    if (flags & Style_MouseOver) {
-		TQRegion r(checkbox->rect());
-		r -= visualRect(subRect(SR_CheckBoxIndicator, widget), widget);
+		TQRegion r(ceData.rect);
+		r -= visualRect(subRect(SR_CheckBoxIndicator, ceData, elementFlags, widget), ceData, elementFlags);
 		p->setClipRegion(r);
-		p->fillRect(checkbox->rect(), cg.brush(TQColorGroup::Midlight));
+		p->fillRect(ceData.rect, cg.brush(TQColorGroup::Midlight));
 		p->setClipping(FALSE);
 	    }
 
 	    int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
 	    drawItem(p, r, alignment | AlignVCenter | ShowPrefix, cg,
-		     flags & Style_Enabled, checkbox->pixmap(), checkbox->text());
+		     flags & Style_Enabled, (ceData.fgPixmap.isNull())?NULL:&ceData.fgPixmap, ceData.text);
 
-	    if (checkbox->hasFocus()) {
-		TQRect fr = visualRect(subRect(SR_CheckBoxFocusRect, widget), widget);
-		drawPrimitive(PE_FocusRect, p, fr, cg, flags);
+	    if (elementFlags & CEF_HasFocus) {
+		TQRect fr = visualRect(subRect(SR_CheckBoxFocusRect, ceData, elementFlags, widget), ceData, elementFlags);
+		drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, flags);
 	    }
 #endif
 	    break;
@@ -709,23 +718,21 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
     case CE_RadioButtonLabel:
 	{
 #ifndef QT_NO_RADIOBUTTON
-	    const TQRadioButton *radiobutton = (const TQRadioButton *) widget;
-
 	    if (flags & Style_MouseOver) {
-		TQRegion r(radiobutton->rect());
-		r -= visualRect(subRect(SR_RadioButtonIndicator, widget), widget);
+		TQRegion r(ceData.rect);
+		r -= visualRect(subRect(SR_RadioButtonIndicator, ceData, elementFlags, widget), ceData, elementFlags);
 		p->setClipRegion(r);
-		p->fillRect(radiobutton->rect(), cg.brush(TQColorGroup::Midlight));
+		p->fillRect(ceData.rect, cg.brush(TQColorGroup::Midlight));
 		p->setClipping(FALSE);
 	    }
 
 	    int alignment = TQApplication::reverseLayout() ? AlignRight : AlignLeft;
 	    drawItem(p, r, alignment | AlignVCenter | ShowPrefix, cg,
-		     flags & Style_Enabled, radiobutton->pixmap(), radiobutton->text());
+		     flags & Style_Enabled, (ceData.fgPixmap.isNull())?NULL:&ceData.fgPixmap, ceData.text);
 
-	    if (radiobutton->hasFocus()) {
-		TQRect fr = visualRect(subRect(SR_RadioButtonFocusRect, widget), widget);
-		drawPrimitive(PE_FocusRect, p, fr, cg, flags);
+	    if (elementFlags & CEF_HasFocus) {
+		TQRect fr = visualRect(subRect(SR_RadioButtonFocusRect, ceData, elementFlags, widget), ceData, elementFlags);
+		drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, flags);
 	    }
 #endif
 	    break;
@@ -757,7 +764,6 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 	    if (! widget || opt.isDefault())
 		break;
 
-	    TQPopupMenu *popupmenu = (TQPopupMenu *) widget;
 	    TQMenuItem *mi = opt.menuItem();
 	    if ( !mi )
 		break;
@@ -765,7 +771,7 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 	    int tab = opt.tabWidth();
 	    int maxpmw = opt.maxIconWidth();
 	    bool dis = ! (flags & Style_Enabled);
-	    bool checkable = popupmenu->isCheckable();
+	    bool checkable = (elementFlags & CEF_IsCheckable);
 	    bool act = flags & Style_Active;
 	    int x, y, w, h;
 
@@ -834,7 +840,7 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 		    if (act)
 			cflags |= Style_On;
 
-		    drawPrimitive(PE_CheckMark, p, vrect, cg, cflags);
+		    drawPrimitive(PE_CheckMark, p, ceData, elementFlags, vrect, cg, cflags);
 		}
 	    }
 
@@ -883,6 +889,7 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 		TQStyle::PrimitiveElement arrow = (TQApplication::reverseLayout() ? PE_ArrowLeft : PE_ArrowRight);
 		vrect = visualRect( TQRect(x + w - hh - 6, y + (hh / 2), hh, hh), r );
 		drawPrimitive(arrow, p,
+			      ceData, elementFlags,
 			      vrect, cg,
 			      ((act && !dis) ?
 			       Style_Down : Style_Default) |
@@ -895,16 +902,15 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
     case CE_TabBarTab:
 	{
 #ifndef QT_NO_TABBAR
-	    const TQTabBar *tabbar = (const TQTabBar *) widget;
 	    bool selected = flags & Style_Selected;
 
-	    TQColorGroup g = tabbar->colorGroup();
+	    TQColorGroup g = ceData.colorGroup;
 	    TQPen oldpen = p->pen();
 	    TQRect fr(r);
 
 	    if (! selected) {
-		if (tabbar->shape() == TQTabBar::RoundedAbove ||
-		    tabbar->shape() == TQTabBar::TriangularAbove) {
+		if (ceData.tabBarData.shape == TQTabBar::RoundedAbove ||
+		    ceData.tabBarData.shape == TQTabBar::TriangularAbove) {
 		    fr.setTop(fr.top() + 2);
 		} else {
 		    fr.setBottom(fr.bottom() - 2);
@@ -917,7 +923,7 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 			(selected) ? cg.brush(TQColorGroup::Button)
 			: cg.brush(TQColorGroup::Mid));
 
-	    if (tabbar->shape() == TQTabBar::RoundedAbove) {
+	    if (ceData.tabBarData.shape == TQTabBar::RoundedAbove) {
 		// "rounded" tabs on top
 		fr.setBottom(fr.bottom() - 1);
 
@@ -941,7 +947,7 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 		p->setPen(black);
 		p->drawLine(fr.right(), fr.top() + 1,
 			    fr.right(), fr.bottom() - 1);
-	    } else if (tabbar->shape() == TQTabBar::RoundedBelow) {
+	    } else if (ceData.tabBarData.shape == TQTabBar::RoundedBelow) {
 		// "rounded" tabs on bottom
 		fr.setTop(fr.top() + 1);
 
@@ -987,7 +993,7 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 		}
 	    } else
 		// triangular drawing code
-		TQMotifStyle::drawControl(element, p, widget, r, cg, flags, opt);
+		TQMotifStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
 
 	    p->setPen(oldpen);
 #endif
@@ -995,7 +1001,7 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 	}
 
     default:
-	TQMotifStyle::drawControl(element, p, widget, r, cg, flags, opt);
+	TQMotifStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
 	break;
     }
 }
@@ -1003,7 +1009,7 @@ void TQMotifPlusStyle::drawControl( ControlElement element,
 
 /*! \reimp
 */
-TQRect TQMotifPlusStyle::subRect(SubRect r, const TQWidget *widget) const
+TQRect TQMotifPlusStyle::subRect(SubRect r, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget) const
 {
     TQRect rect;
 
@@ -1011,11 +1017,10 @@ TQRect TQMotifPlusStyle::subRect(SubRect r, const TQWidget *widget) const
     case SR_PushButtonFocusRect:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
-	    int dfi = pixelMetric(PM_ButtonDefaultIndicator, widget);
+	    int dfi = pixelMetric(PM_ButtonDefaultIndicator, ceData, elementFlags, widget);
 
-	    rect = button->rect();
-	    if (button->isDefault() || button->autoDefault())
+	    rect = ceData.rect;
+	    if ((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault))
 		rect.addCoords(dfi, dfi, -dfi, -dfi);
 #endif
 	    break;
@@ -1023,38 +1028,36 @@ TQRect TQMotifPlusStyle::subRect(SubRect r, const TQWidget *widget) const
 
     case SR_CheckBoxIndicator:
 	{
-	    int h = pixelMetric( PM_IndicatorHeight );
-	    rect.setRect(( widget->rect().height() - h ) / 2,
-			 ( widget->rect().height() - h ) / 2,
-			 pixelMetric( PM_IndicatorWidth ), h );
+	    int h = pixelMetric( PM_IndicatorHeight, ceData, elementFlags );
+	    rect.setRect(( ceData.rect.height() - h ) / 2,
+			 ( ceData.rect.height() - h ) / 2,
+			 pixelMetric( PM_IndicatorWidth, ceData, elementFlags ), h );
 	    break;
 	}
 
     case SR_RadioButtonIndicator:
 	{
-	    int h = pixelMetric( PM_ExclusiveIndicatorHeight );
-	    rect.setRect( ( widget->rect().height() - h ) / 2,
-			  ( widget->rect().height() - h ) / 2,
-			  pixelMetric( PM_ExclusiveIndicatorWidth ), h );
+	    int h = pixelMetric( PM_ExclusiveIndicatorHeight, ceData, elementFlags );
+	    rect.setRect( ( ceData.rect.height() - h ) / 2,
+			  ( ceData.rect.height() - h ) / 2,
+			  pixelMetric( PM_ExclusiveIndicatorWidth, ceData, elementFlags ), h );
 	    break;
 	}
 
     case SR_CheckBoxFocusRect:
     case SR_RadioButtonFocusRect:
-       	rect = widget->rect();
+       	rect = ceData.rect;
 	break;
 
     case SR_ComboBoxFocusRect:
 	{
 #ifndef QT_NO_COMBOBOX
-	    const TQComboBox *combobox = (const TQComboBox *) widget;
-
-	    if (combobox->editable()) {
-		rect = querySubControlMetrics(CC_ComboBox, widget,
-					      SC_ComboBoxEditField);
+	    if (elementFlags & CEF_IsEditable) {
+		rect = querySubControlMetrics(CC_ComboBox, ceData, elementFlags,
+					      SC_ComboBoxEditField, TQStyleOption::Default, widget);
 		rect.addCoords(-3, -3, 3, 3);
 	    } else
-		rect = combobox->rect();
+		rect = ceData.rect;
 #endif
 	    break;
 	}
@@ -1062,21 +1065,20 @@ TQRect TQMotifPlusStyle::subRect(SubRect r, const TQWidget *widget) const
     case SR_SliderFocusRect:
 	{
 #ifndef QT_NO_SLIDER
-	    const TQSlider *slider = (const TQSlider *) widget;
-	    int tickOffset = pixelMetric( PM_SliderTickmarkOffset, widget );
-	    int thickness = pixelMetric( PM_SliderControlThickness, widget );
+	    int tickOffset = pixelMetric( PM_SliderTickmarkOffset, ceData, elementFlags, widget );
+	    int thickness = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
 	    int x, y, wi, he;
 
-	    if ( slider->orientation() == Horizontal ) {
+	    if ( ceData.orientation == Horizontal ) {
 		x = 0;
 		y = tickOffset;
-		wi = slider->width();
+		wi = ceData.rect.width();
 		he = thickness;
 	    } else {
 		x = tickOffset;
 		y = 0;
 		wi = thickness;
-		he = slider->height();
+		he = ceData.rect.height();
 	    }
 
 	    rect.setRect(x, y, wi, he);
@@ -1085,7 +1087,7 @@ TQRect TQMotifPlusStyle::subRect(SubRect r, const TQWidget *widget) const
 	}
 
     default:
-	rect = TQMotifStyle::subRect(r, widget);
+	rect = TQMotifStyle::subRect(r, ceData, elementFlags, widget);
 	break;
     }
 
@@ -1096,13 +1098,15 @@ TQRect TQMotifPlusStyle::subRect(SubRect r, const TQWidget *widget) const
 /*! \reimp */
 void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 			    TQPainter *p,
-			    const TQWidget *widget,
+			    TQStyleControlElementData ceData,
+			    ControlElementFlags elementFlags,
 			    const TQRect &r,
 			    const TQColorGroup &cg,
 			    SFlags flags,
 			    SCFlags controls,
 			    SCFlags active,
-			    const TQStyleOption& opt ) const
+			    const TQStyleOption& opt,
+			    const TQWidget *widget ) const
 {
     if (widget == singleton->hoverWidget)
 	flags |= Style_MouseOver;
@@ -1111,17 +1115,16 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
     case CC_ScrollBar:
 	{
 #ifndef QT_NO_SCROLLBAR
-	    const TQScrollBar *scrollbar = (const TQScrollBar *) widget;
 	    TQRect addline, subline, addpage, subpage, slider, first, last;
-	    bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue());
+	    bool maxedOut = (ceData.minSteps == ceData.maxSteps);
 
-	    subline = querySubControlMetrics(control, widget, SC_ScrollBarSubLine, opt);
-	    addline = querySubControlMetrics(control, widget, SC_ScrollBarAddLine, opt);
-	    subpage = querySubControlMetrics(control, widget, SC_ScrollBarSubPage, opt);
-	    addpage = querySubControlMetrics(control, widget, SC_ScrollBarAddPage, opt);
-	    slider  = querySubControlMetrics(control, widget, SC_ScrollBarSlider,  opt);
-	    first   = querySubControlMetrics(control, widget, SC_ScrollBarFirst,   opt);
-	    last    = querySubControlMetrics(control, widget, SC_ScrollBarLast,    opt);
+	    subline = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubLine, opt, widget);
+	    addline = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddLine, opt, widget);
+	    subpage = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSubPage, opt, widget);
+	    addpage = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarAddPage, opt, widget);
+	    slider  = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarSlider,  opt, widget);
+	    first   = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarFirst,   opt, widget);
+	    last    = querySubControlMetrics(control, ceData, elementFlags, SC_ScrollBarLast,    opt, widget);
 
 	    bool skipUpdate = FALSE;
 	    if (singleton->hovering) {
@@ -1157,67 +1160,67 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 				   &cg.brush(TQColorGroup::Mid));
 
 	    if ((controls & SC_ScrollBarSubLine) && subline.isValid())
-		drawPrimitive(PE_ScrollBarSubLine, p, subline, cg,
+		drawPrimitive(PE_ScrollBarSubLine, p, ceData, elementFlags, subline, cg,
 			      ((active == SC_ScrollBarSubLine ||
 				singleton->scrollbarElement == SC_ScrollBarSubLine) ?
 			       Style_MouseOver: Style_Default) |
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarSubLine) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : Style_Default));
 	    if ((controls & SC_ScrollBarAddLine) && addline.isValid())
-		drawPrimitive(PE_ScrollBarAddLine, p, addline, cg,
+		drawPrimitive(PE_ScrollBarAddLine, p, ceData, elementFlags, addline, cg,
 			      ((active == SC_ScrollBarAddLine ||
 				singleton->scrollbarElement == SC_ScrollBarAddLine) ?
 			       Style_MouseOver: Style_Default) |
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarAddLine) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : Style_Default));
 	    if ((controls & SC_ScrollBarSubPage) && subpage.isValid())
-		drawPrimitive(PE_ScrollBarSubPage, p, subpage, cg,
+		drawPrimitive(PE_ScrollBarSubPage, p, ceData, elementFlags, subpage, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarSubPage) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : Style_Default));
 	    if ((controls & SC_ScrollBarAddPage) && addpage.isValid())
-		drawPrimitive(PE_ScrollBarAddPage, p, addpage, cg,
+		drawPrimitive(PE_ScrollBarAddPage, p, ceData, elementFlags, addpage, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarAddPage) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : Style_Default));
 	    if ((controls & SC_ScrollBarFirst) && first.isValid())
-		drawPrimitive(PE_ScrollBarFirst, p, first, cg,
+		drawPrimitive(PE_ScrollBarFirst, p, ceData, elementFlags, first, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarFirst) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : Style_Default));
 	    if ((controls & SC_ScrollBarLast) && last.isValid())
-		drawPrimitive(PE_ScrollBarLast, p, last, cg,
+		drawPrimitive(PE_ScrollBarLast, p, ceData, elementFlags, last, cg,
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
 			      ((active == SC_ScrollBarLast) ?
 			       Style_Down : Style_Default) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : Style_Default));
 	    if ((controls & SC_ScrollBarSlider) && slider.isValid()) {
-		drawPrimitive(PE_ScrollBarSlider, p, slider, cg,
+		drawPrimitive(PE_ScrollBarSlider, p, ceData, elementFlags, slider, cg,
 			      ((active == SC_ScrollBarSlider ||
 				singleton->scrollbarElement == SC_ScrollBarSlider) ?
 			       Style_MouseOver: Style_Default) |
 			      ((maxedOut) ? Style_Default : Style_Enabled) |
-			      ((scrollbar->orientation() == TQt::Horizontal) ?
+			      ((ceData.orientation == TQt::Horizontal) ?
 			       Style_Horizontal : Style_Default));
 
 		// ### perhaps this should not be able to accept focus if maxedOut?
-		if (scrollbar->hasFocus()) {
+		if (elementFlags & CEF_HasFocus) {
 		    TQRect fr(slider.x() + 2, slider.y() + 2,
 			     slider.width() - 5, slider.height() - 5);
-		    drawPrimitive(PE_FocusRect, p, fr, cg, Style_Default);
+		    drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, Style_Default);
 		}
 	    }
 #endif
@@ -1227,27 +1230,25 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
     case CC_ComboBox:
 	{
 #ifndef QT_NO_COMBOBOX
-	    const TQComboBox *combobox = (const TQComboBox *) widget;
-
 	    TQRect editfield, arrow;
 	    editfield =
 		visualRect(querySubControlMetrics(CC_ComboBox,
-						  combobox,
+						  ceData, elementFlags,
 						  SC_ComboBoxEditField,
-						  opt), widget);
+						  opt, widget), ceData, elementFlags);
 	    arrow =
 		visualRect(querySubControlMetrics(CC_ComboBox,
-						  combobox,
+						  ceData, elementFlags,
 						  SC_ComboBoxArrow,
-						  opt), widget);
+						  opt, widget), ceData, elementFlags);
 
-	    if (combobox->editable()) {
+	    if (elementFlags & CEF_IsEditable) {
 		if (controls & SC_ComboBoxEditField && editfield.isValid()) {
 		    editfield.addCoords(-3, -3, 3, 3);
-		    if (combobox->hasFocus())
+		    if (elementFlags & CEF_HasFocus)
 			editfield.addCoords(1, 1, -1, -1);
 		    drawMotifPlusShade(p, editfield, cg, TRUE, FALSE,
-				       (widget->isEnabled() ?
+				       ((elementFlags & CEF_IsEnabled) ?
 					&cg.brush(TQColorGroup::Base) :
 					&cg.brush(TQColorGroup::Background)));
 		}
@@ -1261,12 +1262,12 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 
 		    if (active == SC_ComboBoxArrow)
 			flags |= Style_Sunken;
-		    drawPrimitive(PE_ArrowDown, p, arrow, cg, flags);
+		    drawPrimitive(PE_ArrowDown, p, ceData, elementFlags, arrow, cg, flags);
 		}
 	    } else {
 		if (controls & SC_ComboBoxEditField && editfield.isValid()) {
 		    editfield.addCoords(-3, -3, 3, 3);
-		    if (combobox->hasFocus())
+		    if (elementFlags & CEF_HasFocus)
 			editfield.addCoords(1, 1, -1, -1);
 		    drawMotifPlusShade(p, editfield, cg, FALSE,
 				       (flags & Style_MouseOver));
@@ -1276,10 +1277,10 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 		    drawMotifPlusShade(p, arrow, cg, FALSE, (flags & Style_MouseOver));
 	    }
 
-	    if (combobox->hasFocus() ||
-		(combobox->editable() && combobox->lineEdit()->hasFocus())) {
-		TQRect fr = visualRect(subRect(SR_ComboBoxFocusRect, widget), widget);
-		drawPrimitive(PE_FocusRect, p, fr, cg, flags);
+	    if ((elementFlags & CEF_HasFocus) ||
+		((elementFlags & CEF_IsEditable) && (ceData.comboBoxLineEditFlags & CEF_HasFocus))) {
+		TQRect fr = visualRect(subRect(SR_ComboBoxFocusRect, ceData, elementFlags, widget), ceData, elementFlags);
+		drawPrimitive(PE_FocusRect, p, ceData, elementFlags, fr, cg, flags);
 	    }
 #endif
 	    break;
@@ -1288,7 +1289,6 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
     case CC_SpinWidget:
 	{
 #ifndef QT_NO_SPINWIDGET
-	    const TQSpinWidget * sw = (const TQSpinWidget *) widget;
 	    SFlags flags = Style_Default;
 
 	    if (controls & SC_SpinWidgetFrame)
@@ -1300,14 +1300,14 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 		    flags |= Style_Down;
 
 		PrimitiveElement pe;
-		if ( sw->buttonSymbols() == TQSpinWidget::PlusMinus )
+		if ( ceData.spinWidgetData.buttonSymbols == TQSpinWidget::PlusMinus )
 		    pe = PE_SpinWidgetPlus;
 		else
 		    pe = PE_SpinWidgetUp;
 
-		TQRect re = sw->upRect();
-		TQColorGroup ucg = sw->isUpEnabled() ? cg : sw->palette().disabled();
-		drawPrimitive(pe, p, re, ucg, flags);
+		TQRect re = ceData.spinWidgetData.upRect;
+		TQColorGroup ucg = ceData.spinWidgetData.upEnabled ? cg : ceData.palette.disabled();
+		drawPrimitive(pe, p, ceData, elementFlags, re, ucg, flags);
 	    }
 
 	    if (controls & SC_SpinWidgetDown) {
@@ -1316,14 +1316,14 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 		    flags |= Style_Down;
 
 		PrimitiveElement pe;
-		if ( sw->buttonSymbols() == TQSpinWidget::PlusMinus )
+		if ( ceData.spinWidgetData.buttonSymbols == TQSpinWidget::PlusMinus )
 		    pe = PE_SpinWidgetMinus;
 		else
 		    pe = PE_SpinWidgetDown;
 
-		TQRect re = sw->downRect();
-		TQColorGroup dcg = sw->isDownEnabled() ? cg : sw->palette().disabled();
-		drawPrimitive(pe, p, re, dcg, flags);
+		TQRect re = ceData.spinWidgetData.downRect;
+		TQColorGroup dcg = ceData.spinWidgetData.downEnabled ? cg : ceData.palette.disabled();
+		drawPrimitive(pe, p, ceData, elementFlags, re, dcg, flags);
 	    }
 #endif
 	    break;
@@ -1332,21 +1332,20 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
     case CC_Slider:
 	{
 #ifndef QT_NO_SLIDER
-	    const TQSlider *slider = (const TQSlider *) widget;
 	    bool mouseover = (flags & Style_MouseOver);
 
-	    TQRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
-						  opt),
-		  handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
-						  opt);
+	    TQRect groove = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderGroove,
+						  opt, widget),
+		  handle = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderHandle,
+						  opt, widget);
 
 	    if ((controls & SC_SliderGroove) && groove.isValid()) {
 		drawMotifPlusShade(p, groove, cg, TRUE, FALSE,
 				   &cg.brush(TQColorGroup::Mid));
 
 		if ( flags & Style_HasFocus ) {
-		    TQRect fr = subRect( SR_SliderFocusRect, widget );
-		    drawPrimitive( PE_FocusRect, p, fr, cg, flags );
+		    TQRect fr = subRect( SR_SliderFocusRect, ceData, elementFlags, widget );
+		    drawPrimitive( PE_FocusRect, p, ceData, elementFlags, fr, cg, flags );
 		}
 	    }
 
@@ -1356,9 +1355,9 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 		    flags |= Style_MouseOver;
 		else
 		    flags &= ~Style_MouseOver;
-		drawPrimitive(PE_ButtonBevel, p, handle, cg, flags | Style_Raised);
+		drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, handle, cg, flags | Style_Raised);
 
-		if ( slider->orientation() == Horizontal ) {
+		if ( ceData.orientation == Horizontal ) {
 		    TQCOORD mid = handle.x() + handle.width() / 2;
 		    qDrawShadeLine( p, mid,  handle.y() + 1, mid ,
 				    handle.y() + handle.height() - 3,
@@ -1372,15 +1371,15 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 	    }
 
 	    if (controls & SC_SliderTickmarks)
-		TQMotifStyle::drawComplexControl(control, p, widget, r, cg, flags,
-						SC_SliderTickmarks, active, opt);
+		TQMotifStyle::drawComplexControl(control, p, ceData, elementFlags, r, cg, flags,
+						SC_SliderTickmarks, active, opt, widget);
 #endif
 	    break;
 	}
 
     default:
-	TQMotifStyle::drawComplexControl(control, p, widget, r, cg, flags,
-					controls, active, opt);
+	TQMotifStyle::drawComplexControl(control, p, ceData, elementFlags, r, cg, flags,
+					controls, active, opt, widget);
     }
 }
 
@@ -1388,22 +1387,24 @@ void TQMotifPlusStyle::drawComplexControl(ComplexControl control,
 /*! \reimp
 */
 TQRect TQMotifPlusStyle::querySubControlMetrics(ComplexControl control,
-					      const TQWidget *widget,
+					      TQStyleControlElementData ceData,
+					      ControlElementFlags elementFlags,
 					      SubControl subcontrol,
-					      const TQStyleOption& opt) const
+					      const TQStyleOption& opt,
+					      const TQWidget *widget) const
 {
     switch (control) {
     case CC_SpinWidget: {
-	    int fw = pixelMetric( PM_SpinBoxFrameWidth, 0 );
+	    int fw = pixelMetric( PM_SpinBoxFrameWidth, ceData, elementFlags, 0 );
 	    TQSize bs;
-	    bs.setHeight( (widget->height() + 1)/2 );
+	    bs.setHeight( (ceData.rect.height() + 1)/2 );
 	    if ( bs.height() < 10 )
 		bs.setHeight( 10 );
 	    bs.setWidth( bs.height() ); // 1.6 -approximate golden mean
 	    bs = bs.expandedTo( TQApplication::globalStrut() );
 	    int y = 0;
 	    int x, lx, rx, h;
-	    x = widget->width() - y - bs.width();
+	    x = ceData.rect.width() - y - bs.width();
 	    lx = fw;
 	    rx = x - fw * 2;
 	    h = bs.height() * 2;
@@ -1418,7 +1419,7 @@ TQRect TQMotifPlusStyle::querySubControlMetrics(ComplexControl control,
 	    case SC_SpinWidgetEditField:
 		return TQRect(lx, fw, rx, h - 2*fw);
 	    case SC_SpinWidgetFrame:
-		return TQRect( 0, 0, widget->width() - bs.width(), h);
+		return TQRect( 0, 0, ceData.rect.width() - bs.width(), h);
 	    default:
 		break;
 	    }
@@ -1426,34 +1427,33 @@ TQRect TQMotifPlusStyle::querySubControlMetrics(ComplexControl control,
 
 #ifndef QT_NO_COMBOBOX
     case CC_ComboBox: {
-	const TQComboBox *combobox = (const TQComboBox *) widget;
-	if (combobox->editable()) {
-	    int space = (combobox->height() - 13) / 2;
+	if (elementFlags & CEF_IsEditable) {
+	    int space = (ceData.rect.height() - 13) / 2;
 	    switch (subcontrol) {
 	    case SC_ComboBoxFrame:
 		return TQRect();
 	    case SC_ComboBoxEditField: {
-		TQRect rect = widget->rect();
+		TQRect rect = ceData.rect;
 		rect.setWidth(rect.width() - 13 - space * 2);
 		rect.addCoords(3, 3, -3, -3);
 		return rect; }
 	    case SC_ComboBoxArrow:
-		return TQRect(combobox->width() - 13 - space * 2, 0,
-			     13 + space * 2, combobox->height());
+		return TQRect(ceData.rect.width() - 13 - space * 2, 0,
+			     13 + space * 2, ceData.rect.height());
 	    default: break;		// shouldn't get here
 	    }
 
 	} else {
-	    int space = (combobox->height() - 7) / 2;
+	    int space = (ceData.rect.height() - 7) / 2;
 	    switch (subcontrol) {
 	    case SC_ComboBoxFrame:
 		return TQRect();
 	    case SC_ComboBoxEditField: {
-		TQRect rect = widget->rect();
+		TQRect rect = ceData.rect;
 		rect.addCoords(3, 3, -3, -3);
 		return rect; }
 	    case SC_ComboBoxArrow:		// 12 wide, 7 tall
-		return TQRect(combobox->width() - 12 - space, space, 12, 7);
+		return TQRect(ceData.rect.width() - 12 - space, space, 12, 7);
 	    default: break;		// shouldn't get here
 	    }
 	}
@@ -1464,14 +1464,13 @@ TQRect TQMotifPlusStyle::querySubControlMetrics(ComplexControl control,
     case CC_Slider: {
 
 	if (subcontrol == SC_SliderHandle) {
-	    const TQSlider *slider = (const TQSlider *) widget;
-	    int tickOffset  = pixelMetric( PM_SliderTickmarkOffset, widget );
-	    int thickness   = pixelMetric( PM_SliderControlThickness, widget );
-	    int len         = pixelMetric( PM_SliderLength, widget ) + 2;
-	    int sliderPos   = slider->sliderStart();
+	    int tickOffset  = pixelMetric( PM_SliderTickmarkOffset, ceData, elementFlags, widget );
+	    int thickness   = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
+	    int len         = pixelMetric( PM_SliderLength, ceData, elementFlags, widget ) + 2;
+	    int sliderPos   = ceData.startStep;
 	    int motifBorder = 2;
 
-	    if ( slider->orientation() == Horizontal )
+	    if ( ceData.orientation == Horizontal )
 		return TQRect( sliderPos + motifBorder, tickOffset + motifBorder, len,
 			      thickness - 2*motifBorder );
 	    return TQRect( tickOffset + motifBorder, sliderPos + motifBorder,
@@ -1481,19 +1480,19 @@ TQRect TQMotifPlusStyle::querySubControlMetrics(ComplexControl control,
 #endif
     default: break;
     }
-    return TQMotifStyle::querySubControlMetrics(control, widget, subcontrol, opt);
+    return TQMotifStyle::querySubControlMetrics(control, ceData, elementFlags, subcontrol, opt, widget);
 }
 
 
 /*! \reimp */
-bool TQMotifPlusStyle::eventFilter(TQObject *object, TQEvent *event)
+bool TQMotifPlusStyle::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *event )
 {
     switch(event->type()) {
     case TQEvent::MouseButtonPress:
         {
 	    singleton->mousePressed = TRUE;
 
-            if (!::tqt_cast<TQSlider*>(object))
+            if (!ceData.widgetObjectTypes.contains("TQSlider"))
 		break;
 
 	    singleton->sliderActive = TRUE;
@@ -1504,50 +1503,52 @@ bool TQMotifPlusStyle::eventFilter(TQObject *object, TQEvent *event)
         {
 	    singleton->mousePressed = FALSE;
 
-            if (!::tqt_cast<TQSlider*>(object))
+            if (!ceData.widgetObjectTypes.contains("TQSlider"))
 		break;
 
 	    singleton->sliderActive = FALSE;
-	    ((TQWidget *) object)->repaint(FALSE);
+	    widgetActionRequest(ceData, elementFlags, source, WAR_Repaint);
 	    break;
         }
 
     case TQEvent::Enter:
         {
-            if (! object->isWidgetType())
+            if (!ceData.widgetObjectTypes.contains("TQWidget"))
 		break;
 
-	    singleton->hoverWidget = (TQWidget *) object;
-	    if (! singleton->hoverWidget->isEnabled()) {
+	    singleton->hoverWidget = source;
+	    singleton->hoverWidgetData = ceData;
+	    singleton->hoverWidgetFlags = elementFlags;
+	    if (!(singleton->hoverWidgetFlags & CEF_IsEnabled)) {
 		singleton->hoverWidget = 0;
 		break;
 	    }
-	    singleton->hoverWidget->repaint(FALSE);
+	    widgetActionRequest(singleton->hoverWidgetData, singleton->hoverWidgetFlags, singleton->hoverWidget, WAR_Repaint);
 	    break;
 	}
 
     case TQEvent::Leave:
 	{
-	    if (object != singleton->hoverWidget)
+	    if (source != singleton->hoverWidget)
 		break;
-	    TQWidget *w = singleton->hoverWidget;
+	    void *w = singleton->hoverWidget;
 	    singleton->hoverWidget = 0;
-	    w->repaint(FALSE);
+	    widgetActionRequest(singleton->hoverWidgetData, singleton->hoverWidgetFlags, w, WAR_Repaint);
 	    break;
 	}
 
     case TQEvent::MouseMove:
 	{
-	    if (! object->isWidgetType() || object != singleton->hoverWidget)
+	    if ((!ceData.widgetObjectTypes.contains("TQWidget")) || source != singleton->hoverWidget)
 		break;
 
-	    if (!::tqt_cast<TQScrollBar*>(object) && ! ::tqt_cast<TQSlider*>(object))
+	    if ((!ceData.widgetObjectTypes.contains("TQScrollBar")) && (!ceData.widgetObjectTypes.contains("TQSlider")))
 		break;
 
 	    singleton->mousePos = ((TQMouseEvent *) event)->pos();
 	    if (! singleton->mousePressed) {
 		singleton->hovering = TRUE;
-		singleton->hoverWidget->repaint(FALSE);
+		widgetActionRequest(singleton->hoverWidgetData, singleton->hoverWidgetFlags, singleton->hoverWidget, WAR_Repaint);
 		singleton->hovering = FALSE;
 	    }
 
@@ -1558,15 +1559,17 @@ bool TQMotifPlusStyle::eventFilter(TQObject *object, TQEvent *event)
 	break;
     }
 
-    return TQMotifStyle::eventFilter(object, event);
+    return TQMotifStyle::objectEventHandler(ceData, elementFlags, source, event);
 }
 
 
 /*! \reimp */
 int TQMotifPlusStyle::styleHint(StyleHint hint,
-			       const TQWidget *widget,
+			       TQStyleControlElementData ceData,
+			       ControlElementFlags elementFlags,
 			       const TQStyleOption &opt,
-			       TQStyleHintReturn *returnData) const
+			       TQStyleHintReturn *returnData,
+			       const TQWidget *widget) const
 {
     int ret;
     switch (hint) {
@@ -1574,7 +1577,7 @@ int TQMotifPlusStyle::styleHint(StyleHint hint,
 	ret = 1;
 	break;
     default:
-	ret = TQMotifStyle::styleHint(hint, widget, opt, returnData);
+	ret = TQMotifStyle::styleHint(hint, ceData, elementFlags, opt, returnData, widget);
 	break;
     }
     return ret;
diff --git a/src/styles/qmotifstyle.cpp b/src/styles/qmotifstyle.cpp
index ce25794f..37a5a34c 100644
--- a/src/styles/qmotifstyle.cpp
+++ b/src/styles/qmotifstyle.cpp
@@ -171,9 +171,9 @@ void TQMotifStyle::polish( TQPalette& pal )
  \internal
  Keep TQStyle::polish() visible.
 */
-void TQMotifStyle::polish( TQWidget* w )
+void TQMotifStyle::polish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr )
 {
-    TQStyle::polish(w);
+    TQStyle::polish(ceData, elementFlags, ptr);
 }
 
 /*!
@@ -181,9 +181,9 @@ void TQMotifStyle::polish( TQWidget* w )
  \internal
  Keep TQStyle::polish() visible.
 */
-void TQMotifStyle::polish( TQApplication* a )
+void TQMotifStyle::applicationPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr )
 {
-    TQStyle::polish(a);
+    TQStyle::applicationPolish(ceData, elementFlags, ptr);
 }
 
 static void rot(TQPointArray& a, int n)
@@ -204,6 +204,8 @@ static void rot(TQPointArray& a, int n)
 */
 void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
 				 TQPainter *p,
+				 TQStyleControlElementData ceData,
+				 ControlElementFlags elementFlags,
 				 const TQRect &r,
 				 const TQColorGroup &cg,
 				 SFlags flags,
@@ -251,7 +253,7 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
     case PE_ButtonTool:
     case PE_HeaderSection:
 	qDrawShadePanel( p, r, cg, bool(flags & (Style_Down | Style_On )),
-			 pixelMetric(PM_DefaultFrameWidth),
+			 pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags),
 			 &cg.brush(TQColorGroup::Button) );
 	break;
 
@@ -268,7 +270,7 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
 			 r.x(), r.y() + r.height() - 1);
 	} else
 	    qDrawShadePanel( p, r, cg, !showUp,
-			     pixelMetric(PM_DefaultFrameWidth), &fill );
+			     pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags), &fill );
 #endif
 	break;
     }
@@ -509,7 +511,7 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
     case PE_SpinWidgetMinus:
 	{
 	    p->save();
-	    int fw = pixelMetric( PM_DefaultFrameWidth );
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags );
 	    TQRect br;
 	    br.setRect( r.x() + fw, r.y() + fw, r.width() - fw*2,
 			r.height() - fw*2 );
@@ -547,7 +549,7 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
     case PE_SpinWidgetDown:
 	{
 	    p->save();
-	    int fw = pixelMetric( PM_DefaultFrameWidth );
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags );
 	    TQRect br;
 	    br.setRect( r.x() + fw, r.y() + fw, r.width() - fw*2,
 			r.height() - fw*2 );
@@ -576,8 +578,8 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
 	    int bsx = 0;
 	    int bsy = 0;
 	    if ( flags & Style_Sunken ) {
-		bsx = pixelMetric(PM_ButtonShiftHorizontal);
-		bsy = pixelMetric(PM_ButtonShiftVertical);
+		bsx = pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags);
+		bsy = pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags);
 	    }
 	    p->translate( sx + bsx, sy + bsy );
 	    p->setPen( cg.buttonText() );
@@ -665,7 +667,7 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
     case PE_DockWindowResizeHandle:
 	{
 	    const int motifOffset = 10;
- 	    int sw = pixelMetric( PM_SplitterWidth );
+ 	    int sw = pixelMetric( PM_SplitterWidth, ceData, elementFlags );
 	    if ( flags & Style_Horizontal ) {
  		TQCOORD yPos = r.y() + r.height() / 2;
  		TQCOORD kPos = r.width() - motifOffset - sw;
@@ -694,7 +696,7 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
 	    const int markH = 6;
 	    int posX = r.x() + ( r.width()  - markW ) / 2 - 1;
 	    int posY = r.y() + ( r.height() - markH ) / 2;
-	    int dfw = pixelMetric(PM_DefaultFrameWidth);
+	    int dfw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags);
 
 	    if (dfw < 2) {
 		// Could do with some optimizing/caching...
@@ -736,12 +738,12 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
 
     case PE_ScrollBarSubLine:
 	drawPrimitive(((flags & Style_Horizontal) ? PE_ArrowLeft : PE_ArrowUp),
-		      p, r, cg, Style_Enabled | flags);
+		      p, ceData, elementFlags, r, cg, Style_Enabled | flags);
 	break;
 
     case PE_ScrollBarAddLine:
 	drawPrimitive(((flags & Style_Horizontal) ? PE_ArrowRight : PE_ArrowDown),
-		      p, r, cg, Style_Enabled | flags);
+		      p, ceData, elementFlags, r, cg, Style_Enabled | flags);
 	break;
 
     case PE_ScrollBarSubPage:
@@ -750,7 +752,7 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
 	break;
 
     case PE_ScrollBarSlider:
-	drawPrimitive(PE_ButtonBevel, p, r, cg,
+	drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, r, cg,
 		      (flags | Style_Raised) & ~Style_Down);
 	break;
 
@@ -760,7 +762,7 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
 	break;
 
     default:
-	TQCommonStyle::drawPrimitive( pe, p, r, cg, flags, opt );
+	TQCommonStyle::drawPrimitive( pe, p, ceData, elementFlags, r, cg, flags, opt );
 	break;
     }
 }
@@ -770,40 +772,40 @@ void TQMotifStyle::drawPrimitive( PrimitiveElement pe,
 */
 void TQMotifStyle::drawControl( ControlElement element,
 			       TQPainter *p,
-			       const TQWidget *widget,
+			       TQStyleControlElementData ceData,
+			       ControlElementFlags elementFlags,
 			       const TQRect &r,
 			       const TQColorGroup &cg,
 			       SFlags flags,
-			       const TQStyleOption& opt ) const
+			       const TQStyleOption& opt,
+			       const TQWidget *widget ) const
 {
     switch( element ) {
     case CE_PushButton:
 	{
 #ifndef QT_NO_PUSHBUTTON
  	    int diw, x1, y1, x2, y2;
- 	    const TQPushButton *btn;
 	    TQColorGroup newCg = cg;
- 	    btn = ( const TQPushButton * )widget;
  	    p->setPen( cg.foreground() );
  	    p->setBrush( TQBrush( cg.button(), NoBrush ) );
- 	    diw = pixelMetric( PM_ButtonDefaultIndicator );
+ 	    diw = pixelMetric( PM_ButtonDefaultIndicator, ceData, elementFlags );
  	    r.coords( &x1, &y1, &x2, &y2 );
- 	    if ( btn->isDefault() || btn->autoDefault() ) {
+ 	    if ((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault)) {
  		x1 += diw;
  		y1 += diw;
  		x2 -= diw;
  		y2 -= diw;
  	    }
  	    TQBrush fill;
- 	    if ( btn->isDown() )
+ 	    if ( elementFlags & CEF_IsDown )
  		fill = newCg.brush( TQColorGroup::Mid );
- 	    else if ( btn->isOn() )
+ 	    else if ( elementFlags & CEF_IsOn )
  		fill = TQBrush( newCg.mid(), Dense4Pattern );
  	    else
  		fill = newCg.brush( TQColorGroup::Button );
 
 	    newCg.setBrush( TQColorGroup::Button, fill );
- 	    if ( btn->isDefault() ) {
+ 	    if ( elementFlags & CEF_IsDefault ) {
  		if ( diw == 0 ) {
 		    TQPointArray a;
 		    a.setPoints( 9,
@@ -819,17 +821,17 @@ void TQMotifStyle::drawControl( ControlElement element,
  		    qDrawShadePanel( p, r, newCg, TRUE );
  		}
  	    }
- 	    if ( !btn->isFlat() || btn->isOn() || btn->isDown() ) {
+ 	    if ( !( elementFlags & CEF_IsFlat ) || ( elementFlags & CEF_IsOn ) || ( elementFlags & CEF_IsDown ) ) {
 		TQRect tmp( x1, y1, x2 - x1 + 1, y2 - y1 + 1 );
 		SFlags flags = Style_Default;
-		if ( btn->isOn())
+		if ( elementFlags & CEF_IsOn )
 		    flags |= Style_On;
-		if (btn->isDown())
+		if ( elementFlags & CEF_IsDown )
 		    flags |= Style_Down;
 		p->save();
-		p->setBrushOrigin( -widget->backgroundOffset().x(),
-				   -widget->backgroundOffset().y() );
-		drawPrimitive( PE_ButtonCommand, p,
+		p->setBrushOrigin( -ceData.bgOffset.x(),
+				   -ceData.bgOffset.y() );
+		drawPrimitive( PE_ButtonCommand, p, ceData, elementFlags,
 			       tmp, newCg,
  			       flags );
 		p->restore();
@@ -843,47 +845,46 @@ void TQMotifStyle::drawControl( ControlElement element,
     case CE_TabBarTab:
 	{
 #ifndef QT_NO_TABBAR
-	    if ( !widget || !widget->parentWidget() || !opt.tab() )
+	    if ( (elementFlags & CEF_UseGenericParameters) || !(elementFlags & CEF_HasParentWidget) || !opt.tab() )
 		break;
 
-	    const TQTabBar * tb = (const TQTabBar *) widget;
 	    const TQTab * t = opt.tab();
 
-	    int dfw = pixelMetric( PM_DefaultFrameWidth, tb );
+	    int dfw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget );
 	    bool selected = flags & Style_Selected;
 	    int o =  dfw > 1 ? 1 : 0;
 	    bool lastTab = FALSE;
 
 	    TQRect r2( r );
-	    if ( tb->shape() == TQTabBar::RoundedAbove ) {
-		if ( styleHint( SH_TabBar_Alignment, tb ) == AlignRight &&
-		     tb->indexOf( t->identifier() ) == tb->count()-1 )
+	    if ( ceData.tabBarData.shape == TQTabBar::RoundedAbove ) {
+		if ( styleHint( SH_TabBar_Alignment, ceData, elementFlags, TQStyleOption::Default, 0, widget ) == AlignRight &&
+		     ceData.tabBarData.identIndexMap[t->identifier()] == ceData.tabBarData.tabCount-1 )
 		    lastTab = TRUE;
 
 		if ( o ) {
-		    p->setPen( tb->colorGroup().light() );
+		    p->setPen( ceData.colorGroup.light() );
 		    p->drawLine( r2.left(), r2.bottom(), r2.right(), r2.bottom() );
-		    p->setPen( tb->colorGroup().light() );
+		    p->setPen( ceData.colorGroup.light() );
 		    p->drawLine( r2.left(), r2.bottom()-1, r2.right(), r2.bottom()-1 );
 		    if ( r2.left() == 0 )
-			p->drawPoint( tb->rect().bottomLeft() );
+			p->drawPoint( ceData.rect.bottomLeft() );
 		}
 		else {
-		    p->setPen( tb->colorGroup().light() );
+		    p->setPen( ceData.colorGroup.light() );
 		    p->drawLine( r2.left(), r2.bottom(), r2.right(), r2.bottom() );
 		}
 
 		if ( selected ) {
 		    p->fillRect( TQRect( r2.left()+1, r2.bottom()-o, r2.width()-3, 2),
-				 tb->palette().active().brush( TQColorGroup::Background ));
-		    p->setPen( tb->colorGroup().background() );
+				 ceData.palette.active().brush( TQColorGroup::Background ));
+		    p->setPen( ceData.colorGroup.background() );
 		    // p->drawLine( r2.left()+1, r2.bottom(), r2.right()-2, r2.bottom() );
 		    // if (o)
 		    // p->drawLine( r2.left()+1, r2.bottom()-1, r2.right()-2, r2.bottom()-1 );
 		    p->drawLine( r2.left()+1, r2.bottom(), r2.left()+1, r2.top()+2 );
-		    p->setPen( tb->colorGroup().light() );
+		    p->setPen( ceData.colorGroup.light() );
 		} else {
-		    p->setPen( tb->colorGroup().light() );
+		    p->setPen( ceData.colorGroup.light() );
 		    r2.setRect( r2.left() + 2, r2.top() + 2,
 				r2.width() - 4, r2.height() - 2 );
 		}
@@ -900,7 +901,7 @@ void TQMotifStyle::drawControl( ControlElement element,
 				 r2.right() - 2, r2.top()+1 );
 		}
 
-		p->setPen( tb->colorGroup().dark() );
+		p->setPen( ceData.colorGroup.dark() );
 		p->drawLine( r2.right() - 1, r2.top() + 2,
 			     r2.right() - 1, r2.bottom() - 1 + (selected ? o : -o));
 		if ( o ) {
@@ -910,19 +911,19 @@ void TQMotifStyle::drawControl( ControlElement element,
 				 (selected ? (lastTab ? 0:1):1+o));
 		    p->drawPoint( r2.right() - 1, r2.top() + 1 );
 		}
-	    } else if ( tb->shape()  == TQTabBar::RoundedBelow ) {
-		if ( styleHint( SH_TabBar_Alignment, tb ) == AlignLeft &&
-		     tb->indexOf( t->identifier() ) == tb->count()-1 )
+	    } else if ( ceData.tabBarData.shape  == TQTabBar::RoundedBelow ) {
+		if ( styleHint( SH_TabBar_Alignment, ceData, elementFlags, TQStyleOption::Default, 0, widget ) == AlignLeft &&
+		     ceData.tabBarData.identIndexMap[t->identifier()] == ceData.tabBarData.tabCount-1 )
 		    lastTab = TRUE;
 		if ( selected ) {
 		    p->fillRect( TQRect( r2.left()+1, r2.top(), r2.width()-3, 1),
-				 tb->palette().active().brush( TQColorGroup::Background ));
-		    p->setPen( tb->colorGroup().background() );
+				 ceData.palette.active().brush( TQColorGroup::Background ));
+		    p->setPen( ceData.colorGroup.background() );
 		    // p->drawLine( r2.left()+1, r2.top(), r2.right()-2, r2.top() );
 		    p->drawLine( r2.left()+1, r2.top(), r2.left()+1, r2.bottom()-2 );
-		    p->setPen( tb->colorGroup().dark() );
+		    p->setPen( ceData.colorGroup.dark() );
 		} else {
-		    p->setPen( tb->colorGroup().dark() );
+		    p->setPen( ceData.colorGroup.dark() );
 		    p->drawLine( r2.left(), r2.top(), r2.right(), r2.top() );
 		    p->drawLine( r2.left() + 1, r2.top() + 1,
 				 r2.right() - (lastTab ? 0 : 2),
@@ -946,14 +947,14 @@ void TQMotifStyle::drawControl( ControlElement element,
 				 r2.left() + 2, r2.bottom() );
 		}
 
-		p->setPen( tb->colorGroup().light() );
+		p->setPen( ceData.colorGroup.light() );
 		p->drawLine( r2.left(), r2.top() + (selected ? 0 : 2),
 			     r2.left(), r2.bottom() - 2 );
 		p->drawLine( r2.left() + 1, r2.top() + (selected ? 0 : 2),
 			     r2.left() + 1, r2.bottom() - 3 );
 
 	    } else {
-		TQCommonStyle::drawControl( element, p, widget, r, cg, flags, opt );
+		TQCommonStyle::drawControl( element, p, ceData, elementFlags, r, cg, flags, opt, widget );
 	    }
 #endif
 	    break;
@@ -966,32 +967,31 @@ void TQMotifStyle::drawControl( ControlElement element,
     case CE_ProgressBarLabel:
 	{
 #ifndef QT_NO_PROGRESSBAR
-	    const TQProgressBar * pb = (const TQProgressBar *) widget;
-	    const int unit_width = pixelMetric( PM_ProgressBarChunkWidth, pb );
+	    const int unit_width = pixelMetric( PM_ProgressBarChunkWidth, ceData, elementFlags, widget );
 	    int u = r.width() / unit_width;
-	    int p_v = pb->progress();
-	    int t_s = pb->totalSteps();
-	    if ( u > 0 && pb->progress() >= INT_MAX / u && t_s >= u ) {
+	    int p_v = ceData.currentStep;
+	    int t_s = ceData.totalSteps;
+	    if ( u > 0 && ceData.currentStep >= INT_MAX / u && t_s >= u ) {
 		// scale down to something usable.
 		p_v /= u;
 		t_s /= u;
 	    }
-	    if ( pb->percentageVisible() && pb->totalSteps() ) {
+	    if ( ceData.percentageVisible && ceData.totalSteps ) {
 		int nu = ( u * p_v + t_s/2 ) / t_s;
 		int x = unit_width * nu;
-		if (pb->indicatorFollowsStyle() || pb->centerIndicator()) {
+		if ((elementFlags & CEF_IndicatorFollowsStyle) || (elementFlags & CEF_CenterIndicator)) {
 		    p->setPen( cg.highlightedText() );
 		    p->setClipRect( r.x(), r.y(), x, r.height() );
-		    p->drawText( r, AlignCenter | SingleLine, pb->progressString() );
+		    p->drawText( r, AlignCenter | SingleLine, ceData.progressText );
 
-		    if ( pb->progress() != pb->totalSteps() ) {
+		    if ( ceData.currentStep != ceData.totalSteps ) {
 			p->setClipRect( r.x() + x, r.y(), r.width() - x, r.height() );
 			p->setPen( cg.highlight() );
-			p->drawText( r, AlignCenter | SingleLine, pb->progressString() );
+			p->drawText( r, AlignCenter | SingleLine, ceData.progressText );
 		    }
 		} else {
 		    p->setPen( cg.text() );
-		    p->drawText( r, AlignCenter | SingleLine, pb->progressString() );
+		    p->drawText( r, AlignCenter | SingleLine, ceData.progressText );
 		}
 	    }
 #endif
@@ -1001,10 +1001,9 @@ void TQMotifStyle::drawControl( ControlElement element,
 #ifndef QT_NO_POPUPMENU
     case CE_PopupMenuItem:
 	{
-	    if (! widget || opt.isDefault())
+	    if ((elementFlags & CEF_UseGenericParameters) || opt.isDefault())
 		break;
 
-	    const TQPopupMenu *popupmenu = (const TQPopupMenu *) widget;
 	    TQMenuItem *mi = opt.menuItem();
 	    if ( !mi )
 		break;
@@ -1012,7 +1011,7 @@ void TQMotifStyle::drawControl( ControlElement element,
 	    int tab = opt.tabWidth();
 	    int maxpmw = opt.maxIconWidth();
 	    bool dis = ! (flags & Style_Enabled);
-	    bool checkable = popupmenu->isCheckable();
+	    bool checkable = (elementFlags & CEF_IsCheckable);
 	    bool act = flags & Style_Active;
 	    int x, y, w, h;
 
@@ -1034,7 +1033,7 @@ void TQMotifStyle::drawControl( ControlElement element,
 	    int pw = motifItemFrame;
 
 	    if ( act && !dis ) {                        // active item frame
-		if (pixelMetric( PM_DefaultFrameWidth ) > 1)
+		if (pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags ) > 1)
 		    qDrawShadePanel( p, x, y, w, h, cg, FALSE, pw,
 				     &cg.brush( TQColorGroup::Button ) );
 		else
@@ -1086,7 +1085,7 @@ void TQMotifStyle::drawControl( ControlElement element,
 		    if (act)
 			cflags |= Style_On;
 
-		    drawPrimitive(PE_CheckMark, p,
+		    drawPrimitive(PE_CheckMark, p, ceData, elementFlags,
 				  TQRect(xvis, y+motifItemFrame, mw, mh),
 				  cg, cflags);
 		}
@@ -1140,11 +1139,11 @@ void TQMotifStyle::drawControl( ControlElement element,
 		TQRect vr = visualRect( TQRect(x+w - motifArrowHMargin - motifItemFrame - dim,
 					y+h/2-dim/2, dim, dim), r );
 		if ( act )
-		    drawPrimitive(arrow, p, vr, cg,
+		    drawPrimitive(arrow, p, ceData, elementFlags, vr, cg,
 				  (Style_Down |
 				  (dis ? Style_Default : Style_Enabled)) );
 		else
-		    drawPrimitive(arrow, p, vr, cg,
+		    drawPrimitive(arrow, p, ceData, elementFlags, vr, cg,
 				  (dis ? Style_Default : Style_Enabled));
 	    }
 
@@ -1159,12 +1158,12 @@ void TQMotifStyle::drawControl( ControlElement element,
 				 &cg.brush(TQColorGroup::Button) );
 	    else  // other item
 		p->fillRect( r, cg.brush(TQColorGroup::Button) );
-	    TQCommonStyle::drawControl( element, p, widget, r, cg, flags, opt );
+	    TQCommonStyle::drawControl( element, p, ceData, elementFlags, r, cg, flags, opt, widget );
 	    break;
 	}
 
     default:
-	TQCommonStyle::drawControl( element, p, widget, r, cg, flags, opt );
+	TQCommonStyle::drawControl( element, p, ceData, elementFlags, r, cg, flags, opt, widget );
 	break;
     }
 }
@@ -1220,20 +1219,22 @@ static void get_combo_parameters( const TQRect &r,
 */
 void TQMotifStyle::drawComplexControl( ComplexControl control,
 				     TQPainter *p,
-				     const TQWidget *widget,
+				     TQStyleControlElementData ceData,
+				     ControlElementFlags elementFlags,
 				     const TQRect &r,
 				     const TQColorGroup &cg,
 				     SFlags flags,
 				     SCFlags sub,
 				     SCFlags subActive,
-				     const TQStyleOption& opt ) const
+				     const TQStyleOption& opt,
+				     const TQWidget *widget ) const
 {
     switch ( control ) {
     case CC_SpinWidget: {
 	SCFlags drawSub = SC_None;
 	if ( sub & SC_SpinWidgetFrame )
 	    qDrawShadePanel( p, r, cg, TRUE,
-			     pixelMetric( PM_DefaultFrameWidth) );
+			     pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags ) );
 
 	if ( sub & SC_SpinWidgetUp || sub & SC_SpinWidgetDown ) {
 	    if ( sub & SC_SpinWidgetUp )
@@ -1241,20 +1242,18 @@ void TQMotifStyle::drawComplexControl( ComplexControl control,
 	    if ( sub & SC_SpinWidgetDown )
 		drawSub |= SC_SpinWidgetDown;
 
-	    TQCommonStyle::drawComplexControl( control, p, widget, r, cg, flags,
-					      drawSub, subActive, opt );
+	    TQCommonStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg, flags,
+					      drawSub, subActive, opt, widget );
 	}
 	break; }
 
     case CC_Slider:
 	{
 #ifndef QT_NO_SLIDER
-	    const TQSlider * slider = (const TQSlider *) widget;
-
-	    TQRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
-						  opt),
-		  handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
-						  opt);
+	    TQRect groove = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderGroove,
+						  opt, widget),
+		  handle = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderHandle,
+						  opt, widget);
 
 	    if ((sub & SC_SliderGroove) && groove.isValid()) {
 		qDrawShadePanel( p, groove, cg, TRUE, 2,
@@ -1262,15 +1261,15 @@ void TQMotifStyle::drawComplexControl( ComplexControl control,
 
 
 		if ( flags & Style_HasFocus ) {
-		    TQRect fr = subRect( SR_SliderFocusRect, widget );
-		    drawPrimitive( PE_FocusRect, p, fr, cg );
+		    TQRect fr = subRect( SR_SliderFocusRect, ceData, elementFlags, widget );
+		    drawPrimitive( PE_FocusRect, p, ceData, elementFlags, fr, cg );
 		}
 	    }
 
 	    if (( sub & SC_SliderHandle ) && handle.isValid()) {
-		drawPrimitive( PE_ButtonBevel, p, handle, cg );
+		drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, handle, cg );
 
-		if ( slider->orientation() == Horizontal ) {
+		if ( ceData.orientation == Horizontal ) {
 		    TQCOORD mid = handle.x() + handle.width() / 2;
 		    qDrawShadeLine( p, mid, handle.y(), mid,
 				    handle.y() + handle.height() - 2,
@@ -1284,9 +1283,9 @@ void TQMotifStyle::drawComplexControl( ComplexControl control,
 	    }
 
 	    if ( sub & SC_SliderTickmarks )
-		TQCommonStyle::drawComplexControl( control, p, widget, r, cg, flags,
+		TQCommonStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg, flags,
 						  SC_SliderTickmarks, subActive,
-						  opt );
+						  opt, widget );
 #endif
 	    break;
 	}
@@ -1296,12 +1295,12 @@ void TQMotifStyle::drawComplexControl( ComplexControl control,
 	if ( sub & SC_ComboBoxArrow ) {
 	    const TQComboBox * cb = (const TQComboBox *) widget;
 	    int awh, ax, ay, sh, sy, dh, ew;
-	    int fw = pixelMetric( PM_DefaultFrameWidth, cb);
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, cb);
 
-	    drawPrimitive( PE_ButtonCommand, p, r, cg, flags );
-	    TQRect ar = TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, cb, SC_ComboBoxArrow,
-								   opt ), cb );
-	    drawPrimitive( PE_ArrowDown, p, ar, cg, flags | Style_Enabled );
+	    drawPrimitive( PE_ButtonCommand, p, ceData, elementFlags, r, cg, flags );
+	    TQRect ar = TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, ceData, elementFlags, SC_ComboBoxArrow,
+								   opt, cb ), ceData, elementFlags );
+	    drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, ar, cg, flags | Style_Enabled );
 
 	    TQRect tr = r;
 	    tr.addCoords( fw, fw, -fw, -fw );
@@ -1316,16 +1315,16 @@ void TQMotifStyle::drawComplexControl( ComplexControl control,
 	    p->drawLine( ar.x()+awh-1, sy+1, ar.x()+awh-1, sy+sh-1 );
 
 	    if ( cb->hasFocus() ) {
-		TQRect re = TQStyle::visualRect( subRect( SR_ComboBoxFocusRect, cb ), cb );
-		drawPrimitive( PE_FocusRect, p, re, cg );
+		TQRect re = TQStyle::visualRect( subRect( SR_ComboBoxFocusRect, ceData, elementFlags, cb ), ceData, elementFlags );
+		drawPrimitive( PE_FocusRect, p, ceData, elementFlags, re, cg );
 	    }
 	}
 
 	if ( sub & SC_ComboBoxEditField ) {
 	    TQComboBox * cb = (TQComboBox *) widget;
 	    if ( cb->editable() ) {
-		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, cb,
-								       SC_ComboBoxEditField ), cb );
+		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, ceData, elementFlags,
+								       SC_ComboBoxEditField, cb ), ceData, elementFlags );
 		er.addCoords( -1, -1, 1, 1);
 		qDrawShadePanel( p, er, cg, TRUE, 1,
 				 &cg.brush( TQColorGroup::Button ));
@@ -1340,11 +1339,11 @@ void TQMotifStyle::drawComplexControl( ComplexControl control,
 	    if (sub == (SC_ScrollBarAddLine | SC_ScrollBarSubLine | SC_ScrollBarAddPage |
 			SC_ScrollBarSubPage | SC_ScrollBarFirst | SC_ScrollBarLast |
 			SC_ScrollBarSlider))
-		qDrawShadePanel(p, widget->rect(), cg, TRUE,
-				pixelMetric(PM_DefaultFrameWidth, widget),
+		qDrawShadePanel(p, ceData.rect, cg, TRUE,
+				pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget),
 				&cg.brush(TQColorGroup::Mid));
-	    TQCommonStyle::drawComplexControl(control, p, widget, r, cg, flags, sub,
-					     subActive, opt);
+	    TQCommonStyle::drawComplexControl(control, p, ceData, elementFlags, r, cg, flags, sub,
+					     subActive, opt, widget);
 	    break;
 	}
 
@@ -1352,7 +1351,7 @@ void TQMotifStyle::drawComplexControl( ComplexControl control,
     case CC_ListView:
 	{
 	    if ( sub & SC_ListView ) {
-		TQCommonStyle::drawComplexControl( control, p, widget, r, cg, flags, sub, subActive, opt );
+		TQCommonStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg, flags, sub, subActive, opt, widget );
 	    }
 	    if ( sub & ( SC_ListViewBranch | SC_ListViewExpand ) ) {
 		if (opt.isDefault())
@@ -1455,14 +1454,14 @@ void TQMotifStyle::drawComplexControl( ComplexControl control,
 #endif // QT_NO_LISTVIEW
 
     default:
-	TQCommonStyle::drawComplexControl( control, p, widget, r, cg, flags,
-					  sub, subActive, opt );
+	TQCommonStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg, flags,
+					  sub, subActive, opt, widget );
     }
 }
 
 
 /*! \reimp */
-int TQMotifStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) const
+int TQMotifStyle::pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const
 {
      int ret;
 
@@ -1519,9 +1518,9 @@ int TQMotifStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) cons
 #ifndef QT_NO_SLIDER
 	    const TQSlider * sl = (const TQSlider *) widget;
 	    if ( sl->orientation() == Horizontal )
-		ret = sl->width() - pixelMetric( PM_SliderLength, sl ) - 6;
+		ret = sl->width() - pixelMetric( PM_SliderLength, ceData, elementFlags, sl ) - 6;
 	    else
-		ret = sl->height() - pixelMetric( PM_SliderLength, sl ) - 6;
+		ret = sl->height() - pixelMetric( PM_SliderLength, ceData, elementFlags, sl ) - 6;
 #endif
 	    break;
 	}
@@ -1540,7 +1539,7 @@ int TQMotifStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) cons
 	break;
 
     default:
-	ret =  TQCommonStyle::pixelMetric( metric, widget );
+	ret =  TQCommonStyle::pixelMetric( metric, ceData, elementFlags, widget );
 	break;
     }
     return ret;
@@ -1550,24 +1549,26 @@ int TQMotifStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) cons
 /*!\reimp
 */
 TQRect TQMotifStyle::querySubControlMetrics( ComplexControl control,
-					   const TQWidget *widget,
+					   TQStyleControlElementData ceData,
+					   ControlElementFlags elementFlags,
 					   SubControl sc,
-					   const TQStyleOption& opt ) const
+					   const TQStyleOption& opt,
+					   const TQWidget *widget ) const
 {
     switch ( control ) {
     case CC_SpinWidget: {
-	if ( !widget )
+	if ( elementFlags & CEF_UseGenericParameters )
 	    return TQRect();
-	int fw = pixelMetric( PM_SpinBoxFrameWidth, 0 );
+	int fw = pixelMetric( PM_SpinBoxFrameWidth, ceData, elementFlags, 0 );
 	TQSize bs;
-	bs.setHeight( widget->height()/2 );
+	bs.setHeight( ceData.rect.height()/2 );
 	if ( bs.height() < 8 )
 	    bs.setHeight( 8 );
-	bs.setWidth( TQMIN( bs.height() * 8 / 5, widget->width() / 4 ) ); // 1.6 -approximate golden mean
+	bs.setWidth( TQMIN( bs.height() * 8 / 5, ceData.rect.width() / 4 ) ); // 1.6 -approximate golden mean
 	bs = bs.expandedTo( TQApplication::globalStrut() );
 	int y = 0;
 	int x, lx, rx;
-	x = widget->width() - y - bs.width();
+	x = ceData.rect.width() - y - bs.width();
 	lx = fw;
 	rx = x - fw * 2;
 	switch ( sc ) {
@@ -1576,12 +1577,12 @@ TQRect TQMotifStyle::querySubControlMetrics( ComplexControl control,
 	case SC_SpinWidgetDown:
 	    return TQRect(x, y + bs.height(), bs.width(), bs.height());
 	case SC_SpinWidgetButtonField:
-	    return TQRect(x, y, bs.width(), widget->height() - 2*fw);
+	    return TQRect(x, y, bs.width(), ceData.rect.height() - 2*fw);
 	case SC_SpinWidgetEditField:
-	    return TQRect(lx, fw, rx, widget->height() - 2*fw);
+	    return TQRect(lx, fw, rx, ceData.rect.height() - 2*fw);
 	case SC_SpinWidgetFrame:
 	    return TQRect( 0, 0,
-			  widget->width() - bs.width(), widget->height() );
+			  ceData.rect.width() - bs.width(), ceData.rect.height() );
 	default:
 	    break;
 	}
@@ -1590,14 +1591,13 @@ TQRect TQMotifStyle::querySubControlMetrics( ComplexControl control,
 #ifndef QT_NO_SLIDER
     case CC_Slider: {
 	if (sc == SC_SliderHandle) {
-	    const TQSlider * sl = (const TQSlider *) widget;
-	    int tickOffset  = pixelMetric( PM_SliderTickmarkOffset, sl );
-	    int thickness   = pixelMetric( PM_SliderControlThickness, sl );
-	    int sliderPos   = sl->sliderStart();
-	    int len         = pixelMetric( PM_SliderLength, sl );
+	    int tickOffset  = pixelMetric( PM_SliderTickmarkOffset, ceData, elementFlags, widget );
+	    int thickness   = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
+	    int sliderPos   = ceData.startStep;
+	    int len         = pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
 	    int motifBorder = 3;
 
-	    if ( sl->orientation() == Horizontal )
+	    if ( ceData.orientation == Horizontal )
 		return TQRect( sliderPos + motifBorder, tickOffset + motifBorder, len,
 			      thickness - 2*motifBorder );
 	    return TQRect( tickOffset + motifBorder, sliderPos + motifBorder,
@@ -1608,25 +1608,24 @@ TQRect TQMotifStyle::querySubControlMetrics( ComplexControl control,
 
 #ifndef QT_NO_SCROLLBAR
     case CC_ScrollBar: {
-	if (! widget)
+	if (elementFlags & CEF_UseGenericParameters)
 	    return TQRect();
 
-	const TQScrollBar *scrollbar = (const TQScrollBar *) widget;
-	int sliderstart = scrollbar->sliderStart();
-	int sbextent = pixelMetric(PM_ScrollBarExtent, widget);
-	int fw = pixelMetric(PM_DefaultFrameWidth, widget);
+	int sliderstart = ceData.startStep;
+	int sbextent = pixelMetric(PM_ScrollBarExtent, ceData, elementFlags, widget);
+	int fw = pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags, widget);
 	int buttonw = sbextent - (fw * 2);
 	int buttonh = sbextent - (fw * 2);
-	int maxlen = ((scrollbar->orientation() == TQt::Horizontal) ?
-		      scrollbar->width() : scrollbar->height()) -
+	int maxlen = ((ceData.orientation == TQt::Horizontal) ?
+		      ceData.rect.width() : ceData.rect.height()) -
 		     (buttonw * 2) - (fw * 2);
 	int sliderlen;
 
 	// calculate slider length
-	if (scrollbar->maxValue() != scrollbar->minValue()) {
-	    uint range = scrollbar->maxValue() - scrollbar->minValue();
-	    sliderlen = (scrollbar->pageStep() * maxlen) /
-			(range + scrollbar->pageStep());
+	if (ceData.maxSteps != ceData.minSteps) {
+	    uint range = ceData.maxSteps - ceData.minSteps;
+	    sliderlen = (ceData.pageStep * maxlen) /
+			(range + ceData.pageStep);
 
 	    if ( sliderlen < 9 || range > INT_MAX/2 )
 		sliderlen = 9;
@@ -1638,47 +1637,47 @@ TQRect TQMotifStyle::querySubControlMetrics( ComplexControl control,
 	switch (sc) {
 	case SC_ScrollBarSubLine:
 	    // top/left button
-	    if (scrollbar->orientation() == TQt::Horizontal) {
-		if ( scrollbar->width()/2 < sbextent )
-		    buttonw = scrollbar->width()/2 - (fw*2);
+	    if (ceData.orientation == TQt::Horizontal) {
+		if ( ceData.rect.width()/2 < sbextent )
+		    buttonw = ceData.rect.width()/2 - (fw*2);
 		return TQRect(fw, fw, buttonw, buttonh);
 	    } else {
-		if ( scrollbar->height()/2 < sbextent )
-		    buttonh = scrollbar->height()/2 - (fw*2);
+		if ( ceData.rect.height()/2 < sbextent )
+		    buttonh = ceData.rect.height()/2 - (fw*2);
 		return TQRect(fw, fw, buttonw, buttonh);
 	    }
 	case SC_ScrollBarAddLine:
 	    // bottom/right button
-	    if (scrollbar->orientation() == TQt::Horizontal) {
-		if ( scrollbar->width()/2 < sbextent )
-		    buttonw = scrollbar->width()/2 - (fw*2);
-		return TQRect(scrollbar->width() - buttonw - fw, fw,
+	    if (ceData.orientation == TQt::Horizontal) {
+		if ( ceData.rect.width()/2 < sbextent )
+		    buttonw = ceData.rect.width()/2 - (fw*2);
+		return TQRect(ceData.rect.width() - buttonw - fw, fw,
 			     buttonw, buttonh);
 	    } else {
-		if ( scrollbar->height()/2 < sbextent )
-		    buttonh = scrollbar->height()/2 - (fw*2);
-		return TQRect(fw, scrollbar->height() - buttonh - fw,
+		if ( ceData.rect.height()/2 < sbextent )
+		    buttonh = ceData.rect.height()/2 - (fw*2);
+		return TQRect(fw, ceData.rect.height() - buttonh - fw,
 			     buttonw, buttonh);
 	    }
 	case SC_ScrollBarSubPage:
-	    if (scrollbar->orientation() == TQt::Horizontal)
+	    if (ceData.orientation == TQt::Horizontal)
 		return TQRect(buttonw + fw, fw, sliderstart - buttonw - fw, buttonw);
 	    return TQRect(fw, buttonw + fw, buttonw, sliderstart - buttonw - fw);
 
 	case SC_ScrollBarAddPage:
-	    if (scrollbar->orientation() == TQt::Horizontal)
+	    if (ceData.orientation == TQt::Horizontal)
 		return TQRect(sliderstart + sliderlen, fw,
 			     maxlen - sliderstart - sliderlen + buttonw + fw, buttonw);
 	    return TQRect(fw, sliderstart + sliderlen, buttonw,
 			 maxlen - sliderstart - sliderlen + buttonw + fw);
 
 	case SC_ScrollBarGroove:
-	    if (scrollbar->orientation() == TQt::Horizontal)
+	    if (ceData.orientation == TQt::Horizontal)
 		return TQRect(buttonw + fw, fw, maxlen, buttonw);
 	    return TQRect(fw, buttonw + fw, buttonw, maxlen);
 
 	case SC_ScrollBarSlider:
-	    if (scrollbar->orientation() == TQt::Horizontal)
+	    if (ceData.orientation == TQt::Horizontal)
 		return TQRect(sliderstart, fw, sliderlen, buttonw);
 	    return TQRect(fw, sliderstart, buttonw, sliderlen);
 
@@ -1693,18 +1692,16 @@ TQRect TQMotifStyle::querySubControlMetrics( ComplexControl control,
 
 	switch ( sc ) {
 	case SC_ComboBoxArrow: {
-	    const TQComboBox * cb = (const TQComboBox *) widget;
 	    int ew, awh, sh, dh, ax, ay, sy;
-	    int fw = pixelMetric( PM_DefaultFrameWidth, cb );
-	    TQRect cr = cb->rect();
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget );
+	    TQRect cr = ceData.rect;
 	    cr.addCoords( fw, fw, -fw, -fw );
 	    get_combo_parameters( cr, ew, awh, ax, ay, sh, dh, sy );
 	    return TQRect( ax, ay, awh, awh ); }
 
 	case SC_ComboBoxEditField: {
-	    const TQComboBox * cb = (const TQComboBox *) widget;
-	    int fw = pixelMetric( PM_DefaultFrameWidth, cb );
-	    TQRect rect = cb->rect();
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget );
+	    TQRect rect = ceData.rect;
 	    rect.addCoords( fw, fw, -fw, -fw );
 	    int ew = get_combo_extra_width( rect.height(), rect.width() );
 	    rect.addCoords( 1, 1, -1-ew, -1 );
@@ -1717,15 +1714,17 @@ TQRect TQMotifStyle::querySubControlMetrics( ComplexControl control,
 #endif
     default: break;
     }
-    return TQCommonStyle::querySubControlMetrics( control, widget, sc, opt );
+    return TQCommonStyle::querySubControlMetrics( control, ceData, elementFlags, sc, opt, widget );
 }
 
 /*!\reimp
 */
 TQSize TQMotifStyle::sizeFromContents( ContentsType contents,
-				     const TQWidget *widget,
+				     TQStyleControlElementData ceData,
+				     ControlElementFlags elementFlags,
 				     const TQSize &contentsSize,
-				     const TQStyleOption& opt ) const
+				     const TQStyleOption& opt,
+				     const TQWidget *widget ) const
 {
     TQSize sz(contentsSize);
 
@@ -1733,10 +1732,9 @@ TQSize TQMotifStyle::sizeFromContents( ContentsType contents,
     case CT_PushButton:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
-	    sz = TQCommonStyle::sizeFromContents(contents, widget, contentsSize, opt);
-	    if ((button->isDefault() || button->autoDefault()) &&
-		sz.width() < 80 && ! button->pixmap())
+	    sz = TQCommonStyle::sizeFromContents(contents, ceData, elementFlags, contentsSize, opt, widget);
+	    if (((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault)) &&
+		sz.width() < 80 && ceData.fgPixmap.isNull())
 		sz.setWidth(80);
 #endif
 	    break;
@@ -1745,11 +1743,10 @@ TQSize TQMotifStyle::sizeFromContents( ContentsType contents,
     case CT_PopupMenuItem:
 	{
 #ifndef QT_NO_POPUPMENU
-	    if (! widget || opt.isDefault())
+	    if ((elementFlags & CEF_UseGenericParameters) || opt.isDefault())
 		break;
 
-	    const TQPopupMenu *popup = (TQPopupMenu *) widget;
-	    bool checkable = popup->isCheckable();
+	    bool checkable = (elementFlags & CEF_IsCheckable);
 	    TQMenuItem *mi = opt.menuItem();
 	    int maxpmw = opt.maxIconWidth();
 	    int w = sz.width(), h = sz.height();
@@ -1794,7 +1791,7 @@ TQSize TQMotifStyle::sizeFromContents( ContentsType contents,
 	}
 
     default:
-	sz = TQCommonStyle::sizeFromContents( contents, widget, contentsSize, opt );
+	sz = TQCommonStyle::sizeFromContents( contents, ceData, elementFlags, contentsSize, opt, widget );
 	break;
     }
 
@@ -1803,21 +1800,21 @@ TQSize TQMotifStyle::sizeFromContents( ContentsType contents,
 
 /*!\reimp
 */
-TQRect TQMotifStyle::subRect( SubRect r, const TQWidget *widget ) const
+TQRect TQMotifStyle::subRect( SubRect r, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const
 {
     TQRect rect;
-    TQRect wrect = widget->rect();
+    TQRect wrect = ceData.rect;
 
     switch ( r ) {
     case SR_SliderFocusRect:
-	rect = TQCommonStyle::subRect( r, widget );
+	rect = TQCommonStyle::subRect( r, ceData, elementFlags, widget );
 	rect.addCoords( 2, 2, -2, -2 );
 	break;
 
     case SR_ComboBoxFocusRect:
 	{
 	    int awh, ax, ay, sh, sy, dh, ew;
-	    int fw = pixelMetric( PM_DefaultFrameWidth, widget );
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget );
 	    TQRect tr = wrect;
 
 	    tr.addCoords( fw, fw, -fw, -fw );
@@ -1829,17 +1826,16 @@ TQRect TQMotifStyle::subRect( SubRect r, const TQWidget *widget ) const
     case SR_DockWindowHandleRect:
 	{
 #ifndef QT_NO_MAINWINDOW
-	    if ( !widget || !widget->parent() )
+	    if ( (elementFlags & CEF_UseGenericParameters) || !(elementFlags & CEF_HasParentWidget) )
 		break;
 
-	    const TQDockWindow * dw = (const TQDockWindow *) widget->parent();
-	    if ( !dw->area() || !dw->isCloseEnabled() )
-		rect.setRect( 0, 0, widget->width(), widget->height() );
+	    if ( !ceData.dwData.hasDockArea || !ceData.dwData.closeEnabled )
+		rect.setRect( 0, 0, ceData.rect.width(), ceData.rect.height() );
 	    else {
-		if ( dw->area()->orientation() == Horizontal )
-		    rect.setRect(2, 15, widget->width()-2, widget->height() - 15);
+		if ( ceData.dwData.areaOrientation == Horizontal )
+		    rect.setRect(2, 15, ceData.rect.width()-2, ceData.rect.height() - 15);
 		else
-		    rect.setRect(0, 2, widget->width() - 15, widget->height() - 2);
+		    rect.setRect(0, 2, ceData.rect.width() - 15, ceData.rect.height() - 2);
 	    }
 #endif
 	    break;
@@ -1849,15 +1845,14 @@ TQRect TQMotifStyle::subRect( SubRect r, const TQWidget *widget ) const
     case SR_ProgressBarContents:
 	{
 #ifndef QT_NO_PROGRESSBAR
-	    TQFontMetrics fm( ( widget ? widget->fontMetrics() :
+	    TQFontMetrics fm( ( (!(elementFlags & CEF_UseGenericParameters)) ? TQFontMetrics(ceData.font) :
 			       TQApplication::fontMetrics() ) );
-	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
 	    int textw = 0;
-	    if (progressbar->percentageVisible())
+	    if (ceData.percentageVisible)
 		textw = fm.width("100%") + 6;
 
-	    if (progressbar->indicatorFollowsStyle() ||
-		progressbar->centerIndicator())
+	    if ((elementFlags & CEF_IndicatorFollowsStyle) ||
+		(elementFlags & CEF_CenterIndicator))
 		rect = wrect;
 	    else
 		rect.setCoords(wrect.left(), wrect.top(),
@@ -1869,15 +1864,14 @@ TQRect TQMotifStyle::subRect( SubRect r, const TQWidget *widget ) const
     case SR_ProgressBarLabel:
 	{
 #ifndef QT_NO_PROGRESSBAR
-	    TQFontMetrics fm( ( widget ? widget->fontMetrics() :
+	    TQFontMetrics fm( ( (!(elementFlags & CEF_UseGenericParameters)) ? TQFontMetrics(ceData.font) :
 			       TQApplication::fontMetrics() ) );
-	    const TQProgressBar *progressbar = (const TQProgressBar *) widget;
 	    int textw = 0;
-	    if (progressbar->percentageVisible())
+	    if (ceData.percentageVisible)
 		textw = fm.width("100%") + 6;
 
-	    if (progressbar->indicatorFollowsStyle() ||
-		progressbar->centerIndicator())
+	    if ((elementFlags & CEF_IndicatorFollowsStyle) ||
+		(elementFlags & CEF_CenterIndicator))
 		rect = wrect;
 	    else
 		rect.setCoords(wrect.right() - textw, wrect.top(),
@@ -1889,7 +1883,7 @@ TQRect TQMotifStyle::subRect( SubRect r, const TQWidget *widget ) const
     case SR_CheckBoxContents:
 	{
 #ifndef QT_NO_CHECKBOX
-	    TQRect ir = subRect(SR_CheckBoxIndicator, widget);
+	    TQRect ir = subRect(SR_CheckBoxIndicator, ceData, elementFlags, widget);
 	    rect.setRect(ir.right() + 10, wrect.y(),
 			 wrect.width() - ir.width() - 10, wrect.height());
 #endif
@@ -1898,14 +1892,14 @@ TQRect TQMotifStyle::subRect( SubRect r, const TQWidget *widget ) const
 
     case SR_RadioButtonContents:
 	{
-	    TQRect ir = subRect(SR_RadioButtonIndicator, widget);
+	    TQRect ir = subRect(SR_RadioButtonIndicator, ceData, elementFlags, widget);
 	    rect.setRect(ir.right() + 10, wrect.y(),
 			 wrect.width() - ir.width() - 10, wrect.height());
 	    break;
 	}
 
     default:
-	rect = TQCommonStyle::subRect( r, widget );
+	rect = TQCommonStyle::subRect( r, ceData, elementFlags, widget );
     }
 
     return rect;
@@ -2228,8 +2222,10 @@ static const char *const question_xpm[] = {
  \reimp
  */
 TQPixmap TQMotifStyle::stylePixmap(StylePixmap sp,
-				 const TQWidget *widget,
-				 const TQStyleOption& opt) const
+				 TQStyleControlElementData ceData,
+				 ControlElementFlags elementFlags,
+				 const TQStyleOption& opt,
+				 const TQWidget *widget) const
 {
 #ifndef QT_NO_IMAGEIO_XPM
     switch (sp) {
@@ -2306,15 +2302,17 @@ TQPixmap TQMotifStyle::stylePixmap(StylePixmap sp,
     }
 #endif
 
-    return TQCommonStyle::stylePixmap(sp, widget, opt);
+    return TQCommonStyle::stylePixmap(sp, ceData, elementFlags, opt, widget);
 }
 
 
 /*! \reimp */
 int TQMotifStyle::styleHint(StyleHint hint,
-			   const TQWidget *widget,
+			   TQStyleControlElementData ceData,
+			   ControlElementFlags elementFlags,
 			   const TQStyleOption &opt,
-			   TQStyleHintReturn *returnData) const
+			   TQStyleHintReturn *returnData,
+			   const TQWidget *widget) const
 {
     int ret;
 
@@ -2348,7 +2346,7 @@ int TQMotifStyle::styleHint(StyleHint hint,
 	break;
 
     default:
-	ret = TQCommonStyle::styleHint(hint, widget, opt, returnData);
+	ret = TQCommonStyle::styleHint(hint, ceData, elementFlags, opt, returnData, widget);
 	break;
     }
 
diff --git a/src/styles/qplatinumstyle.cpp b/src/styles/qplatinumstyle.cpp
index 8f9f9ab7..2bc0e459 100644
--- a/src/styles/qplatinumstyle.cpp
+++ b/src/styles/qplatinumstyle.cpp
@@ -86,6 +86,8 @@ TQPlatinumStyle::~TQPlatinumStyle()
  */
 void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
 				    TQPainter *p,
+				    TQStyleControlElementData ceData,
+				    ControlElementFlags elementFlags,
 				    const TQRect &r,
 				    const TQColorGroup &cg,
 				    SFlags flags,
@@ -98,7 +100,7 @@ void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
 	    // sunken...
 	    if ( flags & Style_Sunken )
 		flags ^= Style_Sunken;
-	    drawPrimitive( PE_ButtonBevel, p, r, cg, flags, opt );
+	    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, r, cg, flags, opt );
 	    break;
 	}
     case PE_ButtonTool:
@@ -115,7 +117,7 @@ void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
 
 	    fill = myCG.brush( TQColorGroup::Button );
 	    myCG.setBrush( TQColorGroup::Mid, fill );
-	    drawPrimitive( PE_ButtonBevel, p, r, myCG, flags, opt );
+	    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, r, myCG, flags, opt );
 	    break;
 	}
     case PE_ButtonBevel:
@@ -450,7 +452,7 @@ void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
 	}
     case PE_Indicator:
 	{
-	    drawPrimitive( PE_ButtonBevel, p, TQRect(r.x(), r.y(),
+	    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, TQRect(r.x(), r.y(),
 						    r.width() - 2, r.height()),
 			   cg, flags );
 	    p->fillRect( r.x() + r.width() - 2, r.y(), 2, r.height(),
@@ -606,14 +608,14 @@ void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
 	}
     case PE_ScrollBarAddLine:
 	{
-	    drawPrimitive( PE_ButtonBevel, p, r, cg,
+	    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, r, cg,
 			   (flags & Style_Enabled) | ((flags & Style_Down)
 						      ? Style_Sunken
 						      : Style_Raised) );
 	    p->setPen( cg.shadow() );
 	    p->drawRect( r );
 	    drawPrimitive( ((flags & Style_Horizontal) ? PE_ArrowRight
-			    : PE_ArrowDown), p, TQRect(r.x() + 2,
+			    : PE_ArrowDown), p, ceData, elementFlags, TQRect(r.x() + 2,
 						      r.y() + 2,
 						      r.width() - 4,
 						      r.height() - 4),
@@ -622,14 +624,14 @@ void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
 	}
     case PE_ScrollBarSubLine:
 	{
-	    drawPrimitive( PE_ButtonBevel, p, r, cg,
+	    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, r, cg,
 			   (flags & Style_Enabled) | ((flags & Style_Down)
 						      ? Style_Sunken
 						      : Style_Raised) );
 	    p->setPen( cg.shadow() );
 	    p->drawRect( r );
 	    drawPrimitive( ((flags & Style_Horizontal) ? PE_ArrowLeft
-			    : PE_ArrowUp ), p, TQRect(r.x() + 2,
+			    : PE_ArrowUp ), p, ceData, elementFlags, TQRect(r.x() + 2,
 						     r.y() + 2,
 						     r.width() - 4,
 						     r.height() - 4),
@@ -715,14 +717,14 @@ void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
 	{
 	    TQPoint bo = p->brushOrigin();
 	    p->setBrushOrigin( r.topLeft() );
-	    drawPrimitive( PE_ButtonBevel, p, r, cg, Style_Raised );
+	    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, r, cg, Style_Raised );
 	    p->setBrushOrigin( bo );
 	    drawRiffles( p, r.x(), r.y(), r.width(), r.height(), cg,
 			 flags & Style_Horizontal );
 	    p->setPen( cg.shadow() );
 	    p->drawRect( r );
 	    if ( flags & Style_HasFocus ) {
-		drawPrimitive( PE_FocusRect, p, TQRect(r.x() + 2, r.y() + 2,
+		drawPrimitive( PE_FocusRect, p, ceData, elementFlags, TQRect(r.x() + 2, r.y() + 2,
 						      r.width() - 5,
 						      r.height() - 5 ),
 			       cg, flags );
@@ -730,7 +732,7 @@ void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
 	    break;
 	}
     default:
-	TQWindowsStyle::drawPrimitive( pe, p, r, cg, flags, opt );
+	TQWindowsStyle::drawPrimitive( pe, p, ceData, elementFlags, r, cg, flags, opt );
 	break;
     }
 
@@ -740,36 +742,36 @@ void TQPlatinumStyle::drawPrimitive( PrimitiveElement pe,
  */
 void TQPlatinumStyle::drawControl( ControlElement element,
 				  TQPainter *p,
-				  const TQWidget *widget,
+				  TQStyleControlElementData ceData,
+				  ControlElementFlags elementFlags,
 				  const TQRect &r,
 				  const TQColorGroup &cg,
 				  SFlags how,
-				  const TQStyleOption& opt ) const
+				  const TQStyleOption& opt,
+				  const TQWidget *widget ) const
 {
     switch( element ) {
     case CE_PushButton:
 	{
 #ifndef QT_NO_PUSHBUTTON
 	    TQColorGroup myCg( cg );
-	    const TQPushButton *btn;
 	    int x1, y1, x2, y2;
 	    bool useBevelButton;
 	    SFlags flags;
 	    flags = Style_Default;
-	    btn = (const TQPushButton*)widget;
-	    p->setBrushOrigin( -widget->backgroundOffset().x(),
-			       -widget->backgroundOffset().y() );
+	    p->setBrushOrigin( -ceData.bgOffset.x(),
+			       -ceData.bgOffset.y() );
 
 	    // take care of the flags based on what we know...
-	    if ( btn->isDown() )
+	    if ( elementFlags & CEF_IsDown )
 		flags |= Style_Down;
-	    if ( btn->isOn() )
+	    if ( elementFlags & CEF_IsOn )
 		flags |= Style_On;
-	    if ( btn->isEnabled() )
+	    if ( elementFlags & CEF_IsEnabled )
 		flags |= Style_Enabled;
-	    if ( btn->isDefault() )
+	    if ( elementFlags & CEF_IsDefault )
 		flags |= Style_Default;
- 	    if (! btn->isFlat() && !(flags & Style_Down))
+ 	    if (! ( elementFlags & CEF_IsFlat ) && !(flags & Style_Down))
  		flags |= Style_Raised;
 
 	    r.coords( &x1, &y1, &x2, &y2 );
@@ -778,28 +780,28 @@ void TQPlatinumStyle::drawControl( ControlElement element,
 	    p->setBrush( TQBrush(cg.button(), NoBrush) );
 
 	    TQBrush fill;
-	    if ( btn->isDown() ) {
+	    if ( elementFlags & CEF_IsDown ) {
 		fill = cg.brush( TQColorGroup::Dark );
 		// this could be done differently, but this
 		// makes a down Bezel drawn correctly...
 		myCg.setBrush( TQColorGroup::Mid, fill );
-	    } else if ( btn->isOn() ) {
+	    } else if ( elementFlags & CEF_IsOn ) {
 		fill = TQBrush( cg.mid(), Dense4Pattern );
 		myCg.setBrush( TQColorGroup::Mid, fill );
 	    }
 	    // to quote the old TQPlatinumStlye drawPushButton...
 	    // small or square image buttons as well as toggle buttons are
 	    // bevel buttons (what a heuristic....)
-	    if ( btn->isToggleButton()
-		 || ( btn->pixmap() &&
-		      (btn->width() * btn->height() < 1600 ||
-		       TQABS( btn->width() - btn->height()) < 10 )) )
+	    if ( ( elementFlags & CEF_BiState )
+		 || ( (!ceData.fgPixmap.isNull()) &&
+		      (ceData.rect.width() * ceData.rect.height() < 1600 ||
+		       TQABS( ceData.rect.width() - ceData.rect.height()) < 10 )) )
 		useBevelButton = TRUE;
 	    else
 		useBevelButton = FALSE;
 
-	    int diw = pixelMetric( PM_ButtonDefaultIndicator, widget );
-	    if ( btn->isDefault() ) {
+	    int diw = pixelMetric( PM_ButtonDefaultIndicator, ceData, elementFlags, widget );
+	    if ( elementFlags & CEF_IsDefault ) {
 		x1 += 1;
 		y1 += 1;
 		x2 -= 1;
@@ -814,37 +816,37 @@ void TQPlatinumStyle::drawControl( ControlElement element,
 
 		cg2.setColor( TQColorGroup::Button, cg.mid() );
 		if ( useBevelButton ) {
-		    drawPrimitive( PE_ButtonBevel, p, TQRect( x1, y1,
+		    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, TQRect( x1, y1,
 							     x2 - x1 + 1,
 							     y2 - y1 + 1 ),
 				   myCg, myFlags, opt );
 		} else {
-		    drawPrimitive( PE_ButtonCommand, p, TQRect( x1, y1,
+		    drawPrimitive( PE_ButtonCommand, p, ceData, elementFlags, TQRect( x1, y1,
 							       x2 - x1 + 1,
 							       y2 - y1 + 1 ),
 				   cg2, myFlags, opt );
 		}
 	    }
 
-	    if ( btn->isDefault() || btn->autoDefault() ) {
+	    if ( ( elementFlags & CEF_IsDefault ) || ( elementFlags & CEF_AutoDefault ) ) {
 		x1 += diw;
 		y1 += diw;
 		x2 -= diw;
 		y2 -= diw;
 	    }
 
-	    if ( !btn->isFlat() || btn->isOn() || btn->isDown() ) {
+	    if ( (!( elementFlags & CEF_IsFlat )) || ( elementFlags & CEF_IsOn ) || ( elementFlags & CEF_IsDown ) ) {
 		if ( useBevelButton ) {
 		    // fix for toggle buttons...
 		    if ( flags & (Style_Down | Style_On) )
 			flags |= Style_Sunken;
-		    drawPrimitive( PE_ButtonBevel, p, TQRect( x1, y1,
+		    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, TQRect( x1, y1,
 							     x2 - x1 + 1,
 							     y2 - y1 + 1 ),
 				   myCg, flags, opt );
 		} else {
 
-		    drawPrimitive( PE_ButtonCommand, p, TQRect( x1, y1,
+		    drawPrimitive( PE_ButtonCommand, p, ceData, elementFlags, TQRect( x1, y1,
 							       x2 - x1 + 1,
 							       y2 - y1 + 1 ),
 				   myCg, flags, opt );
@@ -860,16 +862,14 @@ void TQPlatinumStyle::drawControl( ControlElement element,
     case CE_PushButtonLabel:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *btn;
 	    bool on;
 	    int x, y, w, h;
 	    SFlags flags;
 	    flags = Style_Default;
-	    btn = (const TQPushButton*)widget;
-	    on = btn->isDown() || btn->isOn();
+	    on = (( elementFlags & CEF_IsDown ) || ( elementFlags & CEF_IsOn ));
 	    r.rect( &x, &y, &w, &h );
-	    if ( btn->isMenuButton() ) {
-		int dx = pixelMetric( PM_MenuButtonIndicator, widget );
+	    if ( elementFlags & CEF_IsMenuWidget ) {
+		int dx = pixelMetric( PM_MenuButtonIndicator, ceData, elementFlags, widget );
 
 		TQColorGroup g = cg;
 		int xx = x + w - dx - 4;
@@ -884,23 +884,23 @@ void TQPlatinumStyle::drawControl( ControlElement element,
 		    p->setPen( g.light() );
 		    p->drawLine( xx + 2, yy + 2, xx + 2, yy + hh - 2 );
 		}
-		if ( btn->isEnabled() )
+		if ( elementFlags & CEF_IsEnabled )
 		    flags |= Style_Enabled;
-		drawPrimitive( PE_ArrowDown, p, TQRect(x + w - dx - 1, y + 2,
+		drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, TQRect(x + w - dx - 1, y + 2,
 						      dx, h - 4),
 			       g, flags, opt );
 		w -= dx;
 	    }
 #ifndef QT_NO_ICONSET
-	    if ( btn->iconSet() && !btn->iconSet()->isNull() ) {
-		TQIconSet::Mode mode = btn->isEnabled()
+	    if ( !ceData.iconSet.isNull() ) {
+		TQIconSet::Mode mode = ( elementFlags & CEF_IsEnabled )
 				      ? TQIconSet::Normal : TQIconSet::Disabled;
-		if ( mode == TQIconSet::Normal && btn->hasFocus() )
+		if ( mode == TQIconSet::Normal && ( elementFlags & CEF_HasFocus ) )
 		    mode = TQIconSet::Active;
 		TQIconSet::State state = TQIconSet::Off;
-		if ( btn->isToggleButton() && btn->isOn() )
+		if ( ( elementFlags & CEF_BiState ) && ( elementFlags & CEF_IsOn ) )
 		    state = TQIconSet::On;
-		TQPixmap pixmap = btn->iconSet()->pixmap( TQIconSet::Small,
+		TQPixmap pixmap = ceData.iconSet.pixmap( TQIconSet::Small,
 							 mode, state );
 		int pixw = pixmap.width();
 		int pixh = pixmap.height();
@@ -911,19 +911,19 @@ void TQPlatinumStyle::drawControl( ControlElement element,
 #endif
 	    drawItem( p, TQRect( x, y, w, h ),
 		      AlignCenter | ShowPrefix,
-		      btn->colorGroup(), btn->isEnabled(),
-		      btn->pixmap(), btn->text(), -1,
-		      on ? &btn->colorGroup().brightText()
-		      : &btn->colorGroup().buttonText() );
-	    if ( btn->hasFocus() )
-		drawPrimitive( PE_FocusRect, p,
-			       subRect(SR_PushButtonFocusRect, widget),
+		      ceData.colorGroup, ( elementFlags & CEF_IsEnabled ),
+		      (ceData.fgPixmap.isNull())?NULL:&ceData.fgPixmap, ceData.text, -1,
+		      on ? &ceData.colorGroup.brightText()
+		      : &ceData.colorGroup.buttonText() );
+	    if ( elementFlags & CEF_HasFocus )
+		drawPrimitive( PE_FocusRect, p, ceData, elementFlags,
+			       subRect(SR_PushButtonFocusRect, ceData, elementFlags, widget),
 			       cg, flags );
 	    break;
 #endif
 	}
     default:
-	TQWindowsStyle::drawControl( element, p, widget, r, cg, how, opt );
+	TQWindowsStyle::drawControl( element, p, ceData, elementFlags, r, cg, how, opt, widget );
 	break;
     }
 }
@@ -932,13 +932,15 @@ void TQPlatinumStyle::drawControl( ControlElement element,
  */
 void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 					 TQPainter *p,
-					 const TQWidget *widget,
+					 TQStyleControlElementData ceData,
+					 ControlElementFlags elementFlags,
 					 const TQRect &r,
 					 const TQColorGroup &cg,
 					 SFlags how,
 					 SCFlags sub,
 					 SCFlags subActive,
-					 const TQStyleOption& opt ) const
+					 const TQStyleOption& opt,
+					 const TQWidget *widget ) const
 {
     switch ( control ) {
     case CC_ComboBox:
@@ -1010,8 +1012,8 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 	    p->drawPoint( x + w - 3, y + h - 3 );
 
 	    if ( sub & SC_ComboBoxArrow ) {
-		TQRect rTmp = querySubControlMetrics( CC_ComboBox, widget,
-						     SC_ComboBoxArrow, opt );
+		TQRect rTmp = querySubControlMetrics( CC_ComboBox, ceData, elementFlags,
+						     SC_ComboBoxArrow, opt, widget );
 		int xx = rTmp.x(),
 		    yy = rTmp.y(),
 		    ww = rTmp.width(),
@@ -1078,21 +1080,19 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 	    }
 #ifndef QT_NO_COMBOBOX
 	    if ( sub & SC_ComboBoxEditField ) {
-		const TQComboBox *cmb;
-		cmb = (const TQComboBox*)widget;
 		// sadly this is pretty much the windows code, except
 		// for the first fillRect call...
 		TQRect re =
 		    TQStyle::visualRect( querySubControlMetrics( CC_ComboBox,
-								widget,
-								SC_ComboBoxEditField ),
-					widget );
-		if ( cmb->hasFocus() && !cmb->editable() )
+								ceData, elementFlags,
+								SC_ComboBoxEditField, TQStyleOption::Default, widget ),
+					ceData, elementFlags );
+		if ( ( elementFlags & CEF_HasFocus ) && (!( elementFlags & CEF_IsEditable )) )
 		    p->fillRect( re.x() + 1, re.y() + 1,
 				 re.width() - 2, re.height() - 2,
 				 cg.brush( TQColorGroup::Highlight ) );
 
-		if ( cmb->hasFocus() ) {
+		if ( elementFlags & CEF_HasFocus ) {
 		    p->setPen( cg.highlightedText() );
 		    p->setBackgroundColor( cg.highlight() );
 		} else {
@@ -1100,16 +1100,16 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 		    p->setBackgroundColor( cg.background() );
 		}
 
-		if ( cmb->hasFocus() && !cmb->editable() ) {
+		if ( ( elementFlags & CEF_HasFocus ) && (!( elementFlags & CEF_IsEditable )) ) {
 		    TQRect re =
-			TQStyle::visualRect( subRect( SR_ComboBoxFocusRect,
-						     cmb ),
-					    widget );
-		    drawPrimitive( PE_FocusRect, p, re, cg,
+			TQStyle::visualRect( subRect( SR_ComboBoxFocusRect, ceData, elementFlags,
+						     widget ),
+					    ceData, elementFlags );
+		    drawPrimitive( PE_FocusRect, p, ceData, elementFlags, re, cg,
 				   Style_FocusAtBorder,
 				   TQStyleOption(cg.highlight()));
 		}
-		if ( cmb->editable() ) {
+		if ( elementFlags & CEF_IsEditable ) {
 		    // need this for the moment...
 		    // was the code in comboButton rect
 		    TQRect ir( x + 3, y + 3,
@@ -1128,15 +1128,14 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
     case CC_Slider:
 	{
 #ifndef QT_NO_SLIDER
-	    const TQSlider *slider = (const TQSlider *) widget;
-	    int thickness = pixelMetric( PM_SliderControlThickness, widget );
-	    int len = pixelMetric( PM_SliderLength, widget );
-	    int ticks = slider->tickmarks();
+	    int thickness = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
+	    int len = pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
+	    int ticks = ceData.tickMarkSetting;
 
-	    TQRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
-						  opt),
-		  handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
-						  opt);
+	    TQRect groove = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderGroove,
+						  opt, widget),
+		  handle = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderHandle,
+						  opt, widget);
 
 	    if ((sub & SC_SliderGroove) && groove.isValid()) {
 		p->fillRect( groove, cg.brush(TQColorGroup::Background) );
@@ -1149,16 +1148,16 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 		if ( ticks & TQSlider::Below )
 		    mid -= len / 8;
 
-		if ( slider->orientation() == Horizontal ) {
+		if ( ceData.orientation == Horizontal ) {
 		    x = 0;
 		    y = groove.y() + mid - 3;
-		    w = slider->width();
+		    w = ceData.rect.width();
 		    h = 7;
 		} else {
 		    x = groove.x() + mid - 3;
 		    y = 0;
 		    w = 7;
-		    h = slider->height();
+		    h = ceData.rect.height();
 		}
 
 		p->fillRect( x, y, w, h, cg.brush( TQColorGroup::Dark ));
@@ -1209,7 +1208,7 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 		// ### end slider groove
 
 		if ( how & Style_HasFocus )
-		    drawPrimitive( PE_FocusRect, p, groove, cg );
+		    drawPrimitive( PE_FocusRect, p, ceData, elementFlags, groove, cg );
 	    }
 
 	    if ((sub & SC_SliderHandle) && handle.isValid()) {
@@ -1224,7 +1223,7 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 		int mx = handle.width() / 2;
 		int my = handle.height() / 2;
 
-		if ( slider->orientation() == Vertical ) {
+		if ( ceData.orientation == Vertical ) {
 		    // Background
 		    TQBrush oldBrush = p->brush();
 		    p->setBrush( cg.brush( TQColorGroup::Button ) );
@@ -1303,15 +1302,15 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 	    }
 
 	    if ( sub & SC_SliderTickmarks )
-		TQCommonStyle::drawComplexControl( control, p, widget, r,
+		TQCommonStyle::drawComplexControl( control, p, ceData, elementFlags, r,
 						  cg, how, SC_SliderTickmarks,
-						  subActive, opt );
+						  subActive, opt, widget );
 #endif
 	    break;
 	}
     default:
-	TQWindowsStyle::drawComplexControl( control, p, widget, r, cg,
-					   how, sub, subActive, opt );
+	TQWindowsStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg,
+					   how, sub, subActive, opt, widget );
 	break;
     }
 }
@@ -1321,18 +1320,18 @@ void TQPlatinumStyle::drawComplexControl( ComplexControl control,
 /*!\reimp
  */
 TQRect TQPlatinumStyle::querySubControlMetrics( ComplexControl control,
-					      const TQWidget *widget,
+					      TQStyleControlElementData ceData,
+					      ControlElementFlags elementFlags,
 					      SubControl sc,
-					      const TQStyleOption& opt ) const
+					      const TQStyleOption& opt,
+					      const TQWidget *widget ) const
 {
     switch( control ) {
 #ifndef QT_NO_COMBOBOX
     case CC_ComboBox:
-	const TQComboBox *cb;
-	cb = (const TQComboBox *)widget;
 	switch( sc ) {
 	case SC_ComboBoxArrow: {
-	    TQRect ir = cb->rect();
+	    TQRect ir = ceData.rect;
 	    int xx;
 	    if( TQApplication::reverseLayout() )
 		xx = ir.x();
@@ -1346,22 +1345,20 @@ TQRect TQPlatinumStyle::querySubControlMetrics( ComplexControl control,
 #endif
 #ifndef QT_NO_SCROLLBAR
     case CC_ScrollBar: {
-	const TQScrollBar *sb;
-	sb = (const TQScrollBar *)widget;
-	int sliderStart = sb->sliderStart();
-	int sbextent = pixelMetric( PM_ScrollBarExtent, widget );
-	int maxlen = ((sb->orientation() == TQt::Horizontal) ?
-		      sb->width() : sb->height()) - ( sbextent * 2 );
+	int sliderStart = ceData.startStep;
+	int sbextent = pixelMetric( PM_ScrollBarExtent, ceData, elementFlags, widget );
+	int maxlen = ((ceData.orientation == TQt::Horizontal) ?
+		      ceData.rect.width() : ceData.rect.height()) - ( sbextent * 2 );
 
 	int sliderlen;
 
 	// calculate length
-	if ( sb->maxValue() != sb->minValue() ) {
-	    uint range = sb->maxValue() - sb->minValue();
-	    sliderlen = ( sb->pageStep() * maxlen ) /
-			( range + sb->pageStep() );
+	if ( ceData.maxSteps != ceData.minSteps ) {
+	    uint range = ceData.maxSteps - ceData.minSteps;
+	    sliderlen = ( ceData.pageStep * maxlen ) /
+			( range + ceData.pageStep );
 
-	    int slidermin = pixelMetric( PM_ScrollBarSliderMin, widget );
+	    int slidermin = pixelMetric( PM_ScrollBarSliderMin, ceData, elementFlags, widget );
 	    if ( sliderlen < slidermin || range > INT_MAX / 2 )
 		sliderlen = slidermin;
 	    if ( sliderlen > maxlen )
@@ -1372,33 +1369,33 @@ TQRect TQPlatinumStyle::querySubControlMetrics( ComplexControl control,
 
 	switch ( sc ) {
 	case SC_ScrollBarSubLine:
-	    if ( sb->orientation() == TQt::Horizontal ) {
-		int buttonw = TQMIN( sb->width() / 2, sbextent );
-		return TQRect( sb->width() - 2 * buttonw, 0, buttonw, sbextent );
+	    if ( ceData.orientation == TQt::Horizontal ) {
+		int buttonw = TQMIN( ceData.rect.width() / 2, sbextent );
+		return TQRect( ceData.rect.width() - 2 * buttonw, 0, buttonw, sbextent );
 	    } else {
-		int buttonh = TQMIN( sb->height() / 2, sbextent );
-		return TQRect( 0, sb->height() - 2 * buttonh, sbextent, buttonh );
+		int buttonh = TQMIN( ceData.rect.height() / 2, sbextent );
+		return TQRect( 0, ceData.rect.height() - 2 * buttonh, sbextent, buttonh );
 	    }
 	case SC_ScrollBarAddLine:
-	    if ( sb->orientation() == TQt::Horizontal ) {
-		int buttonw = TQMIN( sb->width() / 2, sbextent );
-		return TQRect( sb->width() - buttonw, 0, sbextent, buttonw );
+	    if ( ceData.orientation == TQt::Horizontal ) {
+		int buttonw = TQMIN( ceData.rect.width() / 2, sbextent );
+		return TQRect( ceData.rect.width() - buttonw, 0, sbextent, buttonw );
 	    } else {
-		int buttonh = TQMIN( sb->height() / 2, sbextent );
-		return TQRect(0, sb->height() - buttonh, sbextent, buttonh );
+		int buttonh = TQMIN( ceData.rect.height() / 2, sbextent );
+		return TQRect(0, ceData.rect.height() - buttonh, sbextent, buttonh );
 	    }
 	case SC_ScrollBarSubPage:
-	    if ( sb->orientation() == TQt::Horizontal )
+	    if ( ceData.orientation == TQt::Horizontal )
 		return TQRect( 1, 0, sliderStart, sbextent );
 	    return TQRect( 0, 1, sbextent, sliderStart );
 	case SC_ScrollBarAddPage:
-	    if ( sb->orientation() == TQt::Horizontal )
+	    if ( ceData.orientation == TQt::Horizontal )
 		return TQRect( sliderStart + sliderlen, 0, maxlen - sliderStart - sliderlen, sbextent );
 	    return TQRect( 0, sliderStart + sliderlen, sbextent, maxlen - sliderStart - sliderlen );
 	case SC_ScrollBarGroove:
-	    if ( sb->orientation() == TQt::Horizontal )
-		return TQRect( 1, 0, sb->width() - sbextent * 2, sb->height() );
-	    return TQRect( 0, 1, sb->width(), sb->height() - sbextent * 2 );
+	    if ( ceData.orientation == TQt::Horizontal )
+		return TQRect( 1, 0, ceData.rect.width() - sbextent * 2, ceData.rect.height() );
+	    return TQRect( 0, 1, ceData.rect.width(), ceData.rect.height() - sbextent * 2 );
 	default:
 	    break;
 	}
@@ -1406,13 +1403,11 @@ TQRect TQPlatinumStyle::querySubControlMetrics( ComplexControl control,
 #endif
 #ifndef QT_NO_SLIDER
     case CC_Slider: {
-
-	const TQSlider *slider = (const TQSlider *) widget;
-	int tickOffset = pixelMetric( PM_SliderTickmarkOffset, widget);
-	int thickness = pixelMetric( PM_SliderControlThickness, widget);
+	int tickOffset = pixelMetric( PM_SliderTickmarkOffset, ceData, elementFlags, widget);
+	int thickness = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget);
 	int mid = thickness / 2;
-	int ticks = slider->tickmarks();
-	int len = pixelMetric( PM_SliderLength, widget );
+	int ticks = ceData.tickMarkSetting;
+	int len = pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
 
 	switch ( sc ) {
 	case SC_SliderGroove:
@@ -1420,9 +1415,9 @@ TQRect TQPlatinumStyle::querySubControlMetrics( ComplexControl control,
 		mid += len / 8;
 	    if ( ticks & TQSlider::Below )
 		mid -= len / 8;
-	    if ( slider->orientation() == TQSlider::Horizontal )
-		return TQRect( 0, tickOffset, slider->width(), thickness );
-	    return TQRect( tickOffset, 0, thickness, slider->height() );
+	    if ( ceData.orientation == TQSlider::Horizontal )
+		return TQRect( 0, tickOffset, ceData.rect.width(), thickness );
+	    return TQRect( tickOffset, 0, thickness, ceData.rect.height() );
 	default:
 	    break;
 	}
@@ -1431,13 +1426,13 @@ TQRect TQPlatinumStyle::querySubControlMetrics( ComplexControl control,
     default:
 	break;
     }
-    return TQWindowsStyle::querySubControlMetrics( control, widget, sc, opt );
+    return TQWindowsStyle::querySubControlMetrics( control, ceData, elementFlags, sc, opt, widget );
 }
 
 
 /*!\reimp
  */
-int TQPlatinumStyle::pixelMetric( PixelMetric metric,
+int TQPlatinumStyle::pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags,
 				 const TQWidget *widget ) const
 {
     int ret;
@@ -1466,7 +1461,7 @@ int TQPlatinumStyle::pixelMetric( PixelMetric metric,
 	ret = -1;
 	break;
     default:
-	ret = TQWindowsStyle::pixelMetric( metric, widget );
+	ret = TQWindowsStyle::pixelMetric( metric, ceData, elementFlags, widget );
 	break;
     }
     return ret;
@@ -1474,19 +1469,19 @@ int TQPlatinumStyle::pixelMetric( PixelMetric metric,
 
 /*!\reimp
  */
-TQRect TQPlatinumStyle::subRect( SubRect r, const TQWidget *widget ) const
+TQRect TQPlatinumStyle::subRect( SubRect r, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const
 {
     TQRect rect;
     switch ( r ) {
     case SR_ComboBoxFocusRect:
 	{
-	    TQRect tmpR = widget->rect();
+	    TQRect tmpR = ceData.rect;
 	    rect = TQRect( tmpR.x() + 4, tmpR.y() + 4, tmpR.width() - 8 - 16,
 			  tmpR.height() - 8 );
 	    break;
 	}
     default:
-	rect = TQWindowsStyle::subRect( r, widget );
+	rect = TQWindowsStyle::subRect( r, ceData, elementFlags, widget );
 	break;
     }
     return rect;
diff --git a/src/styles/qsgistyle.cpp b/src/styles/qsgistyle.cpp
index 86dcef36..930a34d0 100644
--- a/src/styles/qsgistyle.cpp
+++ b/src/styles/qsgistyle.cpp
@@ -65,7 +65,7 @@ struct SliderLastPosition
 {
     SliderLastPosition() : rect(0,-1,0,-1), slider(0) {}
     TQRect rect;
-    const TQSlider* slider;
+    const void* slider;
 };
 #endif
 
@@ -74,7 +74,7 @@ struct ScrollbarLastPosition
 {
     ScrollbarLastPosition() : rect( 0,-1, 0,-1 ), scrollbar(0) {}
     TQRect rect;
-    const TQScrollBar *scrollbar;
+    const void* scrollbar;
 };
 #endif
 
@@ -86,7 +86,7 @@ public:
     {
     }
 
-    const TQWidget *hotWidget;
+    const void* hotWidget;
     TQPoint mousePos;
 #ifndef QT_NO_SCROLLBAR
     ScrollbarLastPosition lastScrollbarRect;
@@ -136,10 +136,10 @@ TQSGIStyle::~TQSGIStyle()
     bold italic font for menu options.
 */
 void
-TQSGIStyle::polish( TQApplication* app)
+TQSGIStyle::applicationPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr )
 {
     isApplicationStyle = 1;
-    TQMotifStyle::polish( app );
+    TQMotifStyle::polish( ceData, elementFlags, ptr );
 
     TQPalette pal = TQApplication::palette();
     // check this on SGI-Boxes
@@ -181,7 +181,7 @@ TQSGIStyle::polish( TQApplication* app)
 /*! \reimp
 */
 void
-TQSGIStyle::unPolish( TQApplication* /* app */ )
+TQSGIStyle::applicationUnPolish( TQStyleControlElementData, ControlElementFlags, void * )
 {
     TQFont f = TQApplication::font();
     TQApplication::setFont( f, TRUE ); // get rid of the special fonts for special widget classes
@@ -194,9 +194,9 @@ TQSGIStyle::unPolish( TQApplication* /* app */ )
     hovering.
 */
 void
-TQSGIStyle::polish( TQWidget* w )
+TQSGIStyle::polish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr )
 {
-    TQMotifStyle::polish(w);
+    TQMotifStyle::polish(ceData, elementFlags, ptr);
 
     if ( !isApplicationStyle ) {
         TQPalette sgiPal = TQApplication::palette();
@@ -214,7 +214,7 @@ TQSGIStyle::polish( TQWidget* w )
             sgiPal.setColor( TQPalette::Disabled, TQColorGroup::HighlightedText, sgiPal.disabled().base() );
         }
 
-        if ( ::tqt_cast<TQLineEdit*>(w) || ::tqt_cast<TQTextEdit*>(w) ) {
+        if ( (ceData.widgetObjectTypes.contains("TQLineEdit")) || (ceData.widgetObjectTypes.contains("TQTextEdit")) ) {
             // different basecolor and highlighting in Q(Multi)LineEdit
             sgiPal.setColor( TQColorGroup::Base, TQColor(211,181,181) );
             sgiPal.setColor( TQPalette::Active, TQColorGroup::Highlight, sgiPal.active().midlight() );
@@ -224,89 +224,89 @@ TQSGIStyle::polish( TQWidget* w )
             sgiPal.setColor( TQPalette::Disabled, TQColorGroup::Highlight, sgiPal.disabled().midlight() );
             sgiPal.setColor( TQPalette::Disabled, TQColorGroup::HighlightedText, sgiPal.disabled().text() );
 
-        } else if ( ::tqt_cast<TQMenuBar*>(w) || ::tqt_cast<TQToolBar*>(w) ) {
+        } else if ( (ceData.widgetObjectTypes.contains("TQMenuBar")) || (ceData.widgetObjectTypes.contains("TQToolBar")) ) {
             sgiPal.setColor( TQColorGroup::Button, sgiPal.active().midlight() );
         }
 
-        w->setPalette( sgiPal );
+        widgetActionRequest(ceData, elementFlags, ptr, WAR_SetPalette, TQStyleWidgetActionRequestData(sgiPal));
     }
 
-    if ( ::tqt_cast<TQButton*>(w) || ::tqt_cast<TQSlider*>(w) || ::tqt_cast<TQScrollBar*>(w) ) {
-        w->installEventFilter( this );
-        w->setMouseTracking( TRUE );
+    if ( (ceData.widgetObjectTypes.contains("TQButton")) || (ceData.widgetObjectTypes.contains("TQSlider")) || (ceData.widgetObjectTypes.contains("TQScrollBar")) ) {
+        installObjectEventHandler(ceData, elementFlags, ptr, this);
+        widgetActionRequest(ceData, elementFlags, ptr, WAR_EnableMouseTracking);
 #ifndef QT_NO_SCROLLBAR
-        if ( ::tqt_cast<TQScrollBar*>(w) )
-            w->setBackgroundMode( TQWidget::NoBackground );
+        if ( ceData.widgetObjectTypes.contains("TQScrollBar") ) {
+            widgetActionRequest(ceData, elementFlags, ptr, WAR_SetBackgroundMode, TQStyleWidgetActionRequestData(TQWidget::NoBackground));
+        }
 #endif
-    } else if ( ::tqt_cast<TQComboBox*>(w) ) {
+    } else if ( ceData.widgetObjectTypes.contains("TQComboBox") ) {
 	TQFont f = TQApplication::font();
 	f.setBold( TRUE );
 	f.setItalic( TRUE );
-	w->setFont( f );
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_SetFont, TQStyleWidgetActionRequestData(f));
 #ifndef QT_NO_MENUBAR
-    } else if ( ::tqt_cast<TQMenuBar*>(w) ) {
-        ((TQFrame*) w)->setFrameStyle(TQFrame::StyledPanel | TQFrame::Raised);
-        w->setBackgroundMode( TQWidget::PaletteBackground );
+    } else if ( ceData.widgetObjectTypes.contains("TQMenuBar") ) {
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_FrameSetStyle, TQStyleWidgetActionRequestData(TQFrame::StyledPanel | TQFrame::Raised));
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_SetBackgroundMode, TQStyleWidgetActionRequestData(TQWidget::PaletteBackground));
 	TQFont f = TQApplication::font();
 	f.setBold( TRUE );
 	f.setItalic( TRUE );
-	w->setFont( f );
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_SetFont, TQStyleWidgetActionRequestData(f));
 #endif
 #ifndef QT_NO_POPUPMENU
-    } else if ( ::tqt_cast<TQPopupMenu*>(w) ) {
-        ((TQFrame*) w)->setLineWidth( pixelMetric( PM_DefaultFrameWidth ) + 1 );
+    } else if ( ceData.widgetObjectTypes.contains("TQPopupMenu") ) {
+	TQStyleWidgetActionRequestData requestData;
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_FrameSetLineWidth, TQStyleWidgetActionRequestData(pixelMetric( PM_DefaultFrameWidth, TQStyleControlElementData(), CEF_None ) + 1));
 	TQFont f = TQApplication::font();
 	f.setBold( TRUE );
 	f.setItalic( TRUE );
-	w->setFont( f );
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_SetFont, TQStyleWidgetActionRequestData(f));
 #endif
-    } else if ( ::tqt_cast<TQToolBar*>(w) || w->inherits("TQToolBarSeparator") ) {
-        w->setBackgroundMode( TQWidget::PaletteBackground );
+    } else if ( (ceData.widgetObjectTypes.contains("TQToolBar")) || (ceData.widgetObjectTypes.contains("TQToolBarSeparator")) ) {
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_SetBackgroundMode, TQStyleWidgetActionRequestData(TQWidget::PaletteBackground));
     }
 }
 
 /*! \reimp */
 void
-TQSGIStyle::unPolish( TQWidget* w )
+TQSGIStyle::unPolish( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr )
 {
-    if ( ::tqt_cast<TQButton*>(w) || ::tqt_cast<TQSlider*>(w) || ::tqt_cast<TQScrollBar*>(w) ) {
-        w->removeEventFilter( this );
+    if ( (ceData.widgetObjectTypes.contains("TQButton")) || (ceData.widgetObjectTypes.contains("TQSlider")) || (ceData.widgetObjectTypes.contains("TQScrollBar")) ) {
+        removeObjectEventHandler(ceData, elementFlags, ptr, this);
 #ifndef QT_NO_POPUPMENU
-    } else if ( ::tqt_cast<TQPopupMenu*>(w) ) {
-	((TQFrame*)w)->setLineWidth( pixelMetric( PM_DefaultFrameWidth ) );
-	w->setFont( TQApplication::font() );
+    } else if ( ceData.widgetObjectTypes.contains("TQPopupMenu") ) {
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_FrameSetLineWidth, TQStyleWidgetActionRequestData(pixelMetric( PM_DefaultFrameWidth, TQStyleControlElementData(), CEF_None )));
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_SetFont, TQStyleWidgetActionRequestData(TQApplication::font()));
 #endif
 #if !defined(QT_NO_MENUBAR) || !defined(QT_NO_COMBOBOX)
-    } else if ( ::tqt_cast<TQMenuBar*>(w) || ::tqt_cast<TQComboBox*>(w) ) {
-	w->setFont( TQApplication::font() );
+    } else if ( (ceData.widgetObjectTypes.contains("TQMenuBar")) || (ceData.widgetObjectTypes.contains("TQComboBox")) ) {
+	widgetActionRequest(ceData, elementFlags, ptr, WAR_SetFont, TQStyleWidgetActionRequestData(TQApplication::font()));
 #endif
     }
 }
 
 /*! \reimp */
-bool TQSGIStyle::eventFilter( TQObject* o, TQEvent* e )
+bool TQSGIStyle::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e )
 {
-    if ( !o->isWidgetType() || e->type() == TQEvent::Paint )
-	return TQMotifStyle::eventFilter( o, e );
-
-    TQWidget *widget = (TQWidget*)o;
+    if ( (!(ceData.widgetObjectTypes.contains("TQWidget"))) || (e->type() == TQEvent::Paint) )
+	return TQMotifStyle::objectEventHandler( ceData, elementFlags, source, e );
 
     switch ( e->type() ) {
     case TQEvent::MouseButtonPress:
         {
 #ifndef QT_NO_SCROLLBAR
-	    if ( ::tqt_cast<TQScrollBar*>(widget) ) {
-		d->lastScrollbarRect.rect = ((TQScrollBar*)widget)->sliderRect();
-		d->lastScrollbarRect.scrollbar = ((TQScrollBar*)widget);
-		widget->repaint( FALSE );
+	    if (ceData.widgetObjectTypes.contains("TQScrollBar")) {
+		d->lastScrollbarRect.rect = ceData.sliderRect;
+		d->lastScrollbarRect.scrollbar = source;
+		widgetActionRequest(ceData, elementFlags, source, WAR_Repaint);
 	    } else
 #endif
 	    {
 #ifndef QT_NO_SLIDER
-		if ( ::tqt_cast<TQSlider*>(widget) ) {
-		    d->lastSliderRect.rect = ((TQSlider*)widget)->sliderRect();
-		    d->lastSliderRect.slider = ((TQSlider*)widget);
-		    widget->repaint( FALSE );
+		if (ceData.widgetObjectTypes.contains("TQSlider")) {
+		    d->lastSliderRect.rect = ceData.sliderRect;
+		    d->lastSliderRect.slider = source;
+		    widgetActionRequest(ceData, elementFlags, source, WAR_Repaint);
 		}
 #endif
 	    }
@@ -317,52 +317,52 @@ bool TQSGIStyle::eventFilter( TQObject* o, TQEvent* e )
         {
 	    if ( 0 ) {
 #ifndef QT_NO_SCROLLBAR
-	    } else if ( ::tqt_cast<TQScrollBar*>(widget) ) {
+	    } else if (ceData.widgetObjectTypes.contains("TQScrollBar")) {
 		TQRect oldRect = d->lastScrollbarRect.rect;
 		d->lastScrollbarRect.rect = TQRect( 0, -1, 0, -1 );
-		widget->repaint( oldRect, FALSE );
+		widgetActionRequest(ceData, elementFlags, source, WAR_RepaintRect, TQStyleWidgetActionRequestData(oldRect));
 #endif
 #ifndef QT_NO_SLIDER
-	    } else if ( ::tqt_cast<TQSlider*>(widget) ) {
+	    } else if (ceData.widgetObjectTypes.contains("TQSlider")) {
 		TQRect oldRect = d->lastSliderRect.rect;
 		d->lastSliderRect.rect = TQRect( 0, -1, 0, -1 );
-		widget->repaint( oldRect, FALSE );
+		widgetActionRequest(ceData, elementFlags, source, WAR_RepaintRect, TQStyleWidgetActionRequestData(oldRect));
 #endif
             }
         }
         break;
 
     case TQEvent::MouseMove:
-	if ( !widget->isActiveWindow() )
+	if ( !(elementFlags & CEF_IsActiveWindow) )
 	    break;
 	if ( ((TQMouseEvent*)e)->button() )
 	    break;
 
-	d->hotWidget = widget;
+	d->hotWidget = source;
         d->mousePos = ((TQMouseEvent*)e)->pos();
-	widget->repaint( FALSE );
+	widgetActionRequest(ceData, elementFlags, source, WAR_Repaint);
         break;
 
     case TQEvent::Enter:
-	if ( !widget->isActiveWindow() )
+	if ( !(elementFlags & CEF_IsActiveWindow) )
 	    break;
-        d->hotWidget = widget;
-        widget->repaint( FALSE );
+        d->hotWidget = source;
+        widgetActionRequest(ceData, elementFlags, source, WAR_Repaint);
         break;
 
     case TQEvent::Leave:
-	if ( !widget->isActiveWindow() )
+	if ( !(elementFlags & CEF_IsActiveWindow) )
 	    break;
-        if ( widget == d->hotWidget) {
+        if ( source == d->hotWidget) {
             d->hotWidget = 0;
-            widget->repaint( FALSE );
+            widgetActionRequest(ceData, elementFlags, source, WAR_Repaint);
         }
         break;
 
     default:
         break;
     }
-    return TQMotifStyle::eventFilter( o, e );
+    return TQMotifStyle::objectEventHandler( ceData, elementFlags, source, e );
 }
 
 static const int sgiItemFrame           = 2;    // menu item frame width
@@ -375,7 +375,7 @@ static const int sgiTabSpacing 		= 12;   // space between text and tab
 static const int sgiCheckMarkSpace      = 20;
 
 /*! \reimp */
-int TQSGIStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) const
+int TQSGIStyle::pixelMetric( PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const
 {
     switch ( metric ) {
     case PM_DefaultFrameWidth:
@@ -401,7 +401,7 @@ int TQSGIStyle::pixelMetric( PixelMetric metric, const TQWidget *widget ) const
     default:
 	break;
     }
-    return TQMotifStyle::pixelMetric( metric, widget );
+    return TQMotifStyle::pixelMetric( metric, ceData, elementFlags, widget );
 }
 
 static void drawPanel( TQPainter *p, int x, int y, int w, int h,
@@ -552,6 +552,8 @@ static void get_combo_parameters( const TQRect &r,
 /*! \reimp */
 void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
 		    TQPainter *p,
+		    TQStyleControlElementData ceData,
+		    ControlElementFlags elementFlags,
 		    const TQRect &r,
 		    const TQColorGroup &cg,
 		    SFlags flags,
@@ -562,7 +564,7 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
     const int w = r.width();
     const int h = r.height();
     const bool sunken = flags & ( Style_Sunken | Style_Down | Style_On );
-    const int defaultFrameWidth = pixelMetric( PM_DefaultFrameWidth );
+    const int defaultFrameWidth = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags );
     bool hot = ( flags & Style_MouseOver ) && ( flags & Style_Enabled );
 
     switch ( pe ) {
@@ -588,7 +590,7 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
     case PE_ButtonBevel:
     case PE_ButtonTool:
 	{
-	    drawPrimitive( PE_ButtonCommand, p, TQRect( x+1, y+1, w-2, h-2 ), cg, flags, opt );
+	    drawPrimitive( PE_ButtonCommand, p, ceData, elementFlags, TQRect( x+1, y+1, w-2, h-2 ), cg, flags, opt );
 
 	    TQPen oldPen = p->pen();
 	    TQPointArray a;
@@ -642,11 +644,11 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
 	    TQRect er = r;
 	    er.addCoords( 1, 1, -1, -1 );
 	    int iflags = flags & ~Style_On;
-	    drawPrimitive( PE_ButtonBevel, p, er, cg, iflags, opt );
+	    drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, er, cg, iflags, opt );
 	    if ( !(flags & TQStyle::Style_Off) ) {
 		er = r;
 		er.addCoords( 1, 2, 1, 1 );
-		drawPrimitive( PE_CheckMark, p, er, cg, flags, opt );
+		drawPrimitive( PE_CheckMark, p, ceData, elementFlags, er, cg, flags, opt );
 	    }
 	}
 	break;
@@ -795,17 +797,17 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
     case PE_ScrollBarSubLine:
 	if ( !r.contains( d->mousePos ) && !(flags & Style_Active) )
 	    flags &= ~Style_MouseOver;
-	drawPrimitive( PE_ButtonCommand, p, r, cg, flags, opt );
+	drawPrimitive( PE_ButtonCommand, p, ceData, elementFlags, r, cg, flags, opt );
 	drawPrimitive(((flags & Style_Horizontal) ? PE_ArrowLeft : PE_ArrowUp),
-		      p, r, cg, Style_Enabled | flags);
+		      p, ceData, elementFlags, r, cg, Style_Enabled | flags);
 	break;
 
     case PE_ScrollBarAddLine:
 	if ( !r.contains( d->mousePos ) )
 	    flags &= ~Style_MouseOver;
-	drawPrimitive( PE_ButtonCommand, p, r, cg, flags, opt );
+	drawPrimitive( PE_ButtonCommand, p, ceData, elementFlags, r, cg, flags, opt );
 	drawPrimitive(((flags & Style_Horizontal) ? PE_ArrowRight : PE_ArrowDown),
-		      p, r, cg, Style_Enabled | flags);
+		      p, ceData, elementFlags, r, cg, Style_Enabled | flags);
 	break;
 
     case PE_ScrollBarSubPage:
@@ -825,7 +827,7 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
 
 	    TQPixmap pm( r.width(), r.height() );
 	    TQPainter bp( &pm );
-	    drawPrimitive(PE_ButtonBevel, &bp, TQRect(0,0,r.width(),r.height()), cg, flags | Style_Enabled | Style_Raised);
+	    drawPrimitive(PE_ButtonBevel, &bp, ceData, elementFlags, TQRect(0,0,r.width(),r.height()), cg, flags | Style_Enabled | Style_Raised);
 	    if ( flags & Style_Horizontal ) {
 		const int sliderM =  r.width() / 2;
 		if ( r.width() > 20 ) {
@@ -853,7 +855,7 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
     case PE_Splitter:
 	{
 	    const int motifOffset = 10;
-	    int sw = pixelMetric( PM_SplitterWidth );
+	    int sw = pixelMetric( PM_SplitterWidth, ceData, elementFlags );
 	    if ( flags & Style_Horizontal ) {
 		int xPos = x + w/2;
 		int kPos = motifOffset;
@@ -862,7 +864,7 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
 		qDrawShadeLine( p, xPos, kPos + kSize - 1 ,
 			xPos, h, cg );
 
-		drawPrimitive( PE_ButtonBevel, p, TQRect(xPos-sw/2+1, kPos, kSize, kSize+1), cg, flags, opt );
+		drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, TQRect(xPos-sw/2+1, kPos, kSize, kSize+1), cg, flags, opt );
 		qDrawShadeLine( p, xPos+2, 0, xPos, kPos, cg );
 	    } else {
 		int yPos = y + h/2;
@@ -870,14 +872,14 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
 		int kSize = sw - 2;
 
 		qDrawShadeLine( p, 0, yPos, kPos, yPos, cg );
-		drawPrimitive( PE_ButtonBevel, p, TQRect( kPos, yPos-sw/2+1, kSize+1, kSize ), cg, flags, opt );
+		drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, TQRect( kPos, yPos-sw/2+1, kSize+1, kSize ), cg, flags, opt );
 		qDrawShadeLine( p, kPos + kSize+1, yPos, w, yPos, cg );
 	    }
 	}
 	break;
 
     default:
-	TQMotifStyle::drawPrimitive( pe, p, r, cg, flags, opt );
+	TQMotifStyle::drawPrimitive( pe, p, ceData, elementFlags, r, cg, flags, opt );
 	break;
     }
 }
@@ -885,11 +887,13 @@ void TQSGIStyle::drawPrimitive( PrimitiveElement pe,
 /*! \reimp */
 void TQSGIStyle::drawControl( ControlElement element,
 		  TQPainter *p,
-		  const TQWidget *widget,
+		  TQStyleControlElementData ceData,
+		  ControlElementFlags elementFlags,
 		  const TQRect &r,
 		  const TQColorGroup &cg,
 		  SFlags flags,
-		  const TQStyleOption& opt ) const
+		  const TQStyleOption& opt,
+		  const TQWidget *widget ) const
 {
     if ( widget == d->hotWidget )
 	flags |= Style_MouseOver;
@@ -898,17 +902,16 @@ void TQSGIStyle::drawControl( ControlElement element,
     case CE_PushButton:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *btn = (TQPushButton*)widget;
 	    int x1, y1, x2, y2;
 	    r.coords( &x1, &y1, &x2, &y2 );
 
 	    p->setPen( cg.foreground() );
 	    p->setBrush( TQBrush( cg.button(),TQt::NoBrush ) );
-	    p->setBrushOrigin( -widget->backgroundOffset().x(),
-			       -widget->backgroundOffset().y() );
+	    p->setBrushOrigin( -ceData.bgOffset.x(),
+			       -ceData.bgOffset.y() );
 
-	    int diw = pixelMetric( TQStyle::PM_ButtonDefaultIndicator );
-	    if ( btn->isDefault() || btn->autoDefault() ) {
+	    int diw = pixelMetric( TQStyle::PM_ButtonDefaultIndicator, ceData, elementFlags );
+	    if ( ( elementFlags & CEF_IsDefault ) || ( elementFlags & CEF_AutoDefault ) ) {
 		x1 += diw;
 		y1 += diw;
 		x2 -= diw;
@@ -916,7 +919,7 @@ void TQSGIStyle::drawControl( ControlElement element,
 	    }
 
 	    TQPointArray a;
-	    if ( btn->isDefault() ) {
+	    if ( elementFlags & CEF_IsDefault ) {
 		if ( diw == 0 ) {
 		    a.setPoints( 9,
 				 x1, y1, x2, y1, x2, y2, x1, y2, x1, y1+1,
@@ -928,13 +931,13 @@ void TQSGIStyle::drawControl( ControlElement element,
 		    x2 -= 2;
 		    y2 -= 2;
 		} else {
-		    qDrawShadePanel( p, btn->rect(), cg, TRUE );
+		    qDrawShadePanel( p, ceData.rect, cg, TRUE );
 		}
 	    }
 
 	    TQBrush fill = cg.brush( TQColorGroup::Button );
-	    if ( !btn->isFlat() || btn->isOn() || btn->isDown() )
-		drawPrimitive( PE_ButtonBevel, p, TQRect( x1, y1, x2-x1+1, y2-y1+1 ), cg, flags, opt );
+	    if ( (!( elementFlags & CEF_IsFlat )) || ( elementFlags & CEF_IsOn ) || ( elementFlags & CEF_IsDown ) )
+		drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, TQRect( x1, y1, x2-x1+1, y2-y1+1 ), cg, flags, opt );
 
 	    if ( p->brush().style() != TQt::NoBrush )
 		p->setBrush( TQt::NoBrush );
@@ -945,16 +948,15 @@ void TQSGIStyle::drawControl( ControlElement element,
     case CE_PopupMenuItem:
 	{
 #ifndef QT_NO_POPUPMENU
-	    if (! widget || opt.isDefault())
+	    if ( ( elementFlags & CEF_UseGenericParameters ) || opt.isDefault())
 		break;
 	    TQMenuItem *mi = opt.menuItem();
 	    if ( !mi )
 		break;
-	    const TQPopupMenu *popupmenu = (const TQPopupMenu *) widget;
 	    int tab = opt.tabWidth();
 	    int maxpmw = opt.maxIconWidth();
 	    bool dis = ! (flags & Style_Enabled);
-	    bool checkable = popupmenu->isCheckable();
+	    bool checkable = ( elementFlags & CEF_IsCheckable );
 	    bool act = flags & Style_Active;
 	    int x, y, w, h;
 
@@ -973,7 +975,7 @@ void TQSGIStyle::drawControl( ControlElement element,
 	    int pw = sgiItemFrame;
 
 	    if ( act && !dis ) {
-		if ( pixelMetric( PM_DefaultFrameWidth ) > 1 )
+		if ( pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags ) > 1 )
 		    drawPanel( p, x, y, w, h, cg, FALSE, pw,
 				     &cg.brush( TQColorGroup::Light ) );
 		else
@@ -1024,12 +1026,12 @@ void TQSGIStyle::drawControl( ControlElement element,
 
 		    if ( mi->isChecked() ) {
 			TQRect er( x+sgiItemFrame+1, y+sgiItemFrame+3,
-				  pixelMetric(PM_IndicatorWidth),
-				  pixelMetric(PM_IndicatorHeight) );
+				  pixelMetric(PM_IndicatorWidth, ceData, elementFlags),
+				  pixelMetric(PM_IndicatorHeight, ceData, elementFlags) );
 			er.addCoords( 1, 1, -1, -1 );
-			drawPrimitive( PE_ButtonBevel, p, er, cg, cflags, opt );
+			drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, er, cg, cflags, opt );
 			er.addCoords( 0, 1, 1, 1 );
-			drawPrimitive( PE_CheckMark, p, er, cg, cflags | Style_On, opt );
+			drawPrimitive( PE_CheckMark, p, ceData, elementFlags, er, cg, cflags | Style_On, opt );
 		    }
 		}
 	    }
@@ -1082,7 +1084,7 @@ void TQSGIStyle::drawControl( ControlElement element,
 	    }
 	    if ( mi->popup() ) {
 		int dim = (h-2*sgiItemFrame) / 2;
-		drawPrimitive( PE_ArrowRight, p, TQRect( x+w-sgiArrowHMargin-sgiItemFrame-dim, y+h/2-dim/2, dim, dim ), cg, flags );
+		drawPrimitive( PE_ArrowRight, p, ceData, elementFlags, TQRect( x+w-sgiArrowHMargin-sgiItemFrame-dim, y+h/2-dim/2, dim, dim ), cg, flags );
 	    }
 #endif
 	}
@@ -1128,11 +1130,11 @@ void TQSGIStyle::drawControl( ControlElement element,
 	break;
 
     case CE_CheckBox:
-	TQMotifStyle::drawControl( element, p, widget, r, cg, flags, opt );
+	TQMotifStyle::drawControl( element, p, ceData, elementFlags, r, cg, flags, opt, widget );
 	break;
 
     default:
-	TQMotifStyle::drawControl( element, p, widget, r, cg, flags, opt );
+	TQMotifStyle::drawControl( element, p, ceData, elementFlags, r, cg, flags, opt, widget );
 	break;
     }
 }
@@ -1140,13 +1142,15 @@ void TQSGIStyle::drawControl( ControlElement element,
 /*! \reimp */
 void TQSGIStyle::drawComplexControl( ComplexControl control,
 			 TQPainter *p,
-			 const TQWidget* widget,
+			 TQStyleControlElementData ceData,
+			 ControlElementFlags elementFlags,
 			 const TQRect& r,
 			 const TQColorGroup& cg,
 			 SFlags flags,
 			 SCFlags sub,
 			 SCFlags subActive,
-			 const TQStyleOption& opt ) const
+			 const TQStyleOption& opt,
+			 const TQWidget* widget ) const
 {
     if ( widget == d->hotWidget )
 	flags |= Style_MouseOver;
@@ -1155,33 +1159,31 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
     case CC_Slider:
 	{
 #ifndef QT_NO_SLIDER
-	    const TQSlider * slider = (const TQSlider *) widget;
-
-	    TQRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
-						  opt),
-		  handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
-						  opt);
+	    TQRect groove = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderGroove,
+						  opt, widget),
+		  handle = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderHandle,
+						  opt, widget);
 
 	    if ((sub & SC_SliderGroove) && groove.isValid()) {
 		TQRegion region( groove );
 		if ( ( sub & SC_SliderHandle ) && handle.isValid() )
 		    region = region.subtract( handle );
-		if ( d->lastSliderRect.slider == slider && d->lastSliderRect.rect.isValid() )
+		if ( d->lastSliderRect.slider == widget && d->lastSliderRect.rect.isValid() )
 		    region = region.subtract( d->lastSliderRect.rect );
 		p->setClipRegion( region );
 
 		TQRect grooveTop = groove;
 		grooveTop.addCoords( 1, 1, -1, -1 );
-		drawPrimitive( PE_ButtonBevel, p, grooveTop, cg, flags & ~Style_MouseOver, opt );
+		drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, grooveTop, cg, flags & ~Style_MouseOver, opt );
 
 		if ( flags & Style_HasFocus ) {
-		    TQRect fr = subRect( SR_SliderFocusRect, widget );
-		    drawPrimitive( PE_FocusRect, p, fr, cg, flags & ~Style_MouseOver );
+		    TQRect fr = subRect( SR_SliderFocusRect, ceData, elementFlags, widget );
+		    drawPrimitive( PE_FocusRect, p, ceData, elementFlags, fr, cg, flags & ~Style_MouseOver );
 		}
 
-		if ( d->lastSliderRect.slider == slider && d->lastSliderRect.rect.isValid() ) {
+		if ( d->lastSliderRect.slider == widget && d->lastSliderRect.rect.isValid() ) {
 		    if ( ( sub & SC_SliderHandle ) && handle.isValid() ) {
-			region = widget->rect();
+			region = ceData.rect;
 			region = region.subtract( handle );
 			p->setClipRegion( region );
 		    } else {
@@ -1195,9 +1197,9 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
 	    if (( sub & SC_SliderHandle ) && handle.isValid()) {
 		if ( flags & Style_MouseOver && !handle.contains( d->mousePos ) && subActive != SC_SliderHandle )
 		    flags &= ~Style_MouseOver;
-		drawPrimitive( PE_ButtonBevel, p, handle, cg, flags );
+		drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, handle, cg, flags );
 
-		if ( slider->orientation() == Horizontal ) {
+		if ( ceData.orientation == Horizontal ) {
 		    TQCOORD mid = handle.x() + handle.width() / 2;
 		    qDrawShadeLine( p, mid, handle.y(), mid,
 				    handle.y() + handle.height() - 2,
@@ -1211,50 +1213,48 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
 	    }
 
 	    if ( sub & SC_SliderTickmarks )
-		TQMotifStyle::drawComplexControl( control, p, widget, r, cg, flags,
+		TQMotifStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg, flags,
 						 SC_SliderTickmarks, subActive,
-						 opt );
+						 opt, widget );
 #endif
 	    break;
 	}
     case CC_ComboBox:
 	{
 #ifndef QT_NO_COMBOBOX
-	    const TQComboBox * cb = (TQComboBox *) widget;
-
 	    if (sub & SC_ComboBoxFrame) {
 		TQRect fr =
-		    TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, cb,
-								SC_ComboBoxFrame ), cb );
-		drawPrimitive( PE_ButtonBevel, p, fr, cg, flags );
+		    TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, ceData, elementFlags,
+								SC_ComboBoxFrame, TQStyleOption::Default, widget ), ceData, elementFlags );
+		drawPrimitive( PE_ButtonBevel, p, ceData, elementFlags, fr, cg, flags );
 	    }
 
 	    if ( sub & SC_ComboBoxArrow ) {
 		p->save();
 		TQRect er =
-		    TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, cb, SC_ComboBoxArrow ), cb );
+		    TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, ceData, elementFlags, SC_ComboBoxArrow, TQStyleOption::Default, widget ), ceData, elementFlags );
 
 		er.addCoords( 0, 3, 0, 0 );
 
-		drawPrimitive( PE_ArrowDown, p, er, cg, flags | Style_Enabled, opt );
+		drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, er, cg, flags | Style_Enabled, opt );
 
 		int awh, ax, ay, sh, sy, dh, ew;
-		get_combo_parameters( widget->rect(), ew, awh, ax, ay, sh, dh, sy );
+		get_combo_parameters( ceData.rect, ew, awh, ax, ay, sh, dh, sy );
 
 		TQBrush arrow = cg.brush( TQColorGroup::Dark );
 		p->fillRect( ax, sy-1, awh, sh, arrow );
 
 		p->restore();
-		if ( cb->hasFocus() ) {
-		    TQRect re = TQStyle::visualRect( subRect( SR_ComboBoxFocusRect, cb ), cb );
-		    drawPrimitive( PE_FocusRect, p, re, cg );
+		if ( elementFlags & CEF_HasFocus ) {
+		    TQRect re = TQStyle::visualRect( subRect( SR_ComboBoxFocusRect, ceData, elementFlags, widget ), ceData, elementFlags );
+		    drawPrimitive( PE_FocusRect, p, ceData, elementFlags, re, cg );
 		}
 	    }
 	    if ( sub & SC_ComboBoxEditField ) {
-		if ( cb->editable() ) {
+		if ( elementFlags & CEF_IsEditable ) {
 		    TQRect er =
-			TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, cb,
-								    SC_ComboBoxEditField ), cb );
+			TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, ceData, elementFlags,
+								    SC_ComboBoxEditField, TQStyleOption::Default, widget ), ceData, elementFlags );
 		    er.addCoords( -1, -1, 1, 1);
 		    qDrawShadePanel( p, TQRect( er.x()-1, er.y()-1,
 					       er.width()+2, er.height()+2 ),
@@ -1269,27 +1269,26 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
     case CC_ScrollBar:
 	{
 #ifndef QT_NO_SCROLLBAR
-	    TQScrollBar *scrollbar = (TQScrollBar*)widget;
-	    bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue());
+	    bool maxedOut = (ceData.minSteps == ceData.maxSteps);
 	    if ( maxedOut )
 		flags &= ~Style_Enabled;
 
-	    TQRect handle = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarSlider, opt ), widget );
+	    TQRect handle = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, ceData, elementFlags, SC_ScrollBarSlider, opt, widget ), ceData, elementFlags );
 
 	    if ( sub & SC_ScrollBarGroove ) {
 	    }
 	    if ( sub & SC_ScrollBarAddLine ) {
-		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarAddLine, opt ), widget );
-		drawPrimitive( PE_ScrollBarAddLine, p, er, cg, flags, opt );
+		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, ceData, elementFlags, SC_ScrollBarAddLine, opt, widget ), ceData, elementFlags );
+		drawPrimitive( PE_ScrollBarAddLine, p, ceData, elementFlags, er, cg, flags, opt );
 	    }
 	    if ( sub & SC_ScrollBarSubLine ) {
-		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarSubLine, opt ), widget );
-		drawPrimitive( PE_ScrollBarSubLine, p, er, cg, flags, opt );
+		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, ceData, elementFlags, SC_ScrollBarSubLine, opt, widget ), ceData, elementFlags );
+		drawPrimitive( PE_ScrollBarSubLine, p, ceData, elementFlags, er, cg, flags, opt );
 	    }
 	    if ( sub & SC_ScrollBarAddPage ) {
-		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarAddPage, opt ), widget );
+		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, ceData, elementFlags, SC_ScrollBarAddPage, opt, widget ), ceData, elementFlags );
 		TQRegion region( er );
-		if ( d->lastScrollbarRect.scrollbar == scrollbar &&
+		if ( d->lastScrollbarRect.scrollbar == widget &&
 		     d->lastScrollbarRect.rect.isValid() &&
 		     er.intersects( d->lastScrollbarRect.rect ) ) {
 		    region = region.subtract( d->lastScrollbarRect.rect );
@@ -1300,9 +1299,9 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
 		    p->setClipRegion( region );
 		}
 
-		drawPrimitive( PE_ScrollBarAddPage, p, er, cg, flags & ~Style_MouseOver, opt );
+		drawPrimitive( PE_ScrollBarAddPage, p, ceData, elementFlags, er, cg, flags & ~Style_MouseOver, opt );
 
-		if ( d->lastScrollbarRect.scrollbar == scrollbar &&
+		if ( d->lastScrollbarRect.scrollbar == widget &&
 		     d->lastScrollbarRect.rect.isValid() &&
 		     er.intersects( d->lastScrollbarRect.rect ) ) {
 		    if ( sub & SC_ScrollBarSlider && handle.isValid() ) {
@@ -1317,9 +1316,9 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
 		p->setClipping( FALSE );
 	    }
 	    if ( sub & SC_ScrollBarSubPage ) {
-		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, widget, SC_ScrollBarSubPage, opt ), widget );
+		TQRect er = TQStyle::visualRect( querySubControlMetrics( CC_ScrollBar, ceData, elementFlags, SC_ScrollBarSubPage, opt, widget ), ceData, elementFlags );
 		TQRegion region( er );
-		if ( d->lastScrollbarRect.scrollbar == scrollbar &&
+		if ( d->lastScrollbarRect.scrollbar == widget &&
 		     d->lastScrollbarRect.rect.isValid() &&
 		     er.intersects( d->lastScrollbarRect.rect ) ) {
 		    region = region.subtract( d->lastScrollbarRect.rect );
@@ -1329,8 +1328,8 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
 		    region = region.subtract( handle );
 		    p->setClipRegion( region );
 		}
-		drawPrimitive( PE_ScrollBarSubPage, p, er, cg, flags & ~Style_MouseOver, opt );
-		if ( d->lastScrollbarRect.scrollbar == scrollbar &&
+		drawPrimitive( PE_ScrollBarSubPage, p, ceData, elementFlags, er, cg, flags & ~Style_MouseOver, opt );
+		if ( d->lastScrollbarRect.scrollbar == widget &&
 		     d->lastScrollbarRect.rect.isValid() &&
 		     er.intersects( d->lastScrollbarRect.rect ) ) {
 		    if ( sub & SC_ScrollBarSlider && handle.isValid() ) {
@@ -1349,14 +1348,14 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
 		if ( subActive == SC_ScrollBarSlider )
 		    flags |= Style_Active;
 
-		drawPrimitive( PE_ScrollBarSlider, p, handle, cg, flags, opt );
+		drawPrimitive( PE_ScrollBarSlider, p, ceData, elementFlags, handle, cg, flags, opt );
 	    }
 #endif
 	}
 	break;
 
     default:
-	TQMotifStyle::drawComplexControl( control, p, widget, r, cg, flags, sub, subActive, opt );
+// 	TQMotifStyle::drawComplexControl( control, p, ceData, elementFlags, r, cg, flags, sub, subActive, opt, widget );
 	break;
     }
 }
@@ -1364,9 +1363,11 @@ void TQSGIStyle::drawComplexControl( ComplexControl control,
 /*!\reimp
 */
 TQSize TQSGIStyle::sizeFromContents( ContentsType contents,
-				     const TQWidget *widget,
+				     TQStyleControlElementData ceData,
+				     ControlElementFlags elementFlags,
 				     const TQSize &contentsSize,
-				     const TQStyleOption& opt ) const
+				     const TQStyleOption& opt,
+				     const TQWidget *widget ) const
 {
     TQSize sz(contentsSize);
 
@@ -1374,15 +1375,14 @@ TQSize TQSGIStyle::sizeFromContents( ContentsType contents,
     case CT_PopupMenuItem:
 	{
 #ifndef QT_NO_POPUPMENU
-	    if (! widget || opt.isDefault())
+	    if ((elementFlags & CEF_UseGenericParameters) || opt.isDefault())
 		break;
 
 	    TQMenuItem *mi = opt.menuItem();
-	    sz = TQMotifStyle::sizeFromContents( contents, widget, contentsSize,
-						opt );
+	    sz = TQMotifStyle::sizeFromContents( contents, ceData, elementFlags, contentsSize,
+						opt, widget );
 	    // SGI checkmark items needs a bit more room
-	    const TQPopupMenu *popup = (TQPopupMenu *) widget;
-	    if ( popup && popup->isCheckable() )
+	    if ( elementFlags & CEF_IsCheckable )
 		sz.setWidth( sz.width() + 8 );
 	    // submenu indicator needs a bit more room
 	    if (mi->popup())
@@ -1395,7 +1395,7 @@ TQSize TQSGIStyle::sizeFromContents( ContentsType contents,
         break;
 
     default:
-	sz = TQMotifStyle::sizeFromContents( contents, widget, contentsSize, opt );
+	sz = TQMotifStyle::sizeFromContents( contents, ceData, elementFlags, contentsSize, opt, widget );
 	break;
     }
 
@@ -1403,7 +1403,7 @@ TQSize TQSGIStyle::sizeFromContents( ContentsType contents,
 }
 
 /*! \reimp */
-TQRect TQSGIStyle::subRect( SubRect r, const TQWidget *widget ) const
+TQRect TQSGIStyle::subRect( SubRect r, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget ) const
 {
     TQRect rect;
 
@@ -1411,8 +1411,8 @@ TQRect TQSGIStyle::subRect( SubRect r, const TQWidget *widget ) const
     case SR_ComboBoxFocusRect:
 	{
 	    int awh, ax, ay, sh, sy, dh, ew;
-	    int fw = pixelMetric( PM_DefaultFrameWidth, widget );
-	    TQRect tr = widget->rect();
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget );
+	    TQRect tr = ceData.rect;
 
 	    tr.addCoords( fw, fw, -fw, -fw );
 	    get_combo_parameters( tr, ew, awh, ax, ay, sh, dh, sy );
@@ -1420,7 +1420,7 @@ TQRect TQSGIStyle::subRect( SubRect r, const TQWidget *widget ) const
 	}
 	break;
     default:
-	return TQMotifStyle::subRect( r, widget );
+	return TQMotifStyle::subRect( r, ceData, elementFlags, widget );
     }
 
     return rect;
@@ -1428,27 +1428,29 @@ TQRect TQSGIStyle::subRect( SubRect r, const TQWidget *widget ) const
 
 /*! \reimp */
 TQRect TQSGIStyle::querySubControlMetrics( ComplexControl control,
-					   const TQWidget *widget,
+					   TQStyleControlElementData ceData,
+					   ControlElementFlags elementFlags,
 					   SubControl sub,
-					   const TQStyleOption& opt ) const
+					   const TQStyleOption& opt,
+					   const TQWidget *widget ) const
 {
     switch ( control ) {
     case CC_ComboBox:
 	switch ( sub ) {
 	case SC_ComboBoxFrame:
-	    return widget->rect();
+	    return ceData.rect;
 
 	case SC_ComboBoxArrow: {
 	    int ew, awh, sh, dh, ax, ay, sy;
-	    int fw = pixelMetric( PM_DefaultFrameWidth, widget );
-	    TQRect cr = widget->rect();
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget );
+	    TQRect cr = ceData.rect;
 	    cr.addCoords( fw, fw, -fw, -fw );
 	    get_combo_parameters( cr, ew, awh, ax, ay, sh, dh, sy );
 	    return TQRect( ax, ay, awh, awh ); }
 
 	case SC_ComboBoxEditField: {
-	    int fw = pixelMetric( PM_DefaultFrameWidth, widget );
-	    TQRect rect = widget->rect();
+	    int fw = pixelMetric( PM_DefaultFrameWidth, ceData, elementFlags, widget );
+	    TQRect rect = ceData.rect;
 	    rect.addCoords( fw, fw, -fw, -fw );
 	    int ew = get_combo_extra_width( rect.height() );
 	    rect.addCoords( 1, 1, -1-ew, -1 );
@@ -1459,10 +1461,10 @@ TQRect TQSGIStyle::querySubControlMetrics( ComplexControl control,
 	}
 	break;
 	case CC_ScrollBar:
-	    return TQCommonStyle::querySubControlMetrics( control, widget, sub, opt );
+	    return TQCommonStyle::querySubControlMetrics( control, ceData, elementFlags, sub, opt, widget );
 	default: break;
     }
-    return TQMotifStyle::querySubControlMetrics( control, widget, sub, opt );
+    return TQMotifStyle::querySubControlMetrics( control, ceData, elementFlags, sub, opt, widget );
 }
 
 #endif // QT_NO_STYLE_SGI
diff --git a/src/styles/qwindowsstyle.cpp b/src/styles/qwindowsstyle.cpp
index e716a53e..5a1289dc 100644
--- a/src/styles/qwindowsstyle.cpp
+++ b/src/styles/qwindowsstyle.cpp
@@ -66,10 +66,6 @@
 #include "ntqobjectlist.h"
 #include "ntqmenubar.h"
 
-#if defined(Q_WS_WIN)
-#include "qt_windows.h"
-#endif
-
 #include <limits.h>
 
 
@@ -99,99 +95,42 @@ class TQWindowsStyle::Private : public TQObject
 public:
     Private(TQWindowsStyle *parent);
 
-    bool hasSeenAlt(const TQWidget *widget) const;
-    bool altDown() const { return alt_down; }
-
-protected:
-    bool eventFilter(TQObject *o, TQEvent *e);
+    bool objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e );
 
 private:
-    TQPtrList<TQWidget> seenAlt;
-    bool alt_down;
     int menuBarTimer;
 };
 
 TQWindowsStyle::Private::Private(TQWindowsStyle *parent)
-: TQObject(parent, "TQWindowsStylePrivate"), alt_down(FALSE), menuBarTimer(0)
+: TQObject(parent, "TQWindowsStylePrivate"), menuBarTimer(0)
 {
 }
 
-// Returns true if the toplevel parent of \a widget has seen the Alt-key
-bool TQWindowsStyle::Private::hasSeenAlt(const TQWidget *widget) const
-{
-    widget = widget->topLevelWidget();
-    return seenAlt.contains(widget);
-}
-
 // Records Alt- and Focus events
-bool TQWindowsStyle::Private::eventFilter(TQObject *o, TQEvent *e)
+bool TQWindowsStyle::Private::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags, void* source, TQEvent *e )
 {
-    if (!o->isWidgetType())
-	return TQObject::eventFilter(o, e);
+    if (!(ceData.widgetObjectTypes.contains("TQWidget"))) {
+	return TRUE;
+    }
 
-    TQWidget *widget = ::tqt_cast<TQWidget*>(o);
+    TQWidget *widget = reinterpret_cast<TQWidget*>(source);
 
     switch(e->type()) {
-    case TQEvent::KeyPress:
-	if (((TQKeyEvent*)e)->key() == Key_Alt) {
-	    widget = widget->topLevelWidget();
-
-	    // Alt has been pressed - find all widgets that care
-	    TQObjectList *l = widget->queryList("TQWidget");
-	    TQObjectListIt it( *l );
-	    TQWidget *w;
-	    while ( (w = (TQWidget*)it.current()) != 0 ) {
-		++it;
-		if (w->isTopLevel() || !w->isVisible() ||
-		    w->style().styleHint(SH_UnderlineAccelerator, w))
-		    l->removeRef(w);
-	    }
-	    // Update states before repainting
-	    seenAlt.append(widget);
-	    alt_down = TRUE;
-
-	    // Repaint all relevant widgets
-	    it.toFirst();
-	    while ( (w = (TQWidget*)it.current()) != 0 ) {
-		++it;
-		w->repaint(FALSE);
-	    }
-	    delete l;
-	}
-	break;
-    case TQEvent::KeyRelease:
-	if (((TQKeyEvent*)e)->key() == Key_Alt) {
-	    widget = widget->topLevelWidget();
-
-	    // Update state
-	    alt_down = FALSE;
-	    // Repaint only menubars
-	    TQObjectList *l = widget->queryList("TQMenuBar");
-	    TQObjectListIt it( *l );
-	    TQMenuBar *menuBar;
-	    while ( (menuBar = (TQMenuBar*)it.current()) != 0) {
-		++it;
-		menuBar->repaint(FALSE);
-	    }
-	}
-	break;
     case TQEvent::FocusIn:
     case TQEvent::FocusOut:
 	{
 	    // Menubars toggle based on focus
-	    TQMenuBar *menuBar = ::tqt_cast<TQMenuBar*>(o);
+	    TQMenuBar *menuBar = ::tqt_cast<TQMenuBar*>(widget);
 	    if (menuBar && !menuBarTimer) // delayed repaint to avoid flicker
 		menuBarTimer = menuBar->startTimer(0);
 	}
 	break;
     case TQEvent::Close:
 	// Reset widget when closing
-	seenAlt.removeRef(widget);
-	seenAlt.removeRef(widget->topLevelWidget());
 	break;
     case TQEvent::Timer:
 	{
-	    TQMenuBar *menuBar = ::tqt_cast<TQMenuBar*>(o);
+	    TQMenuBar *menuBar = ::tqt_cast<TQMenuBar*>(widget);
 	    TQTimerEvent *te = (TQTimerEvent*)e;
 	    if (menuBar && te->timerId() == menuBarTimer) {
 		menuBar->killTimer(te->timerId());
@@ -205,7 +144,7 @@ bool TQWindowsStyle::Private::eventFilter(TQObject *o, TQEvent *e)
 	break;
     }
 
-    return TQObject::eventFilter(o, e);
+    return TRUE;
 }
 
 /*!
@@ -234,32 +173,40 @@ TQWindowsStyle::~TQWindowsStyle()
 }
 
 /*! \reimp */
-void TQWindowsStyle::polish(TQApplication *app)
+bool TQWindowsStyle::objectEventHandler( TQStyleControlElementData ceData, ControlElementFlags elementFlags, void* source, TQEvent *e ) {
+    if (d) {
+        return d->objectEventHandler(ceData, elementFlags, source, e);
+    }
+    return TRUE;
+}
+
+/*! \reimp */
+void TQWindowsStyle::applicationPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr)
 {
     // We only need the overhead when shortcuts are sometimes hidden
-    if (!styleHint(SH_UnderlineAccelerator, 0)) {
+    if (styleHint(SH_UnderlineAccelerator, TQStyleControlElementData(), CEF_None, 0) && styleHint(SH_HideUnderlineAcceleratorWhenAltUp, TQStyleControlElementData(), CEF_None, 0)) {
 	d = new Private(this);
-	app->installEventFilter(d);
+	installObjectEventHandler(ceData, elementFlags, ptr, this);
     }
 }
 
 /*! \reimp */
-void TQWindowsStyle::unPolish(TQApplication *)
+void TQWindowsStyle::applicationUnPolish(TQStyleControlElementData, ControlElementFlags, void *)
 {
     delete d;
     d = 0;
 }
 
 /*! \reimp */
-void TQWindowsStyle::polish(TQWidget *widget)
+void TQWindowsStyle::polish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr)
 {
-    TQCommonStyle::polish(widget);
+    TQCommonStyle::polish(ceData, elementFlags, ptr);
 }
 
 /*! \reimp */
-void TQWindowsStyle::unPolish(TQWidget *widget)
+void TQWindowsStyle::unPolish(TQStyleControlElementData ceData, ControlElementFlags elementFlags, void *ptr)
 {
-    TQCommonStyle::polish(widget);
+    TQCommonStyle::polish(ceData, elementFlags, ptr);
 }
 
 /*! \reimp */
@@ -271,6 +218,8 @@ void TQWindowsStyle::polish( TQPalette &pal )
 /*! \reimp */
 void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 				   TQPainter *p,
+				   TQStyleControlElementData ceData,
+				   ControlElementFlags elementFlags,
 				   const TQRect &r,
 				   const TQColorGroup &cg,
 				   SFlags flags,
@@ -315,31 +264,6 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 		p->fillRect(r, fill);
 	    break;
 	}
-#if defined(Q_WS_WIN)
-    case PE_HeaderArrow:
-	p->save();
-	if ( flags & Style_Up ) { // invert logic to follow Windows style guide
-	    TQPointArray pa( 3 );
-	    p->setPen( cg.light() );
-	    p->drawLine( r.x() + r.width(), r.y(), r.x() + r.width() / 2, r.height() );
-	    p->setPen( cg.dark() );
-	    pa.setPoint( 0, r.x() + r.width() / 2, r.height() );
-	    pa.setPoint( 1, r.x(), r.y() );
-	    pa.setPoint( 2, r.x() + r.width(), r.y() );
-	    p->drawPolyline( pa );
-	} else {
-	    TQPointArray pa( 3 );
-	    p->setPen( cg.light() );
-	    pa.setPoint( 0, r.x(), r.height() );
-	    pa.setPoint( 1, r.x() + r.width(), r.height() );
-	    pa.setPoint( 2, r.x() + r.width() / 2, r.y() );
-	    p->drawPolyline( pa );
-	    p->setPen( cg.dark() );
-	    p->drawLine( r.x(), r.height(), r.x() + r.width() / 2, r.y() );
-	}
-	p->restore();
-	break;
-#endif
 
     case PE_ButtonDefault:
 	p->setPen(cg.shadow());
@@ -507,7 +431,7 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
     case PE_Panel:
     case PE_PanelPopup:
 	{
-	    int lw = opt.isDefault() ? pixelMetric(PM_DefaultFrameWidth)
+	    int lw = opt.isDefault() ? pixelMetric(PM_DefaultFrameWidth, ceData, elementFlags)
 			: opt.lineWidth();
 
 	    if (lw == 2) {
@@ -518,7 +442,7 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 		}
 		qDrawWinPanel(p, r, popupCG, flags & Style_Sunken);
 	    } else {
-		TQCommonStyle::drawPrimitive(pe, p, r, cg, flags, opt);
+		TQCommonStyle::drawPrimitive(pe, p, ceData, elementFlags, r, cg, flags, opt);
 	    }
 	    break;
 	}
@@ -572,13 +496,13 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 		p->setBrush( cg.brush( TQColorGroup::Button ) );
 		p->drawRect( r );
 	    } else
-		drawPrimitive(PE_ButtonBevel, p, r, cg, flags | Style_Raised);
+		drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, r, cg, flags | Style_Raised);
 	} else
-	    drawPrimitive(PE_ButtonBevel, p, r, cg, (flags & Style_Enabled) |
+	    drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, r, cg, (flags & Style_Enabled) |
 			  ((flags & Style_Down) ? Style_Down : Style_Raised));
 
 	drawPrimitive(((flags & Style_Horizontal) ? PE_ArrowLeft : PE_ArrowUp),
-		      p, r, cg, flags);
+		      p, ceData, elementFlags, r, cg, flags);
 	break;
 
     case PE_ScrollBarAddLine:
@@ -588,13 +512,13 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 		p->setBrush( cg.brush( TQColorGroup::Button ) );
 		p->drawRect( r );
 	    } else
-		drawPrimitive(PE_ButtonBevel, p, r, cg, flags | Style_Raised);
+		drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, r, cg, flags | Style_Raised);
 	} else
-	    drawPrimitive(PE_ButtonBevel, p, r, cg, (flags & Style_Enabled) |
+	    drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, r, cg, (flags & Style_Enabled) |
 			  ((flags & Style_Down) ? Style_Down : Style_Raised));
 
 	drawPrimitive(((flags & Style_Horizontal) ? PE_ArrowRight : PE_ArrowDown),
-		      p, r, cg, flags);
+		      p, ceData, elementFlags, r, cg, flags);
 	break;
 
     case PE_ScrollBarAddPage:
@@ -632,7 +556,7 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 	    p->setBackgroundMode(OpaqueMode);
 	    p->drawRect(r);
 	} else
-	    drawPrimitive(PE_ButtonBevel, p, r, cg, Style_Enabled | Style_Raised);
+	    drawPrimitive(PE_ButtonBevel, p, ceData, elementFlags, r, cg, Style_Enabled | Style_Raised);
 	break;
 
     case PE_WindowFrame:
@@ -674,8 +598,8 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 
 	    p->save();
 	    if ( flags & Style_Down )
-		p->translate( pixelMetric( PM_ButtonShiftHorizontal ),
-			      pixelMetric( PM_ButtonShiftVertical ) );
+		p->translate( pixelMetric( PM_ButtonShiftHorizontal, ceData, elementFlags ),
+			      pixelMetric( PM_ButtonShiftVertical, ceData, elementFlags ) );
 
 	    if ( flags & Style_Enabled ) {
 		a.translate( r.x() + r.width() / 2, r.y() + r.height() / 2 );
@@ -694,7 +618,7 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 	    }
 	    p->restore();
 	} else
-	    TQCommonStyle::drawPrimitive(pe, p, r, cg, flags, opt);
+	    TQCommonStyle::drawPrimitive(pe, p, ceData, elementFlags, r, cg, flags, opt);
     }
 }
 
@@ -704,33 +628,34 @@ void TQWindowsStyle::drawPrimitive( PrimitiveElement pe,
 */
 void TQWindowsStyle::drawControl( ControlElement element,
 				 TQPainter *p,
-				 const TQWidget *widget,
+				 TQStyleControlElementData ceData,
+				 ControlElementFlags elementFlags,
 				 const TQRect &r,
 				 const TQColorGroup &cg,
 				 SFlags flags,
-				 const TQStyleOption& opt ) const
+				 const TQStyleOption& opt,
+				 const TQWidget *widget ) const
 {
     switch (element) {
 #ifndef QT_NO_TABBAR
     case CE_TabBarTab:
 	{
-	    if ( !widget || !widget->parentWidget() || !opt.tab() )
+	    if ( ( elementFlags & CEF_UseGenericParameters ) || (!( elementFlags & CEF_HasParentWidget )) || !opt.tab() )
 		break;
 
-	    const TQTabBar * tb = (const TQTabBar *) widget;
 	    const TQTab * t = opt.tab();
 	    bool selected = flags & Style_Selected;
-	    bool lastTab = (tb->indexOf( t->identifier() ) == tb->count()-1) ?
+	    bool lastTab = (ceData.tabBarData.identIndexMap[t->identifier()] == ceData.tabBarData.tabCount-1) ?
 			   TRUE : FALSE;
 	    TQRect r2( r );
-	    if ( tb->shape()  == TQTabBar::RoundedAbove ) {
+	    if ( ceData.tabBarData.shape  == TQTabBar::RoundedAbove ) {
 		p->setPen( cg.midlight() );
 
 		p->drawLine( r2.left(), r2.bottom(), r2.right(), r2.bottom() );
 		p->setPen( cg.light() );
 		p->drawLine( r2.left(), r2.bottom()-1, r2.right(), r2.bottom()-1 );
 		if ( r2.left() == 0 )
-		    p->drawPoint( tb->rect().bottomLeft() );
+		    p->drawPoint( ceData.rect.bottomLeft() );
 
 		if ( selected ) {
 		    p->fillRect( TQRect( r2.left()+1, r2.bottom()-1, r2.width()-3, 2),
@@ -774,9 +699,9 @@ void TQWindowsStyle::drawControl( ControlElement element,
 		x2++;
 		p->drawLine( x2, r2.top() + 2, x2, r2.bottom() -
 			     (selected ? (lastTab ? 0:1) :2));
-	    } else if ( tb->shape() == TQTabBar::RoundedBelow ) {
-		bool rightAligned = styleHint( SH_TabBar_Alignment, tb ) == AlignRight;
-		bool firstTab = tb->indexOf( t->identifier() ) == 0;
+	    } else if ( ceData.tabBarData.shape == TQTabBar::RoundedBelow ) {
+		bool rightAligned = styleHint( SH_TabBar_Alignment, ceData, elementFlags, TQStyleOption::Default, 0, widget ) == AlignRight;
+		bool firstTab = ceData.tabBarData.identIndexMap[t->identifier()] == 0;
 		if ( selected ) {
 		    p->fillRect( TQRect( r2.left()+1, r2.top(), r2.width()-3, 1),
 				 cg.brush( TQColorGroup::Background ));
@@ -823,7 +748,7 @@ void TQWindowsStyle::drawControl( ControlElement element,
 		p->drawLine( r2.left(), r2.top() + (selected ? 0 : 2),
 			     r2.left(), r2.bottom() - 2 );
 	    } else {
-		TQCommonStyle::drawControl(element, p, widget, r, cg, flags, opt);
+		TQCommonStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
 	    }
 	    break;
 	}
@@ -838,10 +763,9 @@ void TQWindowsStyle::drawControl( ControlElement element,
 #ifndef QT_NO_POPUPMENU
     case CE_PopupMenuItem:
 	{
-	    if (! widget || opt.isDefault())
+	    if (( elementFlags & CEF_UseGenericParameters ) || opt.isDefault())
 		break;
 
-	    const TQPopupMenu *popupmenu = (const TQPopupMenu *) widget;
 	    TQMenuItem *mi = opt.menuItem();
 	    if ( !mi )
 		break;
@@ -849,7 +773,7 @@ void TQWindowsStyle::drawControl( ControlElement element,
 	    int tab = opt.tabWidth();
 	    int maxpmw = opt.maxIconWidth();
 	    bool dis = !(flags&Style_Enabled);
-	    bool checkable = popupmenu->isCheckable();
+	    bool checkable = ( elementFlags & CEF_IsCheckable );
 	    bool act = flags & Style_Active;
 	    int x, y, w, h;
 
@@ -937,7 +861,7 @@ void TQWindowsStyle::drawControl( ControlElement element,
 		    if (act)
 			cflags |= Style_On;
 
-		    drawPrimitive(PE_CheckMark, p,
+		    drawPrimitive(PE_CheckMark, p, ceData, elementFlags,
 				  visualRect( TQRect(xp, y + windowsItemFrame,
 					checkcol - 2*windowsItemFrame,
 					h - 2*windowsItemFrame), r ), cg, cflags);
@@ -973,8 +897,9 @@ void TQWindowsStyle::drawControl( ControlElement element,
 	    if ( !s.isNull() ) {                        // draw text
 		int t = s.find( '\t' );
 		int text_flags = AlignVCenter|ShowPrefix | DontClip | SingleLine;
-		if (!styleHint(SH_UnderlineAccelerator, widget))
+		if ((!styleHint(SH_UnderlineAccelerator, ceData, elementFlags, TQStyleOption::Default, 0, widget)) || ((styleHint(SH_HideUnderlineAcceleratorWhenAltUp, ceData, elementFlags, TQStyleOption::Default, 0, widget)) && (!acceleratorsShown()))) {
 		    text_flags |= NoAccel;
+		}
 		text_flags |= (TQApplication::reverseLayout() ? AlignRight : AlignLeft );
 		if ( t >= 0 ) {                         // draw tab text
 		    int xp = x + w - tab - windowsItemHMargin - windowsItemFrame + 1;
@@ -1014,10 +939,10 @@ void TQWindowsStyle::drawControl( ControlElement element,
 		if ( act ) {
 		    TQColorGroup g2 = cg;
 		    g2.setColor( TQColorGroup::ButtonText, g2.highlightedText() );
-		    drawPrimitive(arrow, p, vrect,
+		    drawPrimitive(arrow, p, ceData, elementFlags, vrect,
 				  g2, dis ? Style_Default : Style_Enabled);
 		} else {
-		    drawPrimitive(arrow, p, vrect,
+		    drawPrimitive(arrow, p, ceData, elementFlags, vrect,
 				  cg, dis ? Style_Default : Style_Enabled );
 		}
 	    }
@@ -1042,17 +967,17 @@ void TQWindowsStyle::drawControl( ControlElement element,
 		    qDrawShadeRect( p, r.x(), r.y(), r.width(), r.height(),
 				    cg, active && down, 1, 0, &b );
 		if ( active && down ) {
-		    pr.moveBy( pixelMetric(PM_ButtonShiftHorizontal, widget),
-			       pixelMetric(PM_ButtonShiftVertical, widget) );
+		    pr.moveBy( pixelMetric(PM_ButtonShiftHorizontal, ceData, elementFlags, widget),
+			       pixelMetric(PM_ButtonShiftVertical, ceData, elementFlags, widget) );
 		    p->setBrushOrigin(p->brushOrigin() - TQPoint(1,1));
 		}
 	    }
-	    TQCommonStyle::drawControl(element, p, widget, pr, cg, flags, opt);
+	    TQCommonStyle::drawControl(element, p, ceData, elementFlags, pr, cg, flags, opt, widget);
 	    break;
 	}
 
     default:
-	TQCommonStyle::drawControl(element, p, widget, r, cg, flags, opt);
+	TQCommonStyle::drawControl(element, p, ceData, elementFlags, r, cg, flags, opt, widget);
     }
 }
 
@@ -1060,7 +985,7 @@ void TQWindowsStyle::drawControl( ControlElement element,
 /*!
   \reimp
 */
-int TQWindowsStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) const
+int TQWindowsStyle::pixelMetric(PixelMetric metric, TQStyleControlElementData ceData, ControlElementFlags elementFlags, const TQWidget *widget) const
 {
     int ret;
 
@@ -1085,10 +1010,9 @@ int TQWindowsStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) cons
 	// equally between the tickmark regions.
     case PM_SliderControlThickness:
 	{
-	    const TQSlider * sl = (const TQSlider *) widget;
-	    int space = (sl->orientation() == Horizontal) ? sl->height()
-			: sl->width();
-	    int ticks = sl->tickmarks();
+	    int space = (ceData.orientation == Horizontal) ? ceData.rect.height()
+			: ceData.rect.width();
+	    int ticks = ceData.tickMarkSetting;
 	    int n = 0;
 	    if ( ticks & TQSlider::Above ) n++;
 	    if ( ticks & TQSlider::Below ) n++;
@@ -1099,7 +1023,7 @@ int TQWindowsStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) cons
 
 	    int thick = 6;	// Magic constant to get 5 + 16 + 5
 	    if ( ticks != TQSlider::Both && ticks != TQSlider::NoMarks )
-		thick += pixelMetric( PM_SliderLength, sl ) / 4;
+		thick += pixelMetric( PM_SliderLength, ceData, elementFlags, widget ) / 4;
 
 	    space -= thick;
 	    //### the two sides may be unequal in size
@@ -1114,46 +1038,12 @@ int TQWindowsStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) cons
 	ret = 0;
 	break;
 
-#if defined(Q_WS_WIN)
-    case PM_TitleBarHeight:
-	if ( widget && ( widget->testWFlags( WStyle_Tool ) || ::tqt_cast<TQDockWindow*>(widget) ) ) {
-	    // MS always use one less than they say
-#if defined(Q_OS_TEMP)
-	    ret = GetSystemMetrics( SM_CYCAPTION ) - 1;
-#else
-	    ret = GetSystemMetrics( SM_CYSMCAPTION ) - 1;
-#endif
-	} else {
-	    ret = GetSystemMetrics( SM_CYCAPTION ) - 1;
-	}
-	break;
-
-    case PM_ScrollBarExtent:
-	{
-#ifndef Q_OS_TEMP
-	    NONCLIENTMETRICS ncm;
-	    ncm.cbSize = sizeof(NONCLIENTMETRICS);
-	    if ( SystemParametersInfo( SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &ncm, 0 ) )
-		ret = TQMAX( ncm.iScrollHeight, ncm.iScrollWidth );
-	    else
-#endif
-		ret = TQCommonStyle::pixelMetric( metric, widget );
-	}
-	break;
-#endif
-
     case PM_SplitterWidth:
 	ret = TQMAX( 6, TQApplication::globalStrut().width() );
 	break;
 
-#if defined(Q_WS_WIN)
-    case PM_MDIFrameWidth:
-	ret = GetSystemMetrics(SM_CYFRAME);
-	break;
-#endif
-
     default:
-	ret = TQCommonStyle::pixelMetric(metric, widget);
+	ret = TQCommonStyle::pixelMetric(metric, ceData, elementFlags, widget);
 	break;
     }
 
@@ -1165,9 +1055,11 @@ int TQWindowsStyle::pixelMetric(PixelMetric metric, const TQWidget *widget) cons
   \reimp
 */
 TQSize TQWindowsStyle::sizeFromContents( ContentsType contents,
-				       const TQWidget *widget,
+				       TQStyleControlElementData ceData,
+				       ControlElementFlags elementFlags,
 				       const TQSize &contentsSize,
-				       const TQStyleOption& opt ) const
+				       const TQStyleOption& opt,
+				       const TQWidget *widget ) const
 {
     TQSize sz(contentsSize);
 
@@ -1175,15 +1067,14 @@ TQSize TQWindowsStyle::sizeFromContents( ContentsType contents,
     case CT_PushButton:
 	{
 #ifndef QT_NO_PUSHBUTTON
-	    const TQPushButton *button = (const TQPushButton *) widget;
-	    sz = TQCommonStyle::sizeFromContents(contents, widget, contentsSize, opt);
+	    sz = TQCommonStyle::sizeFromContents(contents, ceData, elementFlags, contentsSize, opt, widget);
 	    int w = sz.width(), h = sz.height();
 
 	    int defwidth = 0;
-	    if (button->isDefault() || button->autoDefault())
-		defwidth = 2*pixelMetric( PM_ButtonDefaultIndicator, widget );
+	    if ((elementFlags & CEF_IsDefault) || (elementFlags & CEF_AutoDefault))
+		defwidth = 2*pixelMetric( PM_ButtonDefaultIndicator, ceData, elementFlags, widget );
 
-	    if (w < 80+defwidth && !button->pixmap())
+	    if (w < 80+defwidth && ceData.fgPixmap.isNull())
 		w = 80+defwidth;
 	    if (h < 23+defwidth)
 		h = 23+defwidth;
@@ -1196,11 +1087,10 @@ TQSize TQWindowsStyle::sizeFromContents( ContentsType contents,
     case CT_PopupMenuItem:
 	{
 #ifndef QT_NO_POPUPMENU
-	    if (! widget || opt.isDefault())
+	    if (( elementFlags & CEF_UseGenericParameters ) || opt.isDefault())
 		break;
 
-	    const TQPopupMenu *popup = (const TQPopupMenu *) widget;
-	    bool checkable = popup->isCheckable();
+	    bool checkable = ( elementFlags & CEF_IsCheckable );
 	    TQMenuItem *mi = opt.menuItem();
 	    int maxpmw = opt.maxIconWidth();
 	    int w = sz.width(), h = sz.height();
@@ -1218,7 +1108,7 @@ TQSize TQWindowsStyle::sizeFromContents( ContentsType contents,
 		if (mi->pixmap())
 		    h = TQMAX(h, mi->pixmap()->height() + 2*windowsItemFrame);
 		else if (! mi->text().isNull())
-		    h = TQMAX(h, popup->fontMetrics().height() + 2*windowsItemVMargin +
+		    h = TQMAX(h, TQFontMetrics(ceData.font).height() + 2*windowsItemVMargin +
 			     2*windowsItemFrame);
 
 		if (mi->iconSet() != 0)
@@ -1256,7 +1146,7 @@ TQSize TQWindowsStyle::sizeFromContents( ContentsType contents,
 	}
 
     default:
-	sz = TQCommonStyle::sizeFromContents(contents, widget, sz, opt);
+	sz = TQCommonStyle::sizeFromContents(contents, ceData, elementFlags, sz, opt, widget);
 	break;
     }
 
@@ -1556,8 +1446,10 @@ static const char *const question_xpm[] = {
  \reimp
  */
 TQPixmap TQWindowsStyle::stylePixmap(StylePixmap stylepixmap,
-				   const TQWidget *widget,
-				   const TQStyleOption& opt) const
+				   TQStyleControlElementData ceData,
+				   ControlElementFlags elementFlags,
+				   const TQStyleOption& opt,
+				   const TQWidget *widget) const
 {
 #ifndef QT_NO_IMAGEIO_XPM
     switch (stylepixmap) {
@@ -1587,26 +1479,28 @@ TQPixmap TQWindowsStyle::stylePixmap(StylePixmap stylepixmap,
 	break;
     }
 #endif //QT_NO_IMAGEIO_XPM
-    return TQCommonStyle::stylePixmap(stylepixmap, widget, opt);
+    return TQCommonStyle::stylePixmap(stylepixmap, ceData, elementFlags, opt, widget);
 }
 
 /*!\reimp
 */
 void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
-					const TQWidget *widget,
+					TQStyleControlElementData ceData,
+					ControlElementFlags elementFlags,
 					const TQRect &r,
 					const TQColorGroup &cg,
 					SFlags flags,
 					SCFlags sub,
 					SCFlags subActive,
-					const TQStyleOption& opt ) const
+					const TQStyleOption& opt,
+					const TQWidget *widget ) const
 {
     switch (ctrl) {
 #ifndef QT_NO_LISTVIEW
     case CC_ListView:
 	{
 	    if ( sub & SC_ListView ) {
-		TQCommonStyle::drawComplexControl( ctrl, p, widget, r, cg, flags, sub, subActive, opt );
+		TQCommonStyle::drawComplexControl( ctrl, p, ceData, elementFlags, r, cg, flags, sub, subActive, opt, widget );
 	    }
 	    if ( sub & ( SC_ListViewBranch | SC_ListViewExpand ) ) {
 		if (opt.isDefault())
@@ -1769,13 +1663,13 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 	if ( sub & SC_ComboBoxArrow ) {
 	    SFlags flags = Style_Default;
 
-	    qDrawWinPanel( p, r, cg, TRUE, widget->isEnabled() ?
+	    qDrawWinPanel( p, r, cg, TRUE, ( elementFlags & CEF_IsEnabled ) ?
 			   &cg.brush( TQColorGroup::Base ):
 			   &cg.brush( TQColorGroup::Background ) );
 
 	    TQRect ar =
-		TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, widget,
-							    SC_ComboBoxArrow ), widget );
+		TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, ceData, elementFlags,
+							    SC_ComboBoxArrow, TQStyleOption::Default, widget ), ceData, elementFlags );
 	    if ( subActive == SC_ComboBoxArrow ) {
 		p->setPen( cg.dark() );
 		p->setBrush( cg.brush( TQColorGroup::Button ) );
@@ -1785,25 +1679,24 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 			       &cg.brush( TQColorGroup::Button ) );
 
 	    ar.addCoords( 2, 2, -2, -2 );
-	    if ( widget->isEnabled() )
+	    if ( elementFlags & CEF_IsEnabled )
 		flags |= Style_Enabled;
 
 	    if ( subActive == SC_ComboBoxArrow ) {
 		flags |= Style_Sunken;
 	    }
-	    drawPrimitive( PE_ArrowDown, p, ar, cg, flags );
+	    drawPrimitive( PE_ArrowDown, p, ceData, elementFlags, ar, cg, flags );
 	}
 
 	if ( sub & SC_ComboBoxEditField ) {
-	    const TQComboBox * cb = (const TQComboBox *) widget;
 	    TQRect re =
-		TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, widget,
-							    SC_ComboBoxEditField ), widget );
-	    if ( cb->hasFocus() && !cb->editable() )
+		TQStyle::visualRect( querySubControlMetrics( CC_ComboBox, ceData, elementFlags,
+							    SC_ComboBoxEditField, TQStyleOption::Default, widget ), ceData, elementFlags );
+	    if ( ( elementFlags & CEF_HasFocus ) && (!( elementFlags & CEF_IsEditable )) )
 		p->fillRect( re.x(), re.y(), re.width(), re.height(),
 			     cg.brush( TQColorGroup::Highlight ) );
 
-	    if ( cb->hasFocus() ) {
+	    if ( elementFlags & CEF_HasFocus ) {
 		p->setPen( cg.highlightedText() );
 		p->setBackgroundColor( cg.highlight() );
 
@@ -1812,10 +1705,10 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 		p->setBackgroundColor( cg.background() );
 	    }
 
-	    if ( cb->hasFocus() && !cb->editable() ) {
+	    if ( ( elementFlags & CEF_HasFocus ) && (!( elementFlags & CEF_IsEditable )) ) {
 		TQRect re =
-		    TQStyle::visualRect( subRect( SR_ComboBoxFocusRect, cb ), widget );
-		drawPrimitive( PE_FocusRect, p, re, cg, Style_FocusAtBorder, TQStyleOption(cg.highlight()));
+		    TQStyle::visualRect( subRect( SR_ComboBoxFocusRect, ceData, elementFlags, widget ), ceData, elementFlags );
+		drawPrimitive( PE_FocusRect, p, ceData, elementFlags, re, cg, Style_FocusAtBorder, TQStyleOption(cg.highlight()));
 	    }
 	}
 
@@ -1825,15 +1718,14 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 #ifndef QT_NO_SLIDER
     case CC_Slider:
 	{
-	    const TQSlider *sl = (const TQSlider *) widget;
-	    int thickness  = pixelMetric( PM_SliderControlThickness, widget );
-	    int len        = pixelMetric( PM_SliderLength, widget );
-	    int ticks = sl->tickmarks();
+	    int thickness  = pixelMetric( PM_SliderControlThickness, ceData, elementFlags, widget );
+	    int len        = pixelMetric( PM_SliderLength, ceData, elementFlags, widget );
+	    int ticks = ceData.tickMarkSetting;
 
-	    TQRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
-						  opt),
-		  handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
-						  opt);
+	    TQRect groove = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderGroove,
+						  opt, widget),
+		  handle = querySubControlMetrics(CC_Slider, ceData, elementFlags, SC_SliderHandle,
+						  opt, widget);
 
 	    if ((sub & SC_SliderGroove) && groove.isValid()) {
 		int mid = thickness / 2;
@@ -1844,7 +1736,7 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 		    mid -= len / 8;
 
 		p->setPen( cg.shadow() );
-		if ( sl->orientation() == Horizontal ) {
+		if ( ceData.orientation == Horizontal ) {
 		    qDrawWinPanel( p, groove.x(), groove.y() + mid - 2,
 				   groove.width(), 4, cg, TRUE );
 		    p->drawLine( groove.x() + 1, groove.y() + mid - 1,
@@ -1859,9 +1751,9 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 	    }
 
 	    if (sub & SC_SliderTickmarks)
-		TQCommonStyle::drawComplexControl(ctrl, p, widget, r, cg, flags,
+		TQCommonStyle::drawComplexControl(ctrl, p, ceData, elementFlags, r, cg, flags,
 						 SC_SliderTickmarks, subActive,
-						 opt );
+						 opt, widget );
 
 	    if ( sub & SC_SliderHandle ) {
 		// 4444440
@@ -1887,15 +1779,15 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 		int y1 = y;
 		int y2 = y+he-1;
 
-		Orientation orient = sl->orientation();
-		bool tickAbove = sl->tickmarks() == TQSlider::Above;
-		bool tickBelow = sl->tickmarks() == TQSlider::Below;
+		Orientation orient = ceData.orientation;
+		bool tickAbove = ceData.tickMarkSetting == TQSlider::Above;
+		bool tickBelow = ceData.tickMarkSetting == TQSlider::Below;
 
 		p->fillRect( x, y, wi, he, cg.brush( TQColorGroup::Background ) );
 
 		if ( flags & Style_HasFocus ) {
-		    TQRect re = subRect( SR_SliderFocusRect, sl );
-		    drawPrimitive( PE_FocusRect, p, re, cg );
+		    TQRect re = subRect( SR_SliderFocusRect, ceData, elementFlags, widget );
+		    drawPrimitive( PE_FocusRect, p, ceData, elementFlags, re, cg );
 		}
 
 		if ( (tickAbove && tickBelow) || (!tickAbove && !tickBelow) ) {
@@ -2032,8 +1924,8 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 #endif // QT_NO_SLIDER
 
     default:
-	TQCommonStyle::drawComplexControl( ctrl, p, widget, r, cg, flags, sub,
-					  subActive, opt );
+	TQCommonStyle::drawComplexControl( ctrl, p, ceData, elementFlags, r, cg, flags, sub,
+					  subActive, opt, widget );
 	break;
     }
 }
@@ -2041,9 +1933,11 @@ void TQWindowsStyle::drawComplexControl( ComplexControl ctrl, TQPainter *p,
 
 /*! \reimp */
 int TQWindowsStyle::styleHint( StyleHint hint,
-			      const TQWidget *widget,
+			      TQStyleControlElementData ceData,
+			      ControlElementFlags elementFlags,
 			      const TQStyleOption &opt,
-			      TQStyleHintReturn *returnData ) const
+			      TQStyleHintReturn *returnData,
+			      const TQWidget *widget ) const
 {
     int ret;
 
@@ -2063,11 +1957,6 @@ int TQWindowsStyle::styleHint( StyleHint hint,
 	break;
 
     case SH_ItemView_ChangeHighlightOnFocus:
-#if defined(Q_WS_WIN)
-	if ( qWinVersion() != WV_95 && qWinVersion() != WV_NT )
-	    ret = 1;
-	else
-#endif
 	    ret = 0;
 	break;
 
@@ -2075,59 +1964,8 @@ int TQWindowsStyle::styleHint( StyleHint hint,
 	ret = 0;
 	break;
 
-#if defined(Q_WS_WIN)
-    case SH_UnderlineAccelerator:
-	ret = 1;
-	if ( qWinVersion() != WV_95 && qWinVersion() != WV_98 && qWinVersion() != WV_NT ) {
-	    BOOL cues;
-	    SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &cues, 0);
-	    ret = cues ? 1 : 0;
-	    // Do nothing if we always paint underlines
-	    if (!ret && widget && d) {
-		TQMenuBar *menuBar = ::tqt_cast<TQMenuBar*>(widget);
-		TQPopupMenu *popupMenu = 0;
-		if (!menuBar)
-		    popupMenu = ::tqt_cast<TQPopupMenu*>(widget);
-
-		// If we paint a menubar draw underlines if it has focus, or if alt is down,
-		// or if a popup menu belonging to the menubar is active and paints underlines
-		if (menuBar) {
-		    if (menuBar->hasFocus()) {
-			ret = 1;
-		    } else if (d->altDown()) {
-			ret = 1;
-		    } else if (tqApp->focusWidget() && tqApp->focusWidget()->isPopup()) {
-			popupMenu = ::tqt_cast<TQPopupMenu*>(tqApp->focusWidget());
-			TQMenuData *pm = popupMenu ? (TQMenuData*)popupMenu->tqt_cast("TQMenuData") : 0;
-			if (pm && ((FriendlyMenuData*)pm)->parentMenu == menuBar) {
-			    if (d->hasSeenAlt(menuBar))
-				ret = 1;
-			}
-		    }
-		// If we paint a popup menu draw underlines if the respective menubar does
-		} else if (popupMenu) {
-		    TQMenuData *pm = (TQMenuData*)popupMenu->tqt_cast("TQMenuData");
-		    while (pm) {
-			if (((FriendlyMenuData*)pm)->isMenuBar) {
-			    menuBar = (TQMenuBar*)pm;
-			    if (d->hasSeenAlt(menuBar))
-				ret = 1;
-			    break;
-			}
-			pm = ((FriendlyMenuData*)pm)->parentMenu;
-		    }
-		// Otherwise draw underlines if the toplevel widget has seen an alt-press
-		} else if (d->hasSeenAlt(widget)) {
-		    ret = 1;
-		}
-	    }
-
-	}
-	break;
-#endif
-
     default:
-	ret = TQCommonStyle::styleHint(hint, widget, opt, returnData);
+	ret = TQCommonStyle::styleHint(hint, ceData, elementFlags, opt, returnData, widget);
 	break;
     }
 
@@ -2135,7 +1973,7 @@ int TQWindowsStyle::styleHint( StyleHint hint,
 }
 
 /*! \reimp */
-TQRect TQWindowsStyle::subRect(SubRect r, const TQWidget *widget) const
+TQRect TQWindowsStyle::subRect(SubRect r, const TQStyleControlElementData ceData, const ControlElementFlags elementFlags, const TQWidget *widget) const
 {
     TQRect rect;
 
@@ -2143,15 +1981,15 @@ TQRect TQWindowsStyle::subRect(SubRect r, const TQWidget *widget) const
 #ifndef QT_NO_SLIDER
     case SR_SliderFocusRect:
 	{
-	    rect = widget->rect();
+	    rect = ceData.rect;
 	    break;
 	}
 #endif // QT_NO_SLIDER
     case SR_ToolBoxTabContents:
-	rect = widget->rect();
+	rect = ceData.rect;
 	break;
     default:
-	rect = TQCommonStyle::subRect( r, widget );
+	rect = TQCommonStyle::subRect( r, ceData, elementFlags, widget );
 	break;
     }
 
diff --git a/src/tools/ntqglobal.h b/src/tools/ntqglobal.h
index de5ed88e..bc8cb99d 100644
--- a/src/tools/ntqglobal.h
+++ b/src/tools/ntqglobal.h
@@ -43,11 +43,11 @@
 
 #define TQT_REAL_TQT 1
 
-#define TQT_VERSION_STR   "3.4.0"
+#define TQT_VERSION_STR   "3.5.0"
 /*
    TQT_VERSION is (major << 16) + (minor << 8) + patch.
  */
-#define TQT_VERSION 0x030400
+#define TQT_VERSION 0x030500
 
 /*
    The operating system, must be one of: (Q_OS_x)
diff --git a/src/widgets/qdialogbuttons.cpp b/src/widgets/qdialogbuttons.cpp
index 0762e6c7..4153fb59 100644
--- a/src/widgets/qdialogbuttons.cpp
+++ b/src/widgets/qdialogbuttons.cpp
@@ -150,6 +150,12 @@ TQDialogButtons::isButtonVisible(Button button) const
     return ((int)(d->visible & button)) == button;
 }
 
+TQ_UINT32
+TQDialogButtons::visibleButtons() const
+{
+    return d->visible;
+}
+
 void
 TQDialogButtons::addWidget(TQWidget *w)
 {
diff --git a/src/widgets/qdialogbuttons_p.h b/src/widgets/qdialogbuttons_p.h
index d41c6bea..85507ec1 100644
--- a/src/widgets/qdialogbuttons_p.h
+++ b/src/widgets/qdialogbuttons_p.h
@@ -72,6 +72,7 @@ public:
     inline void hideButton(Button b) { setButtonVisible(b, FALSE); }
     virtual void setButtonVisible(Button, bool visible);
     bool isButtonVisible(Button) const;
+    TQ_UINT32 visibleButtons() const;
 
     void addWidget(TQWidget *);
 
diff --git a/src/widgets/qgroupbox.cpp b/src/widgets/qgroupbox.cpp
index d78ae735..39f43a47 100644
--- a/src/widgets/qgroupbox.cpp
+++ b/src/widgets/qgroupbox.cpp
@@ -364,8 +364,9 @@ void TQGroupBox::paintEvent( TQPaintEvent *event )
 	if(va & AlignTop)
 	    r.moveBy(0, fm.descent());
 	TQColor pen( (TQRgb) style().styleHint(TQStyle::SH_GroupBox_TextLabelColor, this )  );
-	if (!style().styleHint(TQStyle::SH_UnderlineAccelerator, this))
+	if ((!style().styleHint(TQStyle::SH_UnderlineAccelerator, this)) || ((style().styleHint(TQStyle::SH_HideUnderlineAcceleratorWhenAltUp, this)) && (!style().acceleratorsShown()))) {
 	    va |= NoAccel;
+	}
 	style().drawItem( &paint, r, ShowPrefix | AlignHCenter | va, colorGroup(),
 			  isEnabled(), 0, str, -1, ownPalette() ? 0 : &pen );
 	paint.setClipRegion( event->region().subtract( r ) ); // clip everything but title
diff --git a/src/widgets/qlabel.cpp b/src/widgets/qlabel.cpp
index c78b9910..314bfe21 100644
--- a/src/widgets/qlabel.cpp
+++ b/src/widgets/qlabel.cpp
@@ -838,8 +838,9 @@ void TQLabel::drawContents( TQPainter *p )
 	}
 #endif
 	int alignment = align;
-	if ((align & ShowPrefix) && !style().styleHint(TQStyle::SH_UnderlineAccelerator, this))
+	if ((align & ShowPrefix) && ((!style().styleHint(TQStyle::SH_UnderlineAccelerator, this)) || ((style().styleHint(TQStyle::SH_HideUnderlineAcceleratorWhenAltUp, this)) && (!style().acceleratorsShown())))) {
 	    alignment |= NoAccel;
+	}
 	// ordinary text or pixmap label
 	style().drawItem( p, cr, alignment, colorGroup(), isEnabled(),
 			  pix, ltext );
diff --git a/src/widgets/qtabbar.cpp b/src/widgets/qtabbar.cpp
index 697b28f5..caa8e7d1 100644
--- a/src/widgets/qtabbar.cpp
+++ b/src/widgets/qtabbar.cpp
@@ -335,7 +335,7 @@ private:
 */
 
 TQTabBar::TQTabBar( TQWidget * parent, const char *name )
-    : TQWidget( parent, name, WNoAutoErase | WNoMousePropagation  )
+    : TQWidget( parent, name, WNoAutoErase | WNoMousePropagation  ), l(NULL)
 {
     d = new TQTabPrivate;
     d->pressed = 0;
@@ -839,7 +839,10 @@ void TQTabBar::show()
 
 int TQTabBar::currentTab() const
 {
-    const TQTab * t = l->getLast();
+    const TQTab * t = 0;
+    if (l) {
+        t = l->getLast();
+    }
 
     return t ? t->id : -1;
 }
@@ -965,10 +968,12 @@ void TQTabBar::keyPressEvent( TQKeyEvent * e )
 
 TQTab * TQTabBar::tab( int id ) const
 {
-    TQTab * t;
-    for( t = l->first(); t; t = l->next() )
-	if ( t && t->id == id )
-	    return t;
+    if (l) {
+	TQTab * t;
+	for( t = l->first(); t; t = l->next() )
+	    if ( t && t->id == id )
+		return t;
+    }
     return 0;
 }
 
@@ -982,7 +987,8 @@ TQTab * TQTabBar::tab( int id ) const
 TQTab * TQTabBar::tabAt( int index ) const
 {
     TQTab * t;
-    t = lstatic->at( index );
+    TQPtrList<TQTab> internalList = *lstatic;
+    t = internalList.at( index );
     return t;
 }
 
@@ -996,8 +1002,9 @@ TQTab * TQTabBar::tabAt( int index ) const
 int TQTabBar::indexOf( int id ) const
 {
     TQTab * t;
+    TQPtrList<TQTab> internalList = *lstatic;
     int idx = 0;
-    for( t = lstatic->first(); t; t = lstatic->next() ) {
+    for( t = internalList.first(); t; t = internalList.next() ) {
 	if ( t && t->id == id )
 	    return idx;
 	idx++;
@@ -1014,7 +1021,10 @@ int TQTabBar::indexOf( int id ) const
 */
 int TQTabBar::count() const
 {
-    return l->count();
+    if (l) {
+	return l->count();
+    }
+    return 0;
 }
 
 
diff --git a/src/widgets/qtoolbox.cpp b/src/widgets/qtoolbox.cpp
index 74f1e604..d1c30012 100644
--- a/src/widgets/qtoolbox.cpp
+++ b/src/widgets/qtoolbox.cpp
@@ -240,8 +240,9 @@ void TQToolBoxButton::drawButton( TQPainter *p )
 	fill = &cg.color( TQPalette::foregroundRoleFromMode( tb->backgroundMode() ) );
 
     int alignment = AlignLeft | AlignVCenter | ShowPrefix;
-    if (!style().styleHint(TQStyle::SH_UnderlineAccelerator, this))
+    if ((!style().styleHint(TQStyle::SH_UnderlineAccelerator, this)) || ((style().styleHint(TQStyle::SH_HideUnderlineAcceleratorWhenAltUp, this)) && (!style().acceleratorsShown()))) {
 	alignment |= NoAccel;
+    }
     style().drawItem( p, tr, alignment, cg,
 		      isEnabled(), 0, txt, -1, fill );